Created custom functions to convert (h)words to and from bytecode format

Instead of using endian.h that is not portable AND doesn't work with
C++, I'll just write my own using a forced union based type punning
trick.

I've decided to use little endian for the format as well: it seems to
be used by most desktop computers so it should make these functions
faster to run for most CPUs.

lib/base.c

@@ -14,23 +14,87 @@
 
 #include <string.h>
 
+union hword_pun
+{
+  hword h;
+  byte bytes[HWORD_SIZE];
+};
+
+union word_pun
+{
+  word h;
+  byte bytes[WORD_SIZE];
+};
+
+hword hword_htobc(hword w)
+{
+#if __LITTLE_ENDIAN__
+  return w;
+#else
+  union hword_pun x = {w};
+  union hword_pun y = {0};
+  for (size_t i = 0, j = HWORD_SIZE; i < HWORD_SIZE; ++i, --j)
+    y.bytes[j - 1] = x.bytes[i];
+  return y.h;
+#endif
+}
+
+hword hword_bctoh(hword w)
+{
+#if __LITTLE_ENDIAN__
+  return w;
+#else
+  union hword_pun x = {w};
+  union hword_pun y = {0};
+  for (size_t i = 0, j = HWORD_SIZE; i < HWORD_SIZE; ++i, --j)
+    y.bytes[j - 1] = x.bytes[i];
+  return y.h;
+#endif
+}
+
+word word_htobc(word w)
+{
+#if __LITTLE_ENDIAN__
+  return w;
+#else
+  union word_pun x = {w};
+  union word_pun y = {0};
+  for (size_t i = 0, j = WORD_SIZE; i < WORD_SIZE; ++i, --j)
+    y.bytes[j - 1] = x.bytes[i];
+  return y.h;
+#endif
+}
+
+word word_bctoh(word w)
+{
+#if __LITTLE_ENDIAN__
+  return w;
+#else
+  union word_pun x = {w};
+  union word_pun y = {0};
+  for (size_t i = 0, j = WORD_SIZE; i < WORD_SIZE; ++i, --j)
+    y.bytes[j - 1] = x.bytes[i];
+  return y.h;
+#endif
+}
+
 hword convert_bytes_to_hword(byte *bytes)
 {
   hword be_h = 0;
   memcpy(&be_h, bytes, HWORD_SIZE);
-  hword h = be32toh(be_h);
+  hword h = hword_bctoh(be_h);
   return h;
 }
 
 void convert_hword_to_bytes(hword w, byte *bytes)
 {
-  hword be_h = htobe32(w);
+  hword be_h = hword_htobc(w);
   memcpy(bytes, &be_h, HWORD_SIZE);
 }
 
 void convert_word_to_bytes(word w, byte *bytes)
 {
-  word be_w = htobe64(w);
+  word be_w = word_htobc(w);
   memcpy(bytes, &be_w, WORD_SIZE);
 }
 
@@ -38,6 +102,6 @@ word convert_bytes_to_word(byte *bytes)
 {
   word be_w = 0;
   memcpy(&be_w, bytes, WORD_SIZE);
-  word w = be64toh(be_w);
+  word w = word_bctoh(be_w);
   return w;
 }

lib/base.h

@@ -13,8 +13,6 @@
 #ifndef BASE_H
 #define BASE_H
 
-#define _DEFAULT_SOURCE
-#include <endian.h>
 #include <stdint.h>
 
 /* Basic macros for a variety of uses.  Quite self explanatory. */
@@ -130,4 +128,21 @@ word convert_bytes_to_word(byte *);
  */
 void convert_word_to_bytes(word w, byte *buffer);
 
+/** Convert a half word into bytecode format (little endian)
+ */
+hword hword_htobc(hword);
+
+/** Convert a half word in bytecode format (little endian) to host
+ * format
+ */
+hword hword_bctoh(hword);
+
+/** Convert a word into bytecode format (little endian)
+ */
+word word_htobc(word);
+
+/** Convert a word in bytecode format (little endian) to host format
+ */
+word word_bctoh(word);
+
 #endif

lib/inst.c

@@ -438,7 +438,7 @@ void insts_write_bytecode_file(inst_t *instructions, size_t size, FILE *fp)
 
 void prog_header_write_bytecode(prog_header_t header, darr_t *buffer)
 {
-  word start = htobe64(header.start_address);
+  word start = word_htobc(header.start_address);
   darr_append_bytes(buffer, (byte *)&start, sizeof(start));
 }
 
@@ -447,7 +447,7 @@ void prog_write_bytecode(prog_t *program, darr_t *buffer)
   // Write program header
   prog_header_write_bytecode(program->header, buffer);
   // Write instruction count
-  word pcount = htobe64(program->count);
+  word pcount = word_htobc(program->count);
   darr_append_bytes(buffer, (byte *)&pcount, sizeof(pcount));
   // Write instructions
   insts_write_bytecode(program->instructions, program->count, buffer);