ose.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_H
#define OSE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <limits.h>
#if !defined(SWIG) && CHAR_BIT != 8
#error "Unsupported hardware (CHAR_BIT != 8)"
#endif
 
#include <inttypes.h>
 
/* avr-libc has no 64-bit printf formats and none of strtof(), strtoll() or
   strtoull(). Its printf prints a 64-bit integer as "?" whatever the
   format, so the formats only have to compile; strtod() is float there, and
   the integers are read at 32 bits, which is what the part has. */
#if defined(__AVR__)
#include <stdlib.h>
#ifndef PRId64
#define PRId64 "ld"
#endif
#ifndef PRIu64
#define PRIu64 "lu"
#endif
#define strtof(s, e) ((float)strtod((s), (e)))
#define strtoll(s, e, b) ((long long)strtol((s), (e), (b)))
#define strtoull(s, e, b) ((unsigned long long)strtoul((s), (e), (b)))
#endif
 
/* Would be nice to use this, but the compiler for the */
/* ESP8266 doesn't support it :( */
/* #if __has_include("sys/ose_endian.h") */
/* #include "sys/ose_endian.h" */
/* #endif */
#ifdef HAVE_OSE_ENDIAN_H
#include "sys/ose_endian.h"
#endif
 
#ifdef OSE_IN_DOXYGEN
#define OSE_CONF_DEBUG
 
#define OSE_CONF_MEMPROFILE
#endif
 
#ifdef OSE_IN_DOXYGEN
#define OSE_CONF_WRAP_BUNDLE_PTR
#endif
 
#ifdef OSE_CONF_WRAP_BUNDLE_PTR
#define OSE_WRAP_BUNDLE_PTR
#endif
 
#ifdef OSE_CONF_MEMPROFILE
#define OSE_MEMPROFILE
#endif
 
#ifdef OSE_CONF_HOT
#define OSE_HOT OSE_CONF_HOT
#else
#define OSE_HOT
#endif
 
#ifdef ESP_PLATFORM
#include <stddef.h>
void *ose_memmove(void *dst, const void *src, size_t n);
#else
#define ose_memmove memmove
#endif
 
#ifdef OSE_CONF_VALIDATE_VM_STEP
#define OSE_VALIDATE_VM_STEP
#endif
 
#ifdef OSE_CONF_DEBUG
#ifdef NDEBUG
#undef NDEBUG
#endif
#ifndef OSE_DEBUG
#define OSE_DEBUG
#endif
#ifndef OSE_WRAP_BUNDLE_PTR
#define OSE_WRAP_BUNDLE_PTR
#endif
#ifndef OSE_MEMPROFILE
#define OSE_MEMPROFILE
#endif
#else
#ifndef NDEBUG
#define NDEBUG
#endif
#endif
 
#if defined (__unix__) \
    || ( defined (__APPLE__)                    \
         && defined (__MACH__) ) \
    || defined (__EMSCRIPTEN__)
#include <arpa/inet.h>
#elif defined (_WIN32) || defined (_WIN64)
#include <Windows.h>
#include <Winsock.h>
#else
 
#ifndef htonl
#define OSE_NEED_HTONL
int32_t htonl(int32_t x);
#define OSE_BYTE_SWAP32(x)                      \
    ((((x) & 0xff000000) >> 24) |               \
     (((x) & 0x00ff0000) >> 8) |                \
     (((x) & 0x0000ff00) << 8) |                \
     (((x) & 0x000000ff) << 24))
#endif
 
#ifndef ntohl
#define OSE_NEED_NTOHL
int32_t ntohl(int32_t x);
#define OSE_BYTE_SWAP64(x)                      \
    ((((x) & 0xff00000000000000LL) >> 56) |     \
     (((x) & 0x00ff000000000000LL) >> 40) |     \
     (((x) & 0x0000ff0000000000LL) >> 24) |     \
     (((x) & 0x000000ff00000000LL) >> 8)  |     \
     (((x) & 0x00000000ff000000LL) << 8)  |     \
     (((x) & 0x0000000000ff0000LL) << 24) |     \
     (((x) & 0x000000000000ff00LL) << 40) |     \
     (((x) & 0x00000000000000ffLL) << 56))
