Remove amx.c from pawndisasm's sources

We don't need the whole AMX in order to compile pawndisasm, only a handful of
alignment functions (amx_AlignXXX) that are used in amxdbg.c. Just copy those
functions to amxdbg.

As a bonus, we don't have to fix compile warnings in amx.c now. (maybe somebody
will fix them some day in a distant future...)

source/amx/amxdbg.c

@@ -30,6 +30,123 @@
 #include "amx.h"
 #include "amxdbg.h"
 
+#if PAWN_CELL_SIZE==16
+  #define dbg_AlignCell(v) dbg_Align16(v)
+#elif PAWN_CELL_SIZE==32
+  #define dbg_AlignCell(v) dbg_Align32(v)
+#elif PAWN_CELL_SIZE==64 && (defined _I64_MAX || defined HAVE_I64)
+  #define dbg_AlignCell(v) dbg_Align64(v)
+#else
+  #error Unsupported cell size
+#endif
+
+#if !defined NDEBUG
+  static int check_endian(void)
+  {
+    uint16_t val=0x00ff;
+    unsigned char *ptr=(unsigned char *)&val;
+    /* "ptr" points to the starting address of "val". If that address
+     * holds the byte "0xff", the computer stored the low byte of "val"
+     * at the lower address, and so the memory lay out is Little Endian.
+     */
+    assert(*ptr==0xff || *ptr==0x00);
+    #if BYTE_ORDER==BIG_ENDIAN
+      return *ptr==0x00;  /* return "true" if big endian */
+    #else
+      return *ptr==0xff;  /* return "true" if little endian */
+    #endif
+  }
+#endif
+
+#if BYTE_ORDER==BIG_ENDIAN || PAWN_CELL_SIZE==16
+  static void swap16(uint16_t *v)
+  {
+    unsigned char *s = (unsigned char *)v;
+    unsigned char t;
+
+    assert(sizeof(*v)==2);
+    /* swap two bytes */
+    t=s[0];
+    s[0]=s[1];
+    s[1]=t;
+  }
+#endif
+
+#if BYTE_ORDER==BIG_ENDIAN || PAWN_CELL_SIZE==32
+  static void swap32(uint32_t *v)
+  {
+    unsigned char *s = (unsigned char *)v;
+    unsigned char t;
+
+    assert_static(sizeof(*v)==4);
+    /* swap outer two bytes */
+    t=s[0];
+    s[0]=s[3];
+    s[3]=t;
+    /* swap inner two bytes */
+    t=s[1];
+    s[1]=s[2];
+    s[2]=t;
+  }
+#endif
+
+#if (BYTE_ORDER==BIG_ENDIAN || PAWN_CELL_SIZE==64) && (defined _I64_MAX || defined HAVE_I64)
+  static void swap64(uint64_t *v)
+  {
+    unsigned char *s = (unsigned char *)v;
+    unsigned char t;
+
+    assert(sizeof(*v)==8);
+
+    t=s[0];
+    s[0]=s[7];
+    s[7]=t;
+
+    t=s[1];
+    s[1]=s[6];
+    s[6]=t;
+
+    t=s[2];
+    s[2]=s[5];
+    s[5]=t;
+
+    t=s[3];
+    s[3]=s[4];
+    s[4]=t;
+  }
+#endif
+
+uint16_t * AMXAPI dbg_Align16(uint16_t *v)
+{
+  assert_static(sizeof(*v)==2);
+  assert(check_endian());
+  #if BYTE_ORDER==BIG_ENDIAN
+    swap16(v);
+  #endif
+  return v;
+}
+
+uint32_t * AMXAPI dbg_Align32(uint32_t *v)
+{
+  assert_static(sizeof(*v)==4);
+  assert(check_endian());
+  #if BYTE_ORDER==BIG_ENDIAN
+    swap32(v);
+  #endif
+  return v;
+}
+
+#if defined _I64_MAX || defined HAVE_I64
+uint64_t * AMXAPI dbg_Align64(uint64_t *v)
+{
+  assert(sizeof(*v)==8);
+  assert(check_endian());
+  #if BYTE_ORDER==BIG_ENDIAN
+    swap64(v);
+  #endif
+  return v;
+}
+#endif  /* _I64_MAX || HAVE_I64 */
 
 int AMXAPI dbg_FreeInfo(AMX_DBG *amxdbg)
 {
@@ -68,9 +185,9 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
   if (fread(&amxhdr, sizeof amxhdr, 1, fp) == 0)
     return AMX_ERR_FORMAT;
   #if BYTE_ORDER==BIG_ENDIAN
-    amx_Align32((uint32_t*)&amxhdr.size);
+    dbg_Align32((uint32_t*)&amxhdr.size);
-    amx_Align16(&amxhdr.magic);
+    dbg_Align16(&amxhdr.magic);
-    amx_Align16(&dbghdr.flags);
+    dbg_Align16(&dbghdr.flags);
   #endif
   if (amxhdr.magic != AMX_MAGIC)
     return AMX_ERR_FORMAT;
@@ -83,15 +200,15 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
     return AMX_ERR_FORMAT;
 
   #if BYTE_ORDER==BIG_ENDIAN
-    amx_Align32((uint32_t*)&dbghdr.size);
+    dbg_Align32((uint32_t*)&dbghdr.size);
-    amx_Align16(&dbghdr.magic);
+    dbg_Align16(&dbghdr.magic);
-    amx_Align16(&dbghdr.flags);
+    dbg_Align16(&dbghdr.flags);
-    amx_Align16(&dbghdr.files);
+    dbg_Align16(&dbghdr.files);
-    amx_Align16(&dbghdr.lines);
+    dbg_Align16(&dbghdr.lines);
-    amx_Align16(&dbghdr.symbols);
+    dbg_Align16(&dbghdr.symbols);
-    amx_Align16(&dbghdr.tags);
+    dbg_Align16(&dbghdr.tags);
-    amx_Align16(&dbghdr.automatons);
+    dbg_Align16(&dbghdr.automatons);
-    amx_Align16(&dbghdr.states);
+    dbg_Align16(&dbghdr.states);
   #endif
   if (dbghdr.magic != AMX_DBG_MAGIC)
     return AMX_ERR_FORMAT;
@@ -136,7 +253,7 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
     assert(amxdbg->filetbl != NULL);
     amxdbg->filetbl[index] = (AMX_DBG_FILE *)ptr;
     #if BYTE_ORDER==BIG_ENDIAN
-      amx_AlignCell(&amxdbg->filetbl[index]->address);
+      dbg_AlignCell(&amxdbg->filetbl[index]->address);
     #endif
     for (ptr = ptr + sizeof(AMX_DBG_FILE); *ptr != '\0'; ptr++)
       /* nothing */;
@@ -147,8 +264,8 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
   amxdbg->linetbl = (AMX_DBG_LINE*)ptr;
   #if BYTE_ORDER==BIG_ENDIAN
     for (index = 0; index < dbghdr.lines; index++) {
-      amx_AlignCell(&amxdbg->linetbl[index].address);
+      dbg_AlignCell(&amxdbg->linetbl[index].address);
-      amx_Align32((uint32_t*)&amxdbg->linetbl[index].line);
+      dbg_Align32((uint32_t*)&amxdbg->linetbl[index].line);
     } /* for */
   #endif
   ptr += (uint16_t)dbghdr.lines * sizeof(AMX_DBG_LINE);
@@ -158,8 +275,8 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
          && (cell)line->address > (cell)(line - 1)->address) {
     #if BYTE_ORDER==BIG_ENDIAN
       for (index = 0; index <= (uint32_t)(1u << 16) - 1; index++) {
-        amx_AlignCell(&linetbl[index].address);
+        dbg_AlignCell(&linetbl[index].address);
-        amx_Align32((uint32_t*)&linetbl[index].line);
+        dbg_Align32((uint32_t*)&linetbl[index].line);
         line++;
       } /* for */
     #endif
@@ -171,19 +288,19 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
     assert(amxdbg->symboltbl != NULL);
     amxdbg->symboltbl[index] = (AMX_DBG_SYMBOL *)ptr;
     #if BYTE_ORDER==BIG_ENDIAN
-      amx_AlignCell(&amxdbg->symboltbl[index]->address);
+      dbg_AlignCell(&amxdbg->symboltbl[index]->address);
-      amx_Align16((uint16_t*)&amxdbg->symboltbl[index]->tag);
+      dbg_Align16((uint16_t*)&amxdbg->symboltbl[index]->tag);
-      amx_AlignCell(&amxdbg->symboltbl[index]->codestart);
+      dbg_AlignCell(&amxdbg->symboltbl[index]->codestart);
-      amx_AlignCell(&amxdbg->symboltbl[index]->codeend);
+      dbg_AlignCell(&amxdbg->symboltbl[index]->codeend);
-      amx_Align16((uint16_t*)&amxdbg->symboltbl[index]->dim);
+      dbg_Align16((uint16_t*)&amxdbg->symboltbl[index]->dim);
     #endif
     for (ptr = ptr + sizeof(AMX_DBG_SYMBOL); *ptr != '\0'; ptr++)
       /* nothing */;
     ptr++;              /* skip '\0' too */
     for (dim = 0; dim < amxdbg->symboltbl[index]->dim; dim++) {
       symdim = (AMX_DBG_SYMDIM *)ptr;
-      amx_Align16((uint16_t*)&symdim->tag);
+      dbg_Align16((uint16_t*)&symdim->tag);
-      amx_AlignCell(&symdim->size);
+      dbg_AlignCell(&symdim->size);
       ptr += sizeof(AMX_DBG_SYMDIM);
     } /* for */
   } /* for */
