ose_stackops.h

Go to the documentation of this file.

/*
  Copyright (c) 2019-23 John MacCallum Permission is hereby
  granted, free of charge, to any person obtaining a copy of this
  software and associated documentation files (the "Software"), to
  deal in the Software without restriction, including without
  limitation the rights to use, copy, modify, merge, publish,
  distribute, sublicense, and/or sell copies of the Software, and
  to permit persons to whom the Software is furnished to do so,
  subject to the following conditions:
 
  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  OTHER DEALINGS IN THE SOFTWARE.
*/
 
#ifndef OSE_STACKOPS_H
#define OSE_STACKOPS_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "ose.h"
#include "ose_util.h"
#include "ose_errno.h"
 
#define OSE_START_BUNDLE(B) {                               \
    ose_pushBundle(B);                                      \
    int32_t ose_stackops_reserved_o___ =                    \
        ose_getLastBundleElemOffset(B);                     \
    int32_t ose_stackops_reserved_bs___ = ose_readSize(B);
 
#define OSE_END_BUNDLE(B)                                   \
    int32_t ose_stackops_reserved_nbs___ = ose_readSize(B); \
    ose_writeInt32(B, ose_stackops_reserved_o___,           \
                   OSE_BUNDLE_HEADER_LEN +                  \
                   (ose_stackops_reserved_nbs___ -          \
                    ose_stackops_reserved_bs___));          \
}
 
void ose_pushInt32(ose_bundle B, int32_t v);
 
void ose_pushFloat(ose_bundle B, float v);
 
void ose_pushString(ose_bundle B,
                    const char * const v);
 
void ose_pushStringBelowAtOffset(ose_bundle B,
                                 const int32_t offset,
                                 const char * const s,
                                 const int32_t slen);
void ose_pushStringBelow(ose_bundle B,
                         const char * const s,
                         const int32_t slen);
 
void ose_pushBlob(ose_bundle B,
                  int32_t size,
                  const char * const blob);
 
#ifdef OSE_PROVIDE_TYPE_SYMBOL
void ose_pushSymbol(ose_bundle B, const char * const v);
#endif
 
#ifdef OSE_PROVIDE_TYPE_DOUBLE
void ose_pushDouble(ose_bundle B, double v);
#endif
 
#ifdef OSE_PROVIDE_TYPE_INT8
void ose_pushInt8(ose_bundle B, int8_t v);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT8
void ose_pushUInt8(ose_bundle B, uint8_t v);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT32
void ose_pushUInt32(ose_bundle B, uint32_t v);
#endif
 
#ifdef OSE_PROVIDE_TYPE_INT64
void ose_pushInt64(ose_bundle B, int64_t v);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT64
void ose_pushUInt64(ose_bundle B, uint64_t v);
#endif
 
#ifdef OSE_PROVIDE_TYPE_TIMETAG
void ose_pushTimetag(ose_bundle B, uint32_t sec, uint32_t fsec);
#endif
 