#endif
#endif
 
 
#define ose_htonl(x) htonl(x)
#define ose_ntohl(x) ntohl(x)
#ifndef htonll
#define ose_htonll(x)                               \
    ((1==ose_htonl(1))                              \
     ? (x)                                          \
     : ((uint64_t)ose_htonl((x)                     \
                            & 0xFFFFFFFF) << 32)    \
     | ose_htonl((x) >> 32))
#else
#define ose_htonll(x) htonll(x)
#endif
 
#ifndef ntohll
#define ose_ntohll(x)                               \
    ((1==ose_ntohl(1))                              \
     ? (x)                                          \
     : ((uint64_t)ose_ntohl((x)                     \
                            & 0xFFFFFFFF) << 32)    \
     | ose_ntohl((x) >> 32))
#else
#define ose_ntohll(x) ntohll(x)
#endif
 
#define OSE_INT32_TO_BUF_SWAP(buf, i)           \
    {                                           \
        (buf)[0] = ((i) & 0xFF000000) >> 24;    \
        (buf)[1] = ((i) & 0x00FF0000) >> 16;    \
        (buf)[2] = ((i) & 0x0000FF00) >> 8;     \
        (buf)[3] = ((i) & 0x000000FF);          \
    }
#define OSE_INT32_TO_BUF(buf, i) memcpy((buf), &(i), 4);
 
#define OSE_INT64_TO_BUF_SWAP(buf, i)                   \
    {                                                   \
        (buf)[0] = ((i) & 0xFF00000000000000) >> 56;    \
        (buf)[1] = ((i) & 0x00FF000000000000) >> 48;    \
        (buf)[2] = ((i) & 0x0000FF0000000000) >> 40;    \
        (buf)[3] = ((i) & 0x000000FF00000000) >> 32;    \
        (buf)[4] = ((i) & 0x00000000FF000000) >> 24;    \
        (buf)[5] = ((i) & 0x0000000000FF0000) >> 16;    \
        (buf)[6] = ((i) & 0x000000000000FF00) >> 8;     \
        (buf)[7] = ((i) & 0x00000000000000FF);          \
    }
#define OSE_INT64_TO_BUF(buf, i) memcpy((buf), &(i), 8);
 
#define OSE_BUF_TO_INT32_SWAP(buf, i)           \
    {                                           \
        i = (((uint64_t)b[0]) & 0xFF) << 24     \
            | (((uint64_t)b[1]) & 0xFF) << 16   \
            | (((uint64_t)b[2]) & 0xFF) << 8    \
            | (((uint64_t)b[3]) & 0xFF);        \
    }
#define OSE_BUF_TO_INT32(buf, i) memcpy(&(i), (buf), 4);
 
#define OSE_BUF_TO_INT64_SWAP(buf, i)           \
    {                                           \
        i = (((uint64_t)b[0]) & 0xFF) << 56     \
            | (((uint64_t)b[1]) & 0xFF) << 48   \
            | (((uint64_t)b[2]) & 0xFF) << 40   \
            | (((uint64_t)b[3]) & 0xFF) << 32   \
            | (((uint64_t)b[4]) & 0xFF) << 24   \
            | (((uint64_t)b[5]) & 0xFF) << 16   \
            | (((uint64_t)b[6]) & 0xFF) << 8    \
            | (((uint64_t)b[7]) & 0xFF);        \
    }
#define OSE_BUF_TO_INT64(buf, i) memcpy(&(i), (buf), 8);
 
#if defined(OSE_ENDIAN)
#if OSE_ENDIAN == OSE_LITTLE_ENDIAN
#define OSE_BYTE_SWAP32_INT_TO_BUF(buf, i)\
    OSE_INT32_TO_BUF_SWAP(buf, i)
#define OSE_BYTE_SWAP64_INT_TO_BUF(buf, i)\
    OSE_INT64_TO_BUF_SWAP(buf, i)
 
#define OSE_BYTE_SWAP32_BUF_TO_INT(buf, i)\
    OSE_BUF_TO_INT32_SWAP(buf, i)
#define OSE_BYTE_SWAP64_BUF_TO_INT(buf, i)\
    OSE_BUF_TO_INT64_SWAP(buf, i)
 
#else  /* OSE_BIG_ENDIAN */
 