@@ -193,7 +310,7 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
     assert(amxdbg->tagtbl != NULL);
     amxdbg->tagtbl[index] = (AMX_DBG_TAG *)ptr;
     #if BYTE_ORDER==BIG_ENDIAN
-      amx_Align16(&amxdbg->tagtbl[index]->tag);
+      dbg_Align16(&amxdbg->tagtbl[index]->tag);
     #endif
     for (ptr = ptr + sizeof(AMX_DBG_TAG) - 1; *ptr != '\0'; ptr++)
       /* nothing */;
@@ -205,8 +322,8 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
     assert(amxdbg->automatontbl != NULL);
     amxdbg->automatontbl[index] = (AMX_DBG_MACHINE *)ptr;
     #if BYTE_ORDER==BIG_ENDIAN
-      amx_Align16(&amxdbg->automatontbl[index]->automaton);
+      dbg_Align16(&amxdbg->automatontbl[index]->automaton);
-      amx_AlignCell(&amxdbg->automatontbl[index]->address);
+      dbg_AlignCell(&amxdbg->automatontbl[index]->address);
     #endif
     for (ptr = ptr + sizeof(AMX_DBG_MACHINE) - 1; *ptr != '\0'; ptr++)
       /* nothing */;
@@ -218,8 +335,8 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
     assert(amxdbg->statetbl != NULL);
     amxdbg->statetbl[index] = (AMX_DBG_STATE *)ptr;
     #if BYTE_ORDER==BIG_ENDIAN
-      amx_Align16(&amxdbg->statetbl[index]->state);
+      dbg_Align16(&amxdbg->statetbl[index]->state);
-      amx_Align16(&amxdbg->automatontbl[index]->automaton);
+      dbg_Align16(&amxdbg->automatontbl[index]->automaton);
     #endif
     for (ptr = ptr + sizeof(AMX_DBG_STATE) - 1; *ptr != '\0'; ptr++)
       /* nothing */;

source/compiler/CMakeLists.txt

@@ -135,7 +135,6 @@ target_link_libraries(pawncc pawnc)
 set(PAWNDISASM_SRCS
   pawndisasm.c
   ../amx/amxdbg.c
-  ../amx/amx.c
 )
 add_executable(pawndisasm ${PAWNDISASM_SRCS})
 if(UNIX)