Merge #297: simplicity-sys: separate out linker symbols in C library by version name

901127b simplicity-sys: add links= field to the Cargo.toml file (Andrew Poelstra)
ee46600 simplicity-sys: add versions to jet prefixes (Andrew Poelstra)
985be76 simplicity-sys: add versions to jets_ffi code (Andrew Poelstra)
d298887 simplicity-sys: prefix all simplicity_ symbols with the version (Andrew Poelstra)

Pull request description:

  First several commits (all the ones that don't update libsimplicity) from #296.


ACKs for top commit:
  canndrew:
    ACK 901127b


Tree-SHA512: 8e4919605b216cebe75816c4d8451a4a9354ce8141cf2e2e884b01f1f6631893f19de5325b80482d63e3333855ffcf4c818b84cb1ebeec763377ca87f30c4599

Author: apoelstra

simplicity-sys/Cargo.toml

@@ -8,6 +8,8 @@ documentation = "https://docs.rs/simplicity-sys/"
 description = "FFI bindings to libsimplicity"
 edition = "2021"
 rust-version = "1.78.0"
+build = "build.rs"
+links = "rustsimplicity_0_4"
 
 [build-dependencies]
 cc = "1.0.83"

simplicity-sys/depend/env.c

@@ -3,32 +3,32 @@
 #include "simplicity/elements/env.h"
 #include "simplicity/primitive/elements/primitive.h"
 
-const size_t c_sizeof_rawBuffer = sizeof(rawBuffer);
-const size_t c_sizeof_rawOutput = sizeof(rawOutput);
-const size_t c_sizeof_rawInput = sizeof(rawInput);
-const size_t c_sizeof_rawTransaction = sizeof(rawTransaction);
-const size_t c_sizeof_rawTapEnv = sizeof(rawTapEnv);
-const size_t c_sizeof_txEnv = sizeof(txEnv);
+const size_t rustsimplicity_0_4_c_sizeof_rawBuffer = sizeof(rawBuffer);
+const size_t rustsimplicity_0_4_c_sizeof_rawOutput = sizeof(rawOutput);
+const size_t rustsimplicity_0_4_c_sizeof_rawInput = sizeof(rawInput);
+const size_t rustsimplicity_0_4_c_sizeof_rawTransaction = sizeof(rawTransaction);
+const size_t rustsimplicity_0_4_c_sizeof_rawTapEnv = sizeof(rawTapEnv);
+const size_t rustsimplicity_0_4_c_sizeof_txEnv = sizeof(txEnv);
 
-const size_t c_alignof_rawBuffer = alignof(rawBuffer);
-const size_t c_alignof_rawOutput = alignof(rawOutput);
-const size_t c_alignof_rawInput = alignof(rawInput);
-const size_t c_alignof_rawTransaction = alignof(rawTransaction);
-const size_t c_alignof_rawTapEnv = alignof(rawTapEnv);
-const size_t c_alignof_txEnv = alignof(txEnv);
+const size_t rustsimplicity_0_4_c_alignof_rawBuffer = alignof(rawBuffer);
+const size_t rustsimplicity_0_4_c_alignof_rawOutput = alignof(rawOutput);
+const size_t rustsimplicity_0_4_c_alignof_rawInput = alignof(rawInput);
+const size_t rustsimplicity_0_4_c_alignof_rawTransaction = alignof(rawTransaction);
+const size_t rustsimplicity_0_4_c_alignof_rawTapEnv = alignof(rawTapEnv);
+const size_t rustsimplicity_0_4_c_alignof_txEnv = alignof(txEnv);
 
-void c_set_rawBuffer(rawBuffer *result, const unsigned char *buf, unsigned int len)
+void rustsimplicity_0_4_c_set_rawBuffer(rawBuffer *result, const unsigned char *buf, unsigned int len)
 {
     *result = (rawBuffer){.buf = buf, .len = len};
 }
 
-void c_set_rawOutput(rawOutput *result, const unsigned char *asset, const unsigned char *value, const unsigned char *nonce, const rawBuffer *scriptPubKey,
+void rustsimplicity_0_4_c_set_rawOutput(rawOutput *result, const unsigned char *asset, const unsigned char *value, const unsigned char *nonce, const rawBuffer *scriptPubKey,
                      const rawBuffer *surjectionProof, const rawBuffer *rangeProof)
 {
     *result = (rawOutput){.asset = asset, .value = value, .nonce = nonce, .scriptPubKey = *scriptPubKey, .surjectionProof = *surjectionProof, .rangeProof = *rangeProof};
 }
 
-void c_set_rawInput(rawInput *result, const rawBuffer *annex, const unsigned char *pegin, const rawBuffer *scriptSig,
+void rustsimplicity_0_4_c_set_rawInput(rawInput *result, const rawBuffer *annex, const unsigned char *pegin, const rawBuffer *scriptSig,
                     const unsigned char *prevTxid, unsigned int prevIx,
                     const unsigned char *asset, const unsigned char *value, const rawBuffer *scriptPubKey,
                     unsigned int sequence,
@@ -38,7 +38,7 @@ void c_set_rawInput(rawInput *result, const rawBuffer *annex, const unsigned cha
     *result = (rawInput){.annex = annex, .scriptSig = *scriptSig, .prevTxid = prevTxid, .pegin = pegin, .issuance = {.blindingNonce = blindingNonce, .assetEntropy = assetEntropy, .amount = amount, .inflationKeys = inflationKeys, .amountRangePrf = *amountRangePrf, .inflationKeysRangePrf = *inflationKeysRangePrf}, .txo = {.asset = asset, .value = value, .scriptPubKey = *scriptPubKey}, .prevIx = prevIx, .sequence = sequence};
 }
 
-void c_set_rawTransaction(rawTransaction *result, unsigned int version,
+void rustsimplicity_0_4_c_set_rawTransaction(rawTransaction *result, unsigned int version,
                           const unsigned char *txid,
                           const rawInput *input, unsigned int numInputs,
                           const rawOutput *output, unsigned int numOutputs,
@@ -55,14 +55,14 @@ void c_set_rawTransaction(rawTransaction *result, unsigned int version,
     };
 }
 
-void c_set_rawTapEnv(rawTapEnv *result, const unsigned char *controlBlock, unsigned char pathLen, const unsigned char *scriptCMR)
+void rustsimplicity_0_4_c_set_rawTapEnv(rawTapEnv *result, const unsigned char *controlBlock, unsigned char pathLen, const unsigned char *scriptCMR)
 {
     *result = (rawTapEnv){.controlBlock = controlBlock, .pathLen = pathLen, .scriptCMR = scriptCMR};
 }
 
-void c_set_txEnv(txEnv *result, const transaction *tx, const tapEnv *taproot, const unsigned char *genesisHash, unsigned int ix)
+void rustsimplicity_0_4_c_set_txEnv(txEnv *result, const transaction *tx, const tapEnv *taproot, const unsigned char *genesisHash, unsigned int ix)
 {
     sha256_midstate genesis;
     sha256_toMidstate(genesis.s, genesisHash);
-    *result = simplicity_build_txEnv(tx, taproot, &genesis, ix);
+    *result = rustsimplicity_0_4_build_txEnv(tx, taproot, &genesis, ix);
 }

simplicity-sys/depend/simplicity/bitstream.c

@@ -10,7 +10,7 @@
  *
  * Precondition: NULL != stream
  */
-simplicity_err simplicity_closeBitstream(bitstream* stream) {
+simplicity_err rustsimplicity_0_4_closeBitstream(bitstream* stream) {
   if (1 < stream->len) return SIMPLICITY_ERR_BITSTREAM_TRAILING_BYTES;        /* If there is more than one byte remaining. */
   if (1 == stream->len) {
     if (0 == stream->offset) return SIMPLICITY_ERR_BITSTREAM_TRAILING_BYTES;  /* If there is one byte remaining */
@@ -30,8 +30,8 @@ simplicity_err simplicity_closeBitstream(bitstream* stream) {
  * Precondition: 0 <= n < 32
  *               NULL != stream
  */
-int32_t simplicity_readNBits(int n, bitstream* stream) {
-  simplicity_assert(0 <= n && n < 32);
+int32_t rustsimplicity_0_4_readNBits(int n, bitstream* stream) {
+  rustsimplicity_0_4_assert(0 <= n && n < 32);
 
   uint32_t result = 0;
   while (CHAR_BIT <= stream->offset + n) {
@@ -109,7 +109,7 @@ static int32_t decodeUpto3Bits(int32_t* result, bitstream* stream) {
   } else {
     int32_t n = decodeUpto3(stream);
     if (0 <= n) {
-      *result = simplicity_readNBits(n, stream);
+      *result = rustsimplicity_0_4_readNBits(n, stream);
       if (*result < 0) return *result;
     }
     return n;
@@ -153,7 +153,7 @@ static int32_t decodeUpto15Bits(int32_t* result, bitstream* stream) {
   } else {
     int32_t n = decodeUpto15(stream);
     if (0 <= n) {
-      *result = simplicity_readNBits(n, stream);
+      *result = rustsimplicity_0_4_readNBits(n, stream);
       if (*result < 0) return *result;
     }
     return n;
@@ -184,7 +184,7 @@ static int32_t decodeUpto65535(bitstream* stream) {
  *
  * Precondition: NULL != stream
  */
-int32_t simplicity_decodeUptoMaxInt(bitstream* stream) {
+int32_t rustsimplicity_0_4_decodeUptoMaxInt(bitstream* stream) {
   int32_t bit = read1Bit(stream);
   if (bit < 0) return bit;
   if (0 == bit) {
@@ -194,7 +194,7 @@ int32_t simplicity_decodeUptoMaxInt(bitstream* stream) {
     if (n < 0) return n;
     if (30 < n) return SIMPLICITY_ERR_DATA_OUT_OF_RANGE;
     {
-      int32_t result = simplicity_readNBits(n, stream);
+      int32_t result = rustsimplicity_0_4_readNBits(n, stream);
       if (result < 0) return result;
       return ((1 << n) | result);
     }
@@ -211,9 +211,9 @@ int32_t simplicity_decodeUptoMaxInt(bitstream* stream) {
  *               n <= 2^31
  *               NULL != stream
  */
-simplicity_err simplicity_readBitstring(bitstring* result, size_t n, bitstream* stream) {
+simplicity_err rustsimplicity_0_4_readBitstring(bitstring* result, size_t n, bitstream* stream) {
   static_assert(0x80000000u + 2*(CHAR_BIT - 1) <= SIZE_MAX, "size_t needs to be at least 32-bits");
-  simplicity_assert(n <= 0x80000000u);
+  rustsimplicity_0_4_assert(n <= 0x80000000u);
   size_t total_offset = n + stream->offset;
   /* |= stream->len * CHAR_BIT < total_offset iff stream->len < (total_offset + (CHAR_BIT - 1)) / CHAR_BIT */
   if (stream->len < (total_offset + (CHAR_BIT - 1)) / CHAR_BIT) return SIMPLICITY_ERR_BITSTREAM_EOF;

simplicity-sys/depend/simplicity/bitstream.h

@@ -36,7 +36,7 @@ static inline bitstream initializeBitstream(const unsigned char* arr, size_t len
  *
  * Precondition: NULL != stream
  */
-simplicity_err simplicity_closeBitstream(bitstream* stream);
+simplicity_err rustsimplicity_0_4_closeBitstream(bitstream* stream);
 
 /* Fetches up to 31 bits from 'stream' as the 'n' least significant bits of return value.
  * The 'n' bits are set from the MSB to the LSB.
@@ -45,15 +45,15 @@ simplicity_err simplicity_closeBitstream(bitstream* stream);
  * Precondition: 0 <= n < 32
  *               NULL != stream
  */
-int32_t simplicity_readNBits(int n, bitstream* stream);
+int32_t rustsimplicity_0_4_readNBits(int n, bitstream* stream);
 
 /* Returns one bit from 'stream', 0 or 1.
  * Returns 'SIMPLICITY_ERR_BITSTREAM_EOF' if no bits are available.
  *
  * Precondition: NULL != stream
  */
 static inline int32_t read1Bit(bitstream* stream) {
-  return simplicity_readNBits(1, stream);
+  return rustsimplicity_0_4_readNBits(1, stream);
 }
 
 /* Decode an encoded number between 1 and 2^31 - 1 inclusive.
@@ -64,7 +64,7 @@ static inline int32_t read1Bit(bitstream* stream) {
  *
  * Precondition: NULL != stream
  */
-int32_t simplicity_decodeUptoMaxInt(bitstream* stream);
+int32_t rustsimplicity_0_4_decodeUptoMaxInt(bitstream* stream);
 
 /* Fills a 'bitstring' containing 'n' bits from 'stream'.
  * Returns 'SIMPLICITY_ERR_BITSTREAM_EOF' if not enough bits are available.
@@ -76,5 +76,5 @@ int32_t simplicity_decodeUptoMaxInt(bitstream* stream);
  *               n <= 2^31
  *               NULL != stream
  */
-simplicity_err simplicity_readBitstring(bitstring* result, size_t n, bitstream* stream);
+simplicity_err rustsimplicity_0_4_readBitstring(bitstring* result, size_t n, bitstream* stream);
 #endif

simplicity-sys/depend/simplicity/bitstring.h

@@ -30,7 +30,7 @@ typedef struct bitstring {
  */
 static inline bool getBit(const bitstring *s, size_t n) {
   size_t total_offset = s->offset + n;
-  simplicity_assert(n < s->len);
+  rustsimplicity_0_4_assert(n < s->len);
   return 1 & (s->arr[total_offset / CHAR_BIT] >> (CHAR_BIT - 1 - (total_offset % CHAR_BIT)));
 }
 
@@ -40,8 +40,8 @@ static inline bool getBit(const bitstring *s, size_t n) {
  *               n + 8 <= s->len;
  */
 static inline uint_fast8_t getByte(const bitstring *s, size_t n) {
-  simplicity_assert(8 <= s->len);
-  simplicity_assert(n <= s->len - 8);
+  rustsimplicity_0_4_assert(8 <= s->len);
+  rustsimplicity_0_4_assert(n <= s->len - 8);
   size_t total_offset = s->offset + n;
   if (total_offset % CHAR_BIT <= CHAR_BIT - 8) {
     return (uint_fast8_t)(0xff & (s->arr[total_offset / CHAR_BIT] >> (CHAR_BIT - 8 - (total_offset % CHAR_BIT))));

simplicity-sys/depend/simplicity/cmr.c

@@ -18,25 +18,25 @@
  *               unsigned char cmr[32]
  *               unsigned char program[program_len]
  */
-bool simplicity_computeCmr( simplicity_err* error, unsigned char* cmr
+bool rustsimplicity_0_4_computeCmr( simplicity_err* error, unsigned char* cmr
                           , const unsigned char* program, size_t program_len) {
-  simplicity_assert(NULL != error);
-  simplicity_assert(NULL != cmr);
-  simplicity_assert(NULL != program || 0 == program_len);
+  rustsimplicity_0_4_assert(NULL != error);
+  rustsimplicity_0_4_assert(NULL != cmr);
+  rustsimplicity_0_4_assert(NULL != program || 0 == program_len);
 
   bitstream stream = initializeBitstream(program, program_len);
   dag_node* dag = NULL;
-  int_fast32_t dag_len = simplicity_decodeMallocDag(&dag, NULL, &stream);
+  int_fast32_t dag_len = rustsimplicity_0_4_decodeMallocDag(&dag, NULL, &stream);
   if (dag_len <= 0) {
-    simplicity_assert(dag_len < 0);
+    rustsimplicity_0_4_assert(dag_len < 0);
     *error = (simplicity_err)dag_len;
   } else {
-    simplicity_assert(NULL != dag);
-    simplicity_assert((uint_fast32_t)dag_len <= DAG_LEN_MAX);
-    *error = simplicity_closeBitstream(&stream);
+    rustsimplicity_0_4_assert(NULL != dag);
+    rustsimplicity_0_4_assert((uint_fast32_t)dag_len <= DAG_LEN_MAX);
+    *error = rustsimplicity_0_4_closeBitstream(&stream);
     sha256_fromMidstate(cmr, dag[dag_len-1].cmr.s);
   }
 
-  simplicity_free(dag);
+  rustsimplicity_0_4_free(dag);
   return IS_PERMANENT(*error);
 }