#define OSE_BYTE_SWAP32_INT_TO_BUF(buf, i)\
    OSE_INT32_TO_BUF(buf, i)
#define OSE_BYTE_SWAP64_INT_TO_BUF(buf, i)\
    OSE_INT64_TO_BUF(buf, i)
 
#define OSE_BYTE_SWAP32_BUF_TO_INT(buf, i)\
    OSE_BUF_TO_INT32(buf, i)
#define OSE_BYTE_SWAP64_BUF_TO_INT(buf, i)\
    OSE_BUF_TO_INT64(buf, i)
 
#endif
 
#else  /* defined(OSE_ENDIAN) */
 
#define OSE_BYTE_SWAP32_INT_TO_BUF(buf, i)      \
    if(ose_ntohl(1) == 1)                       \
    {                                           \
        OSE_INT32_TO_BUF(buf, i);               \
    }                                           \
    else                                        \
    {                                           \
        OSE_INT32_TO_BUF_SWAP(buf, i);          \
    }
#define OSE_BYTE_SWAP64_INT_TO_BUF(buf, i)      \
    if(ose_ntohl(1) == 1)                       \
    {                                           \
        OSE_INT64_TO_BUF(buf, i);               \
    }                                           \
    else                                        \
    {                                           \
        OSE_INT64_TO_BUF_SWAP(buf, i);          \
    }
 
#define OSE_BYTE_SWAP32_BUF_TO_INT(buf, i)      \
    if(ose_ntohl(1) == 1)                       \
    {                                           \
        OSE_BUF_TO_INT32(buf, i);               \
    }                                           \
    else                                        \
    {                                           \
        OSE_BUF_TO_INT32_SWAP(buf, i);          \
    }
#define OSE_BYTE_SWAP64_BUF_TO_INT(buf, i)      \
    if(ose_ntohl(1) == 1)                       \
    {                                           \
        OSE_BUF_TO_INT64(buf, i);               \
    }                                           \
    else                                        \
    {                                           \
        OSE_BUF_TO_INT64_SWAP(buf, i);          \
    }
 
#endif
 
#ifdef OSE_WRAP_BUNDLE_PTR
typedef struct ose_bundle
{
    char *b;
} ose_bundle;
#define ose_constbundle ose_bundle
ose_bundle ose_makeBundle(const char * const p);
#define ose_makeConstBundle ose_makeBundle
#define ose_getBundlePtr(bundle) (bundle).b
#else
typedef char* ose_bundle;
#define ose_makeBundle(charptr) charptr
#define ose_makeConstBundle(charptr) charptr
#define ose_getBundlePtr(bundle) (bundle)
#define ose_constbundle const char *
#endif
 
typedef void (*ose_fn)(ose_bundle);
 
#define OSE_INTPTR2 (sizeof(intptr_t) * 2)
 
struct ose_timetag
{
    uint32_t sec;               
    uint32_t fsec;              
};
 
/* C23 made bool, true and false keywords, and the compilers for the Teensy
   (gcc 15) and the RP2040 (gcc 16) build C as C23 by default. */
#if !defined(__cplusplus) && !defined(SWIG)                             \
    && !(defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L)
#ifndef __bool_true_false_are_defined
typedef enum
{
    false = 0,
    true
} bool;
#endif
#endif
 
 
#define OSETT_ID_ ','
static const char OSETT_ID = OSETT_ID_;
#define OSETTSTR_ID_ ","
static const char * const OSETTSTR_ID = OSETTSTR_ID_;
 
#define OSETT_INT32_ 'i'
static const char OSETT_INT32 = OSETT_INT32_;
#define OSETTSTR_INT32_ "i"
static const char * const OSETTSTR_INT32 = OSETTSTR_INT32_;
 
#define OSETT_FLOAT_ 'f'
static const char OSETT_FLOAT = OSETT_FLOAT_;
#define OSETTSTR_FLOAT_ "f"
static const char * const OSETTSTR_FLOAT = OSETTSTR_FLOAT_;
 
#define OSETT_STRING_ 's'
static const char OSETT_STRING = OSETT_STRING_;
#define OSETTSTR_STRING_ "s"
static const char * const OSETTSTR_STRING = OSETTSTR_STRING_;
 