#ifdef OSE_PROVIDE_TYPE_TRUE
void ose_pushTrue(ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_FALSE
void ose_pushFalse(ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_NIL
void ose_pushNil(ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_INFINITUM
void ose_pushInfinitum(ose_bundle B);
#endif
 
#define OSE_MAXLINE 4096
 
void ose_pushAlignedPtr(ose_bundle B, const void *v, const char * const name);
 
void ose_pushFnMessage(ose_bundle B,
                       const char * const address,
                       int32_t addresslen,
                       ose_fn fn,
                       const char * const name);
 
void ose_pushLines(ose_bundle B, const char * const src);
 
#ifndef SWIGCSHARP
void ose_pushMessage(ose_bundle B,
                     const char * const address,
                     int32_t addresslen,
                     int32_t n,
                     ...);
#endif
 
 
char *ose_peekAddress(const ose_bundle B);
 
char ose_peekMessageArgTypeAtOffset(const ose_bundle B,
                                    const int32_t messageoffset);
 
char ose_peekMessageArgType(const ose_bundle B);
 
char ose_peekType(const ose_bundle B);
 
int32_t ose_peekInt32(ose_constbundle B);
 
float ose_peekFloat(ose_constbundle B);
 
char *ose_peekString(ose_constbundle B);
 
char *ose_peekBlob(ose_constbundle B);
 
#ifdef OSE_PROVIDE_TYPE_SYMBOL
char *ose_peekSymbol(const ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_DOUBLE
double ose_peekDouble(const ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_INT8
int8_t ose_peekInt8(const ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT8
uint8_t ose_peekUInt8(const ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT32
uint32_t ose_peekUInt32(const ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_INT16
int16_t ose_peekInt16(const ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT16
uint16_t ose_peekUInt16(const ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_INT64
int64_t ose_peekInt64(const ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT64
uint64_t ose_peekUInt64(const ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_TIMETAG
struct ose_timetag ose_peekTimetag(const ose_bundle B);
#endif
 
const void *ose_peekAlignedPtr(ose_bundle B);
 
int32_t ose_popInt32(ose_bundle B);
 
float ose_popFloat(ose_bundle B);
 
int32_t ose_popString(ose_bundle B, char *buf);
 
int32_t ose_popBlob(ose_bundle B, char *buf);
 
#ifdef OSE_PROVIDE_TYPE_SYMBOL
int32_t ose_popSymbol(ose_bundle B, char *buf);
#endif
 
#ifdef OSE_PROVIDE_TYPE_DOUBLE
double ose_popDouble(ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_INT8
int8_t ose_popInt8(ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT8
uint8_t ose_popUInt8(ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT32
uint32_t ose_popUInt32(ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_INT64
int64_t ose_popInt64(ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_UINT64
uint64_t ose_popUInt64(ose_bundle B);
#endif
 
#ifdef OSE_PROVIDE_TYPE_TIMETAG
struct ose_timetag ose_popTimetag(ose_bundle B);
#endif
 
 
void ose_drop(ose_bundle B);
 
void ose_2drop(ose_bundle B);
 
void ose_dup(ose_bundle B);
 
void ose_2dup(ose_bundle B);
 
void ose_nip_impl(ose_bundle B,
                  int32_t onm1,
                  int32_t snm1,
                  int32_t on,
                  int32_t sn);
    
void ose_nip(ose_bundle B);
 
void ose_rot(ose_bundle B);
 
void ose_rrot(ose_bundle B);
 
void ose_over(ose_bundle B);
 
void ose_2over(ose_bundle B);
 
void ose_pick(ose_bundle B);
 
void ose_roll(ose_bundle B);
 
void ose_pickBottom(ose_bundle B);
 
void ose_rollBottom(ose_bundle B);
 
int32_t ose_pickMatch_impl(ose_bundle B);
void ose_pickMatch(ose_bundle B);
int32_t ose_pickPMatch_impl(ose_bundle B);
void ose_pickPMatch(ose_bundle B);
 
int32_t ose_rollMatch_impl(ose_bundle B);
void ose_rollMatch(ose_bundle B);
int32_t ose_rollPMatch_impl(ose_bundle B);
void ose_rollPMatch(ose_bundle B);
 
void ose_swap(ose_bundle B);
 
void ose_2swap(ose_bundle B);
 
void ose_tuck(ose_bundle B);
 
 
void ose_bundleAll(ose_bundle B);
 
void ose_bundleFromBottom(ose_bundle B);
 
void ose_bundleFromTop(ose_bundle B);
 
void ose_clear(ose_bundle B);
 
void ose_popAtOffset(ose_bundle B, int32_t o);
 
void ose_pop(ose_bundle B);
 
void ose_popAll(ose_bundle B);
 
void ose_popAllDrop(ose_bundle B);
 
void ose_popAllBundle(ose_bundle B);
 
void ose_popAllDropBundle(ose_bundle B);
 
void ose_reverse(ose_bundle B);
 
void ose_push(ose_bundle B);
 
void ose_decatenateElemFromEnd(ose_bundle B);
 
void ose_decatenateElemFromStart(ose_bundle B);
 
void ose_concatenateElems(ose_bundle B);
 
void ose_unpack(ose_bundle B);
 
void ose_unpackDrop(ose_bundle B);
 
 
void ose_countElems(ose_bundle B);
 
void ose_countItems(ose_bundle B);
 
void ose_lengthItem(ose_bundle B);
 
void ose_lengthsItems(ose_bundle B);
 
void ose_sizeElem(ose_bundle B);
 
void ose_sizeItem(ose_bundle B);
 
void ose_sizesElems(ose_bundle B);
 
void ose_sizesItems(ose_bundle B);
 
void ose_getAddresses(ose_bundle B);
 
void ose_setTimetag(ose_bundle B);
 
void ose_getTimetag(ose_bundle B);
 
void ose_getTypetags(ose_bundle B);
 
void ose_elemIsBundle(ose_bundle B);
 
void ose_typeof0(ose_bundle B);
 
void ose_typeof1(ose_bundle B);
 
void ose_typeof2(ose_bundle B);
 
 
void ose_setTypetagAtOffset_impl(ose_bundle B,
                                 char typetag,
                                 int32_t offset);
 
void ose_setTypetag_impl(ose_bundle B, char typetag);
 
void ose_setTypetag(ose_bundle B);
 
#ifdef OSE_CONF_VALIDATION_MEMO_BYTES
#define OSE_VMEMO_N 16
struct ose_vmemo
{
    int32_t used;
    int32_t count;
    struct
    {
        int32_t off, len;
    } entry[OSE_VMEMO_N];
    char bytes[OSE_CONF_VALIDATION_MEMO_BYTES] __attribute__((aligned(4)));
};
#endif
 
void ose_blobToElemAtOffset(ose_bundle B, int32_t offset);
 
typedef int (*ose_resolveNameFn)(void *ctx, const char *name,
                                 ose_fn *fn, const char **canon);
 
int32_t ose_disarmPointers(ose_bundle B);
 
int32_t ose_countPointers(ose_bundle B, int32_t *live, int32_t *byname);
 
int32_t ose_rearmPointers(ose_bundle B,
                          ose_resolveNameFn resolve,
                          void *ctx,
                          int32_t *stayed);
 
void ose_blobToElem(ose_bundle B);
 
void ose_blobToType_impl(ose_bundle B, char typetag);
 
void ose_blobToType(ose_bundle B);
 
void ose_toType(ose_bundle B);
 
void ose_toInt32(ose_bundle B);
 
void ose_toFloat(ose_bundle B);
 
void ose_toString(ose_bundle B);
 
void ose_toBlob(ose_bundle B);
 
 
void ose_appendByte(ose_bundle B);
#ifdef OSE_PROVIDE_TYPE_SYMBOL
void ose_toSymbol(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_DOUBLE
void ose_toDouble(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_INT8
void ose_toInt8(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT8
void ose_toUInt8(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_INT16
void ose_toInt16(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT16
void ose_toUInt16(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT32
void ose_toUInt32(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_INT64
void ose_toInt64(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT64
void ose_toUInt64(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_TIMETAG
void ose_toTimetag(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_TRUE
void ose_toTrue(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_FALSE
void ose_toFalse(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_NIL
void ose_toNil(ose_bundle B);
#endif
#ifdef OSE_PROVIDE_TYPE_INFINITUM
void ose_toInfinitum(ose_bundle B);
#endif
 
void ose_concatenateBlobs(ose_bundle B);
 
void ose_concatenateStrings(ose_bundle B);
 
void ose_swapStringToAddress(ose_bundle B);
 
void ose_moveStringToAddress(ose_bundle B);
 
void ose_decatenateBlobFromEnd_impl(ose_bundle B, int32_t n);
void ose_decatenateBlobFromEnd(ose_bundle B);
void ose_decatenateBlobFromStart_impl(ose_bundle B, int32_t n);
void ose_decatenateBlobFromStart(ose_bundle B);
void ose_decatenateStringFromEnd_impl(ose_bundle B, int32_t n);
void ose_decatenateStringFromEnd(ose_bundle B);
void ose_decatenateStringFromStart_impl(ose_bundle B, int32_t n);
void ose_decatenateStringFromStart(ose_bundle B);
 
void ose_elemToBlob(ose_bundle B);
 
void ose_itemToBlob(ose_bundle B);
 
void ose_joinStrings(ose_bundle B);
void ose_splitStringFromEnd(ose_bundle B);
void ose_splitStringFromStart(ose_bundle B);
void ose_swap4Bytes(ose_bundle B);
void ose_swap8Bytes(ose_bundle B);
void ose_swapNBytes(ose_bundle B);
void ose_trimStringEnd(ose_bundle B);
void ose_trimStringStart(ose_bundle B);
 
 
void ose_match(ose_bundle B);
 
void ose_pmatch(ose_bundle B);
void ose_replace(ose_bundle B);
void ose_assign(ose_bundle B);
void ose_lookup(ose_bundle B);
void ose_plookup(ose_bundle B);
 
void ose_route1(ose_bundle B);
 
void ose_routeWithDelegation(ose_bundle B);
 
void ose_select1(ose_bundle B);
 
void ose_selectWithDelegation(ose_bundle B);
 
void ose_gather(ose_bundle B);
 
void ose_nth(ose_bundle B);
 
 
void ose_makeBlob(ose_bundle B);
 
void ose_pushBundle(ose_bundle B);
 
 
void ose_add(ose_bundle B);
 
void ose_sub(ose_bundle B);
 
void ose_mul(ose_bundle B);
 
void ose_div(ose_bundle B);
 
void ose_mod(ose_bundle B);
 
void ose_pow(ose_bundle B);
 
void ose_neg(ose_bundle B);
 
void ose_eql(ose_bundle B);
 
void ose_neq(ose_bundle B);
 
void ose_lte(ose_bundle B);
void ose_gt(ose_bundle B);
void ose_gte(ose_bundle B);
void ose_min(ose_bundle B);
void ose_max(ose_bundle B);
void ose_abs(ose_bundle B);
void ose_not(ose_bundle B);
 
void ose_lt(ose_bundle B);
 
void ose_and(ose_bundle B);
 
void ose_or(ose_bundle B);
 
 
enum ose_errno ose_getLastBundleElem(ose_bundle B,
                                     int32_t *n,
                                     int32_t *offsetn,
                                     int32_t *sizen);
 
enum ose_errno ose_getLastTwoBundleElems(ose_bundle B,
                                         int32_t *n,
                                         int32_t *offsetnm1,
                                         int32_t *sizenm1,
                                         int32_t *offsetn,
                                         int32_t *sizen);
 
enum ose_errno ose_getLastThreeBundleElems(ose_bundle B,
                                           int32_t *n,
                                           int32_t *offsetnm2,
                                           int32_t *sizenm2,
                                           int32_t *offsetnm1,
                                           int32_t *sizenm1,
                                           int32_t *offsetn,
                                           int32_t *sizen);
 
enum ose_errno ose_getLastFourBundleElems(ose_bundle B,
                                          int32_t *n,
                                          int32_t *offsetnm3,
                                          int32_t *sizenm3,
                                          int32_t *offsetnm2,
                                          int32_t *sizenm2,
                                          int32_t *offsetnm1,
                                          int32_t *sizenm1,
                                          int32_t *offsetn,
                                          int32_t *sizen);
 
#ifdef __cplusplus
}
#endif
 
#endif