home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / nasm20b / nasm_src / code.h < prev    next >
C/C++ Source or Header  |  1993-01-19  |  17KB  |  365 lines
  1. /* ---------------------------------------------------------------------- */
  2. /*                   Copyright (C) 1991 by Natürlich!                     */
  3. /*                      This file is copyrighted!                         */
  4. /*                Refer to the documentation for details.                 */
  5. /* ---------------------------------------------------------------------- */
  6. #ifndef _CODE_
  7. # define _CODE_
  8.  
  9. # define C_ACCU      0
  10. # define C_IMM       1
  11. # define C_ABS0      2
  12. # define C_RELX0     3
  13. # define C_RELY0     4
  14. # define C_ABS       5
  15. # define C_RELX      6
  16. # define C_RELY      7
  17. # define C_IMPL      8
  18. # define C_RELA      9
  19. # define C_INDX    0xA
  20. # define C_INDY    0xB
  21. # define C_IND     0xC
  22.  
  23. # define DEFORG    0x1000      /* Default PC and PC for reloctable code */
  24. # define inrange( val, min, max) ((val) >= (min) && (val) < (max))
  25.  
  26. # ifndef KEINE_CODE_INNEREIEN
  27.  
  28. /* ---------------------------------------------------------- */
  29. /* What it all means...                                       */
  30. /* dbyte - drop 16 bits in MSB LSB order -> FEDCBA98 76543210 */
  31. /* dbeek - read 16 bits in MSB LSB order                      */
  32. /* dpoke - drop 16 bits in LSB MSB order -> 76543210 FEDCBA98 */
  33. /* dpeek - read 16 bits in LSB MSB order                      */
  34. /*                                                            */
  35. /* p.... - as above but increment pointer                     */
  36. /* f.... - as above but p must point to word aligned adress   */
  37. /*                      **-PORT #4-**                         */
  38. /* ---------------------------------------------------------- */
  39. #  ifdef poke
  40. #   undef poke
  41. #  endif
  42. #  ifdef peek
  43. #   undef peek
  44. #  endif
  45. #  define dswap( p) (__x = ((byte huge *)( p))[ 1],               \
  46.           ((byte huge *)( p))[ 1] = *(byte huge *)( p),           \
  47.           *(byte huge *)( p) = __x)
  48.  
  49. #  define lswap( p) (__x = ((byte huge *)( p))[ 3],               \
  50.           ((byte huge *)( p))[ 3] = *(byte huge *)( p),           \
  51.           *(byte huge *)( p) = __x,                               \
  52.           __x = ((byte huge *)( p))[ 2],                          \
  53.           ((byte huge *)( p))[ 2] = ((byte huge *)( p))[ 1],      \
  54.           ((byte huge *)( p))[ 1] = __x)
  55.  
  56. #  if ! BIGENDIAN
  57.  
  58. #   define dpoke( p, v)                                            \
  59.       __x = (v);                                                   \
  60.       *(byte huge *)(p)          = *((byte huge *) &__x + 1);      \
  61.       *((byte huge *)(p) + 1)    = *((byte huge *) &__x)
  62. #   define dpeek( p)                                               \
  63.      (*((byte huge *) &__x + 1)  = *(byte huge *)(p),              \
  64.       *(byte huge *) &__x        = *((byte huge *) (p) + 1),       \
  65.       __x)
  66.  
  67. #   if ! PHILOSOPHICAL_PROBLEM      /* and you thought C was portable.. */
  68. #    define pdpoke( p, v)                                          \
  69.        __x = (v);                                                  \
  70.        *((byte huge *)(p))++     = (byte) __x;                     \
  71.        *((byte huge *)(p))++     = *((byte huge *) &__x)
  72. #    define pdpeek( p)                                             \
  73.       (*((byte huge *) &__x + 1) = *((byte huge *)(p))++,          \
  74.        *(byte huge *)&__x        = *((byte huge *)(p))++,          \
  75.        __x)
  76. #   else
  77. #    define pdpoke( p, v)                                          \
  78.        __x = (v);                                                  \
  79.        *(byte huge *)(p)         = (byte) __x;                     \
  80.        *((byte huge *)(p)+ 1)    = *((byte huge *) &__x);          \
  81.        (p) = (void huge *) ((byte huge *) (p) + 2)
  82. #    define pdpeek( p)                                             \
  83.       (*((byte huge *) &__x + 1) = *(byte huge *)(p),              \
  84.        *(byte huge *)&__x        = *((byte huge *)(p) + 1),        \
  85.        (p) = (void huge *) ((byte huge *) (p) + 2),                \
  86.        __x)
  87. #   endif
  88.  
  89. #   if WORD_EVEN
  90. #    define lbyte( p, v)                                          \
  91.       __lx = (v);                                                 \
  92.       *((byte huge *)(p))        = *((byte huge *) &__lx);        \
  93.       *((byte huge *)(p) + 1)    = *((byte huge *) &__lx + 1);    \
  94.       *((byte huge *)(p) + 2)    = *((byte huge *) &__lx + 2);    \
  95.       *((byte huge *)(p) + 3)    = *((byte huge *) &__lx + 3)
  96.  
  97. #    define lbeek( p)                                             \
  98.      (*((byte huge *) &__lx)     = *((byte huge *) (p)),          \
  99.       *((byte huge *) &__lx + 1) = *((byte huge *) (p) + 1),      \
  100.       *((byte huge *) &__lx + 2) = *((byte huge *) (p) + 2),      \
  101.       *((byte huge *) &__lx + 3) = *((byte huge *) (p) + 3),      \
  102.       __lx)
  103.  
  104. #    define dbyte( p, v)                                           \
  105.        __x = (v);                                                  \
  106.        *(byte huge *)(p)         = *(byte huge *) &__x;            \
  107.        *((byte huge *)(p) + 1)   = *((byte huge *) &__x + 1)
  108. #    define dbeek( p)                                              \
  109.       (*(byte huge *) &__x       = *(byte huge *)(p),              \
  110.       *((byte huge *) &__x + 1)  = *((byte huge *) (p) + 1),       \
  111.        __x)
  112.  
  113. #    if ! PHILOSOPHICAL_PROBLEM
  114. #     define pdbyte( p, v)                                         \
  115.         __x = (v);                                                 \
  116.         *((byte huge *)(p))++    = *((byte huge *) &__x);          \
  117.         *((byte huge *)(p))++    = *((byte huge *) &__x + 1)
  118. #     define pdbeek( p)                                            \
  119.        (*(byte huge *) &__x      = *((byte huge *)(p))++,          \
  120.         *((byte huge *) &__x + 1)= *((byte huge *)(p))++,          \
  121.         __x)
  122. #    else
  123. #     define pdbyte( p, v)                                         \
  124.         __x = (v);                                                 \
  125.         *(byte huge *)(p)        = *((byte huge *) &__x);          \
  126.         *((byte huge *)(p) + 1)  = *((byte huge *) &__x + 1);      \
  127.         (p) = (void huge *) ((byte huge *) (p) + 2)
  128. #     define pdbeek( p)                                            \
  129.        (*(byte huge *) &__x      = *(byte huge *)(p),              \
  130.         *((byte huge *) &__x + 1)= *((byte huge *)(p) + 1),        \
  131.         (p) = (void huge *) ((byte huge *) (p) + 2),               \
  132.         __x)
  133. #    endif
  134. #   else
  135. #    define lbyte( p, v)   *(lword huge *)(p)     = (lword)(v)
  136. #    define lbeek( p)      *((lword huge *)(p))
  137.  
  138. #    define dbyte(  p, v)  *(word huge *)(p)      = (word)(v)
  139. #    define dbeek(  p)     (*(word huge *)(p))
  140. #    if ! PHILOSOPHICAL_PROBLEM
  141. #     define pdbyte( p, v) *((word huge *)(p))++  = (word)(v)
  142. #     define pdbeek( p)    (*((word huge *)(p))++)
  143. #    else
  144. #     define pdbyte( p, v) *(word huge *)(p)= (word)(v);            \
  145.                            (p) = (void huge *) ((word huge *)(p) + 1)
  146. #     define pdbeek( p)    (__x = *(word huge *)(p),                \
  147.                            (p) = (void huge *) ((word huge *)(p) + 1),   \
  148.                            __x)
  149. #    endif
  150. #   endif
  151.  
  152. #   if ! PHILOSOPHICAL_PROBLEM
  153. #    define plbyte( p, v)  *((lword huge *)(p))++ = (lword)(v)
  154. #    define plbeek( p)     *((lword huge *)(p))++
  155. #   else
  156. #    define plbyte( p, v)  *(lword huge *)(p) = (lword)(v);            \
  157.                            (p) = (void huge *) ((lword huge *)(p) + 1)
  158. #    define plbeek( p)     (__lx = *(lword huge *)(p),                 \
  159.                             (p) = (void huge *) ((lword huge *) (p) + 1),   \
  160.                             __lx)
  161. #   endif
  162. #   define fdpoke(  p, v)  dpoke( p, v)
  163. #   define fdpeek(  p)     dpeek( p)
  164. #   define fdbyte(  p, v)  *(word huge *)(p) = (word)(v)
  165. #   define fdbeek(  p)     (*(word huge *)(p))
  166. #   define fpdpoke( p, v)  pdpoke( p, v)
  167. #   define fpdpeek( p)     pdpeek( p)
  168. #   if ! PHILOSOPHICAL_PROBLEM
  169. #    define fpdbyte( p, v) *((word huge *)(p))++ = (word)(v)
  170. #    define fpdbeek( p)    (*((word huge *)(p))++)
  171. #   else
  172. #    define fpdbyte( p, v) *((word huge *)(p)) = (word)(v);         \
  173.                            (p) = (void huge *) ((word huge *)(p) + 1)
  174. #    define fpdbeek( p)    (__x = *(word huge *)(p),                \
  175.                            (p) = (void huge *) ((word huge *)(p) + 1),   \
  176.                            __x)
  177. #   endif
  178.  
  179. #  else  /* ------ BIG ENDIAN ------ */
  180.  
  181.  
  182. #   if WORD_EVEN
  183. #    define dpoke( p, v)                                           \
  184.        __x = (v);                                                  \
  185.        *(byte huge *)(p)         = *(byte huge *) &__x;            \
  186.        *((byte huge *)(p) + 1)   = *((byte huge *) &__x + 1)
  187. #    define dpeek( p)                                              \
  188.       (*(byte huge *) &__x       = *(byte huge *) (p),             \
  189.        *((byte huge *) &__x + 1) = *((byte huge *) (p) + 1),       \
  190.        __x)
  191. #    if ! PHILOSOPHICAL_PROBLEM
  192. #     define pdpoke( p, v)                                         \
  193.         __x = (v);                                                 \
  194.         *((byte huge *)(p))++    = *(byte huge *) &__x;            \
  195.         *((byte huge *)(p))++    = *((byte huge *) &__x + 1)
  196. #     define pdpeek( p)                                            \
  197.        (*(byte huge *) &__x      = *((byte huge *)(p))++,          \
  198.         *((byte huge *) &__x + 1)= *((byte huge *)(p))++,          \
  199.         __x)
  200. #    else
  201. #     define pdpoke( p, v)                                         \
  202.         __x = (v);                                                 \
  203.         *(byte huge *)(p)        = *(byte huge *) &__x;            \
  204.         *((byte huge *)(p) + 1)  = *((byte huge *) &__x + 1);      \
  205.         (p) = (void huge *) ((byte huge *) (p) + 2)
  206. #     define pdpeek( p)                                            \
  207.        (*(byte huge *) &__x      = *(byte huge *) (p),             \
  208.         *((byte huge *) &__x + 1)= *((byte huge *) (p) + 1),       \
  209.         (p) = (void huge *) ((byte huge *) (p) + 2),               \
  210.         __x)
  211. #    endif
  212.  
  213. #   else       /* WORD ACCESS ON ODD ADDRESS OK */
  214.  
  215. #    define dpoke( p, v)   *(word huge *)(p)     = (word)(v)
  216. #    define dpeek( p)      (*(word huge *)(p))
  217. #    if ! PHILOSOPHICAL_PROBLEM
  218. #     define pdpoke( p, v) *((word huge *)(p))++ = (word)(v)
  219. #     define pdpeek( p)    (*((word huge *)(p))++)
  220. #    else
  221. #     define pdpoke( p, v) *(word huge *)(p) = (word)(v);          \
  222.                            (p)=(void huge *)((word huge *)(p) + 1)
  223. #     define pdpeek( p)    ( __x = *(word huge *)(p),              \
  224.                            (p)=(void huge *)((word huge *)(p) + 1),\
  225.                             __x)
  226. #    endif
  227. #   endif            /* STILL BIGENDIAN */
  228.  
  229. #   define dbyte( p, v)                                            \
  230.       __x = (v);                                                   \
  231.       *(byte huge *)(p)         = *((byte huge *) &__x + 1);       \
  232.       *((byte huge *)(p) + 1)   = *(byte huge *) &__x
  233. #   define dbeek( p)                                               \
  234.      (*((byte huge *)&__x + 1)  = *(byte huge *) (p),              \
  235.       *(byte huge *)&__x        = *((byte huge *) (p) + 1),        \
  236.       __x)
  237.  
  238. #   if ! PHILOSOPHICAL_PROBLEM
  239. #    define pdbyte( p, v)                                          \
  240.        __x = (v);                                                  \
  241.        *((byte huge *)(p))++     = *((byte huge *) &__x + 1);      \
  242.        *((byte huge *)(p))++     = *(byte huge *) &__x
  243. #    define pdbeek( p)                                             \
  244.       (*((byte huge *) &__x + 1) = *((byte huge *) (p))++,         \
  245.        *((byte huge *) &__x)     = *((byte huge *) (p))++,         \
  246.        __x)
  247. #   else
  248. #    define pdbyte( p, v)                                          \
  249.        __x = (v);                                                  \
  250.        *(byte huge *)(p)         = *((byte huge *) &__x + 1);      \
  251.        *((byte huge *)(p) + 1)   = *(byte huge *) &__x;            \
  252.        (p) = (void huge *) ((byte huge *)(p) + 2)
  253. #    define pdbeek( p)                                             \
  254.       (*((byte huge *) &__x + 1) = *(byte huge *) (p),             \
  255.        *((byte huge *) &__x)     = *((byte huge *) (p) + 1),       \
  256.        (p) = (void huge *) ((byte huge *)(p) + 2),                 \
  257.        __x)
  258. #   endif
  259.  
  260. #   define lbyte( p, v)                                            \
  261.       __lx = (v),                                                  \
  262.       *(byte huge *)(p)         = *((byte huge *) &__lx + 3);      \
  263.       *((byte huge *)(p) + 1)   = *((byte huge *) &__lx + 2);      \
  264.       *((byte huge *)(p) + 2)   = *((byte huge *) &__lx + 1);      \
  265.       *((byte huge *)(p) + 3)   = *(byte huge *) &__lx
  266.  
  267. #  if ! PHILOSOPHICAL_PROBLEM
  268. #   define plbeek( p)                                              \
  269.       (*((byte huge *) &__lx + 3) = *((byte huge *)(p))++,         \
  270.        *((byte huge *) &__lx + 2) = *((byte huge *)(p))++,         \
  271.        *((byte huge *) &__lx + 1) = *((byte huge *)(p))++,         \
  272.        *((byte huge *) &__lx)     = *((byte huge *)(p))++,         \
  273.        __lx)
  274.  
  275. #   define plbyte( p, v)                                           \
  276.        __lx = (v),                                                 \
  277.        *((byte huge *)(p))++      = *((byte huge *) &__lx + 3);    \
  278.        *((byte huge *)(p))++      = *((byte huge *) &__lx + 2);    \
  279.        *((byte huge *)(p))++      = *((byte huge *) &__lx + 1);    \
  280.        *((byte huge *)(p))++      = *(byte huge *) &__lx
  281. #  else
  282. #   define plbeek( p)                                              \
  283.       (*((byte huge *) &__lx + 3) = *(byte huge *)(p),             \
  284.        *((byte huge *) &__lx + 2) = *((byte huge *)(p) + 1),       \
  285.        *((byte huge *) &__lx + 1) = *((byte huge *)(p) + 2),       \
  286.        *((byte huge *) &__lx)     = *((byte huge *)(p) + 3),       \
  287.        (p) = (void huge *) ((lword huge *)(p) + 1),                \
  288.        __lx)
  289.  
  290. #   define plbyte( p, v)                                           \
  291.        __lx = (v),                                                 \
  292.        *(byte huge *)(p)           = *((byte huge *) &__lx + 3);   \
  293.        *((byte huge *)(p) + 1)     = *((byte huge *) &__lx + 2);   \
  294.        *((byte huge *)(p) + 2)     = *((byte huge *) &__lx + 1);   \
  295.        *((byte huge *)(p) + 3)     = *(byte huge *) &__lx;         \
  296.        (p) = (void huge *) ((lword huge *)(p) + 1)
  297. #  endif
  298. #  define lbeek( p)                                                \
  299.      (*(byte huge *) &__lx       = *((byte huge *) (p) + 3),       \
  300.       *((byte huge *) &__lx + 1) = *((byte huge *) (p) + 2),       \
  301.       *((byte huge *) &__lx + 2) = *((byte huge *) (p) + 1),       \
  302.       *((byte huge *) &__lx + 3) = *(byte huge *) (p),             \
  303.       __lx)
  304.  
  305.  
  306. #   define fdpoke(  p, v)  *(word huge *) (p) = (word)(v)
  307. #   define fdpeek(  p)    (*(word huge *) (p))
  308. #   define fdbyte(  p, v)  dbyte( p, v)
  309. #   define fdbeek(  p)     dbeek( p)
  310. #   define fpdpoke( p, v)  pdpoke(p, v)
  311. #   define fpdpeek( p)     pdpeek( p)
  312. #   define fpdbyte( p, v)  pdbyte( p, v)
  313. #   define fpdbeek( p)     pdbeek( p)
  314. #  endif
  315.  
  316. #  if WORD_EVEN
  317. #   define dclr( p)        *(byte huge *)(p) = *((byte huge *)(p) + 1) = 0
  318. #   if ! PHILOSOPHICAL_PROBLEM
  319. #    if ! LATE_PLUSPLUS
  320. #     define pdclr( p)     *((byte huge *)(p))++ = *((byte huge *)(p))++ = 0
  321. #    else
  322. #     define pdclr( p)     *((byte huge *)(p))++ = 0; *((byte huge *)(p))++ = 0
  323. #    endif
  324. #   else
  325. #     define pdclr( p)     *(byte huge *)(p) = 0; *((byte huge *)(p) + 1) = 0; \
  326.                            (p) = (void huge *) ((word huge *)(p) + 1)
  327. #   endif
  328. #  else
  329. #   define dclr( p)        *(word huge *)(p) = 0
  330. #   if PHILOSOPHICAL_PROBLEM
  331. #    define pdclr( p)      *(word huge *)(p) = 0;                         \
  332.                            (p) = (void huge *) ((word huge *)(p) + 1)
  333. #   else
  334. #    define pdclr( p)      *((word huge *)(p))++ = 0
  335. #   endif
  336. #  endif
  337.  
  338. #  define poke( p, v)      *(byte huge *)(p)  = (byte) (v)
  339. #  define peek( p)         *(byte huge *)(p)
  340. #  define apoke( p, v)     *(byte huge *)(p) += (byte) (v)
  341. #  define adpoke( p, v)    dpoke( p, (v) + dpeek( p))
  342. #  define adbyte( p, v)    dbyte( p, dbeek( p) + (word)(v))
  343.  
  344. #  define is_in_program( x)                              \
  345.      ((byte huge *) (x) >= __program && (byte huge *) (x) < __program + MAXMODULE)
  346.  
  347. #  define p_index()      ((word) (__p - __program))
  348. #  define calc_ind( adr) ((word) ((byte huge *)(adr) - __program))
  349. #  ifndef calc_pc
  350. #   define calc_pc( adr) (((word) ((byte huge *)(adr) - __program)) + DEFORG)
  351. #  endif
  352. # endif
  353.  
  354. # ifndef __BIG_GENERATOR__
  355. extern word       __pc, __x;
  356. extern lword      __lx;
  357. extern byte huge  *__program, huge *__p;
  358. # endif
  359.  
  360.  
  361. #endif
  362.  
  363.  
  364.  
  365.