#define OSETT_BLOB_ 'b'
static const char OSETT_BLOB = OSETT_BLOB_;
#define OSETTSTR_BLOB_ "b"
static const char * const OSETTSTR_BLOB = OSETTSTR_BLOB_;
 
#ifdef OSE_IN_DOXYGEN
#define OSE_CONF_PROVIDE_TYPE_SYMBOL
#define OSE_CONF_PROVIDE_TYPE_DOUBLE
#define OSE_CONF_PROVIDE_TYPE_INT8
#define OSE_CONF_PROVIDE_TYPE_UINT8
#define OSE_CONF_PROVIDE_TYPE_INT16
#define OSE_CONF_PROVIDE_TYPE_UINT16
#define OSE_CONF_PROVIDE_TYPE_UINT32
#define OSE_CONF_PROVIDE_TYPE_INT64
#define OSE_CONF_PROVIDE_TYPE_UINT64
#define OSE_CONF_PROVIDE_TYPE_TIMETAG
#define OSE_CONF_PROVIDE_TYPE_TRUE
#define OSE_CONF_PROVIDE_TYPE_FALSE
#define OSE_CONF_PROVIDE_TYPE_NIL
#define OSE_CONF_PROVIDE_TYPE_INFINITUM
#endif  /* OSE_IN_DOXYGEN */
 
#ifdef OSE_CONF_PROVIDE_TYPE_SYMBOL
#define OSE_PROVIDE_TYPE_SYMBOL
#define OSETT_SYMBOL_ 'S'
static const char OSETT_SYMBOL = OSETT_SYMBOL_;
#define OSETTSTR_SYMBOL_ "S"
static const char * const OSETTSTR_SYMBOL = OSETTSTR_SYMBOL_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_DOUBLE
#define OSE_PROVIDE_TYPE_DOUBLE
#define OSETT_DOUBLE_ 'd'
static const char OSETT_DOUBLE = OSETT_DOUBLE_;
#define OSETTSTR_DOUBLE_ "d"
static const char * const OSETTSTR_DOUBLE = OSETTSTR_DOUBLE_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_INT8
#define OSE_PROVIDE_TYPE_INT8
#define OSETT_INT8_ 'c'
static const char OSETT_INT8 = OSETT_INT8_;
#define OSETTSTR_INT8_ "c"
static const char * const OSETTSTR_INT8 = OSETTSTR_INT8_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_UINT8
#define OSE_PROVIDE_TYPE_UINT8
#define OSETT_UINT8_ 'C'
static const char OSETT_UINT8 = OSETT_UINT8_;
#define OSETTSTR_UINT8_ "C"
static const char * const OSETTSTR_UINT8 = OSETTSTR_UINT8_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_INT16
#define OSE_PROVIDE_TYPE_INT16
#define OSETT_INT16_ 'u'
static const char OSETT_INT16 = OSETT_INT16_;
#define OSETTSTR_INT16_ "u"
static const char * const OSETTSTR_INT16 = OSETTSTR_INT16_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_UINT16
#define OSE_PROVIDE_TYPE_UINT16
#define OSETT_UINT16_ 'U'
static const char OSETT_UINT16 = OSETT_UINT16_;
#define OSETTSTR_UINT16_ "U"
static const char * const OSETTSTR_UINT16 = OSETTSTR_UINT16_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_UINT32
#define OSE_PROVIDE_TYPE_UINT32
#define OSETT_UINT32_ 'k'
static const char OSETT_UINT32 = OSETT_UINT32_;
#define OSETTSTR_UINT32_ "k"
static const char * const OSETTSTR_UINT32 = OSETTSTR_UINT32_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_INT64
#define OSE_PROVIDE_TYPE_INT64
#define OSETT_INT64_ 'h'
static const char OSETT_INT64 = OSETT_INT64_;
#define OSETTSTR_INT64_ "h"
static const char * const OSETTSTR_INT64 = OSETTSTR_INT64_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_UINT64
#define OSE_PROVIDE_TYPE_UINT64
#define OSETT_UINT64_ 'H'
static const char OSETT_UINT64 = OSETT_UINT64_;
#define OSETTSTR_UINT64_ "H"
static const char * const OSETTSTR_UINT64 = OSETTSTR_UINT64_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_TIMETAG
#define OSE_PROVIDE_TYPE_TIMETAG
#define OSETT_TIMETAG_ 't'
static const char OSETT_TIMETAG = OSETT_TIMETAG_;
#define OSETTSTR_TIMETAG_ "t"
static const char * const OSETTSTR_TIMETAG = OSETTSTR_TIMETAG_;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_TRUE
#define OSE_PROVIDE_TYPE_TRUE
#define OSETT_TRUE_ 'T'
static const char OSETT_TRUE = OSETT_TRUE_;
#define OSETTSTR_TRUE_ "T"
static const char * const OSETTSTR_TRUE = OSETTSTR_TRUE_;
static const char * const ose_str_true = "/,/T";
static const int32_t ose_strlen_true = 4;
static const int32_t ose_pstrlen_true = 8;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_FALSE
#define OSE_PROVIDE_TYPE_FALSE
#define OSETT_FALSE_ 'F'
static const char OSETT_FALSE = OSETT_FALSE_;
#define OSETTSTR_FALSE_ "F"
static const char * const OSETTSTR_FALSE = OSETTSTR_FALSE_;
static const char * const ose_str_false = "/,/F";
static const int32_t ose_strlen_false = 4;
static const int32_t ose_pstrlen_false = 8;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_NIL
#define OSE_PROVIDE_TYPE_NIL
#define OSETT_NIL_ 'N'
static const char OSETT_NIL = OSETT_NIL_;
#define OSETTSTR_NIL_ "N"
static const char * const OSETTSTR_NIL = OSETTSTR_NIL_;
static const char * const ose_str_nil = "/,/N";
static const int32_t ose_strlen_nil = 4;
static const int32_t ose_pstrlen_nil = 8;
#endif
#ifdef OSE_CONF_PROVIDE_TYPE_INFINITUM
#define OSE_PROVIDE_TYPE_INFINITUM
#define OSETT_INFINITUM_ 'I'
static const char OSETT_INFINITUM = OSETT_INFINITUM_;
#define OSETTSTR_INFINITUM_ "I"
static const char * const OSETTSTR_INFINITUM = OSETTSTR_INFINITUM_;
static const char * const ose_str_infinitum = "/,/I";
static const int32_t ose_strlen_infinitum = 4;
static const int32_t ose_pstrlen_infinitum = 8;
#endif
 
/* non-osc data types
   these are never written into a bundle
   (unless they are defined above) */
#ifndef OSE_PROVIDE_TYPE_TRUE
#define OSETT_TRUE_ 'T'
static const char OSETT_TRUE = OSETT_TRUE_;
#define OSETTSTR_TRUE_ "T"
static const char * const OSETTSTR_TRUE = OSETTSTR_TRUE_;
#endif
 
#ifndef OSE_PROVIDE_TYPE_TRUE
#define OSETT_FALSE_ 'F'
static const char OSETT_FALSE = OSETT_FALSE_;
#define OSETTSTR_FALSE_ "F"
static const char * const OSETTSTR_FALSE = OSETTSTR_FALSE_;
#endif
 
#define OSETT_ALIGNEDPTR_ 'p'
static const char OSETT_ALIGNEDPTR = OSETT_ALIGNEDPTR_;
#define OSETTSTR_ALIGNEDPTR_ "p"
static const char * const OSETTSTR_ALIGNEDPTR = OSETTSTR_ALIGNEDPTR_;
 
#define OSETT_WILDPTR_ 'P'
static const char OSETT_WILDPTR = OSETT_WILDPTR_;
#define OSETTSTR_WILDPTR_ "P"
static const char * const OSETTSTR_WILDPTR = OSETTSTR_WILDPTR_;
 
#define OSETT_OPCODE_ '!'
static const char OSETT_OPCODE = OSETT_OPCODE_;
#define OSETTSTR_OPCODE_ "!"
static const char * const OSETTSTR_OPCODE = OSETTSTR_OPCODE_;
 
#define OSETT_NOTYPETAG_ 0
static const char OSETT_NOTYPETAG = OSETT_NOTYPETAG_;
#define OSETTSTR_NOTYPETAG_ "0"
static const char * const OSETTSTR_NOTYPETAG = OSETTSTR_NOTYPETAG_;
 
#define OSETT_BUNDLE_ '|'
static const char OSETT_BUNDLE = OSETT_BUNDLE_;
#define OSETTSTR_BUNDLE_ "|"
static const char * const OSETTSTR_BUNDLE = OSETTSTR_BUNDLE_;
 
#define OSETT_MESSAGE_ '-'
static const char OSETT_MESSAGE = OSETT_MESSAGE_;
#define OSETTSTR_MESSAGE_ "-"
static const char * const OSETTSTR_MESSAGE = OSETTSTR_MESSAGE_;
 
 
#define OSE_BUNDLE_ID_ "#bundle\0"
/* THE WIDTHS THE LAYOUT IS MADE OF, in one place.
 *
 * Every walk through a bundle reads a size word, steps past it, and pads
 * to an alignment. Those three numbers were written as literals in about a
 * thousand places; they are these three constants now, at the values OSC
 * fixes, so that the layout is stated once and a build that wanted a
 * narrower one (ose-design PROPOSAL-NARROW-OSC.md) would change it here.
 * An int32 or a float is still four bytes wherever one is read or
 * written: that is the item's width, not the layout's, and it stays
 * literal. */
#define OSE_SIZEWORD_LEN_ 4   /* an element's, a blob's or a pointer item's length word */
#define OSE_ALIGN_ 4          /* addresses, typetags, strings and blobs pad to this */
static const int32_t OSE_SIZEWORD_LEN = OSE_SIZEWORD_LEN_;
static const int32_t OSE_ALIGN = OSE_ALIGN_;
#define OSE_BUNDLE_ID_LEN_ 8
#define OSE_TIMETAG_NULL_ "\0\0\0\0\0\0\0\0"
#define OSE_TIMETAG_LEN_ 8
static const char * const OSE_BUNDLE_ID = OSE_BUNDLE_ID_;
static const int32_t OSE_BUNDLE_ID_LEN = OSE_BUNDLE_ID_LEN_;
static const char * const OSE_TIMETAG_NULL = OSE_TIMETAG_NULL_;
static const int32_t OSE_TIMETAG_LEN = OSE_TIMETAG_LEN_;
static const char * const OSE_BUNDLE_HEADER =
    OSE_BUNDLE_ID_ OSE_TIMETAG_NULL_;
/* The macro is what sizes an array: in C a static const int32_t is not a
   constant expression, and gcc refuses one at file scope where clang lets it
   pass. */
#define OSE_BUNDLE_HEADER_LEN_ (OSE_BUNDLE_ID_LEN_ + OSE_TIMETAG_LEN_)
static const int32_t OSE_BUNDLE_HEADER_LEN = OSE_BUNDLE_HEADER_LEN_;
 
#define OSE_EMPTY_TYPETAG_STRING_ ",\0\0\0"
static const char * const OSE_EMPTY_TYPETAG_STRING =
    OSE_EMPTY_TYPETAG_STRING_;
static const int32_t OSE_EMPTY_TYPETAG_STRING_LEN = 1;
static const int32_t OSE_EMPTY_TYPETAG_STRING_SIZE = 4;
 
/* undocumented for now -- consider dropping support for changing this */
#ifdef OSE_CONF_ADDRESS_ANONVAL
#define OSE_USER_ADDRESS_ANONVAL
#include <stdint.h>
static const char * const OSE_ADDRESS_ANONVAL =
    OSE_CONF_ADDRESS_ANONVAL;
static const int32_t OSE_ADDRESS_ANONVAL_LEN =
    OSE_CONF_ADDRESS_ANONVAL_LEN;
#define OSE_ADDRESS_ANONVAL_SIZE_ (OSE_CONF_ADDRESS_ANONVAL_SIZE)
static const int32_t OSE_ADDRESS_ANONVAL_SIZE =
    OSE_ADDRESS_ANONVAL_SIZE_;
static const char * const OSE_ADDRESS_ANONVAL_EMPTY_TYPETAG_STRING =
    OSE_CONF_ADDRESS_ANONVAL OSE_EMPTY_TYPETAG_STRING_;
 
#else  /* OSE_CONF_ADDRESS_ANONVAL */
 
#define OSE_ADDRESS_ANONVAL_ "\0\0\0\0"
static const char * const OSE_ADDRESS_ANONVAL = OSE_ADDRESS_ANONVAL_;
static const int32_t OSE_ADDRESS_ANONVAL_LEN = 0;
#define OSE_ADDRESS_ANONVAL_SIZE_ 4
static const int32_t OSE_ADDRESS_ANONVAL_SIZE = OSE_ADDRESS_ANONVAL_SIZE_;
static const char * const OSE_ADDRESS_ANONVAL_EMPTY_TYPETAG_STRING =
    OSE_ADDRESS_ANONVAL_ OSE_EMPTY_TYPETAG_STRING_;
#endif /* OSE_CONF_ADDRESS_ANONVAL */
 
static const int32_t OSE_ADDRESS_MIN_LEN = 0;
static const int32_t OSE_ADDRESS_MIN_PLEN = 4;
 
typedef int32_t (*ose_getPayloadItemLengthFn)(ose_constbundle, char,
                                              int32_t, int32_t);
typedef int32_t (*ose_getPayloadItemSizeFn)(ose_constbundle, char,
                                            int32_t, int32_t);
typedef int32_t (*ose_pprintPayloadItemFn)(ose_bundle, char,
                                           int32_t, int32_t);
typedef int32_t (*ose_fromStringFn)(ose_bundle, char,
                                    int32_t, int32_t);
 
#define OSE_TYPE_ADDR_PREFIX "/"
 
#define OSE_TYPE_ADDR_PPRINTPAYLOADITEM_SUFFIX "/PPPI"
#define OSE_PPRINTPAYLOADITEM_ADDR_ \
    OSE_TYPE_ADDR_PREFIX "%c" OSE_TYPE_ADDR_PPRINTPAYLOADITEM_SUFFIX
static const char * const OSE_PPRINTPAYLOADITEM_ADDR =
    OSE_PPRINTPAYLOADITEM_ADDR_;
static const int32_t OSE_PPRINTPAYLOADITEM_ADDR_LEN =
    sizeof(OSE_PPRINTPAYLOADITEM_ADDR_);
#ifndef OSE_PPRINTPAYLOADITEM_HOOK
#define OSE_PPRINTPAYLOADITEM_HOOK ose_pprintPayloadItem_hook
#else
extern int32_t OSE_PPRINTPAYLOADITEM_HOOK (ose_bundle bundle,
                                      char typetag,
                                      int32_t msg_offset,
                                      int32_t item_offset);
#endif
 
#define OSE_TYPE_ADDR_GETPAYLOADITEMLENGTH_SUFFIX "/GPIL"
#define OSE_GETPAYLOADITEMLENGTH_ADDR_ \
    OSE_TYPE_ADDR_PREFIX "%c" OSE_TYPE_ADDR_GETPAYLOADITEMLENGTH_SUFFIX
static const char * const OSE_GETPAYLOADITEMLENGTH_ADDR =
    OSE_GETPAYLOADITEMLENGTH_ADDR_;
static const int32_t OSE_GETPAYLOADITEMLENGTH_ADDR_LEN =
    sizeof(OSE_GETPAYLOADITEMLENGTH_ADDR_);
#ifndef OSE_GETPAYLOADITEMLENGTH_HOOK
#define OSE_GETPAYLOADITEMLENGTH_HOOK ose_getPayloadItemLength_hook
#else
extern int32_t OSE_GETPAYLOADITEMLENGTH_HOOK (ose_constbundle bundle,
                                              char typetag,
                                              int32_t msg_offset,
                                              int32_t item_offset);
#endif
 
#define OSE_TYPE_ADDR_GETPAYLOADITEMSIZE_SUFFIX "/GPIS"
#define OSE_GETPAYLOADITEMSIZE_ADDR_ \
    OSE_TYPE_ADDR_PREFIX "%c" OSE_TYPE_ADDR_GETPAYLOADITEMSIZE_SUFFIX
static const char * const OSE_GETPAYLOADITEMSIZE_ADDR =
    OSE_GETPAYLOADITEMSIZE_ADDR_;
static const int32_t OSE_GETPAYLOADITEMSIZE_ADDR_LEN =
    sizeof(OSE_GETPAYLOADITEMSIZE_ADDR_);
#ifndef OSE_GETPAYLOADITEMSIZE_HOOK
#define OSE_GETPAYLOADITEMSIZE_HOOK ose_getPayloadItemSize_hook
#else
extern int32_t OSE_GETPAYLOADITEMSIZE_HOOK (ose_constbundle bundle,
                                            char typetag,
                                            int32_t msg_offset,
                                            int32_t item_offset);
#endif
 
#define OSE_TYPE_ADDR_FROMSTRING_SUFFIX "/FRST"
#define OSE_FROMSTRING_ADDR_                                    \
    OSE_TYPE_ADDR_PREFIX "%c" OSE_TYPE_ADDR_FROMSTRING_SUFFIX
static const char * const OSE_FROMSTRING_ADDR =
    OSE_FROMSTRING_ADDR_;
static const int32_t OSE_FROMSTRING_ADDR_LEN =
    sizeof(OSE_FROMSTRING_ADDR_);
#ifndef OSE_FROMSTRING_HOOK
#define OSE_FROMSTRING_HOOK ose_fromString_hook
#else
extern int32_t OSE_FROMSTRING_HOOK (ose_bundle bundle,
                                    char typetag,
                                    const char * const str);
#endif
 
#ifndef OSE_REGISTERTYPE_HOOK
#define OSE_REGISTERTYPE_HOOK ose_registerType_hook
#else
extern void
OSE_REGISTERTYPE_HOOK (ose_bundle bundle,
                       char typetag,
                       const char * const getPayloadItemLength_addr,
                       ose_getPayloadItemLengthFn getPayloadItemLength,
                       const char * const getPayloadItemSize_addr,
                       ose_getPayloadItemSizeFn getPayloadItemSize,
                       const char * const pprintPayloadItem_addr,
                       ose_pprintPayloadItemFn pprintPayloadItem,
                       const char * const evalType_addr,
                       void (*evalType)(ose_bundle),
                       const char * const fromString_addr,
                       void (*fromString)(ose_bundle));
#endif
 
 
const char *ose_version_string(void);
const char *ose_debug_string(void);
const char *ose_date_compiled_string(void);
 
/* The VM's hook functions, as this build named them (OSEVM_ASSIGN and the
   rest, which a host may override), for a module compiled apart from the
   host -- the stdlib -- to bind. Every field is a function's name fixed at
   build time, so the table is const: defined once in ose_vm.c, never
   written. */
struct osevm_hooks
{
    void (*ASSIGN)(ose_bundle);
    void (*LOOKUP)(ose_bundle);
    void (*FUNCALL)(ose_bundle);
    void (*QUOTE)(ose_bundle);
    void (*COPYREGISTERTOELEM)(ose_bundle);
    void (*APPENDELEMTOREGISTER)(ose_bundle);
    void (*REPLACEREGISTERWITHELEM)(ose_bundle);
    void (*MOVEELEMTOREGISTER)(ose_bundle);
    void (*TOTYPE)(ose_bundle);
    void (*TOINT32)(ose_bundle);
    void (*TOFLOAT)(ose_bundle);
    void (*TOSTRING)(ose_bundle);
    void (*TOBLOB)(ose_bundle);
#ifdef OSE_PROVIDE_TYPE_SYMBOL
    void (*TOSYMBOL)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_DOUBLE
    void (*TODOUBLE)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_INT8
    void (*TOINT8)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT8
    void (*TOUINT8)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_INT16
    void (*TOINT16)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT16
    void (*TOUINT16)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT32
    void (*TOUINT32)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_INT64
    void (*TOINT64)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_UINT64
    void (*TOUINT64)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_TIMETAG
    void (*TOTIMETAG)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_TRUE
    void (*TOTRUE)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_FALSE
    void (*TOFALSE)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_NIL
    void (*TONIL)(ose_bundle);
#endif
#ifdef OSE_PROVIDE_TYPE_INFINITUM
    void (*TOINFINITUM)(ose_bundle);
#endif
    void (*APPENDBYTE)(ose_bundle);
    void (*RESPONDTOSTRING)(ose_bundle);
    void (*PREINPUT)(ose_bundle);
    void (*POSTINPUT)(ose_bundle);
    void (*POPINPUTTOCONTROL)(ose_bundle);
    void (*POSTCONTROL)(ose_bundle);
    void (*EVALTYPE)(ose_bundle);
};
extern const struct osevm_hooks osevm_hooks;
 
#ifdef __cplusplus
}
#endif
 
#endif