home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d186 / a68k.lha / A68k / A68kglb.h < prev    next >
C/C++ Source or Header  |  1989-02-26  |  11KB  |  245 lines
  1. /*------------------------------------------------------------------*/
  2. /*                                    */
  3. /*              MC68000 Cross Assembler                */
  4. /*                                    */
  5. /*           Copyright (c) 1985 by Brian R. Anderson            */
  6. /*                                    */
  7. /*         Global    variables - January 4, 1989            */
  8. /*                                    */
  9. /*   This program may be copied    for personal, non-commercial use    */
  10. /*   only, provided that the above copyright notice is included        */
  11. /*   on    all copies of the source code.    Copying    for any    other use   */
  12. /*   without the consent of the    author is prohibited.            */
  13. /*                                    */
  14. /*------------------------------------------------------------------*/
  15. /*                                    */
  16. /*        Originally published (in Modula-2) in            */
  17. /*        Dr.    Dobb's Journal, April, May, and June 1986.          */
  18. /*                                    */
  19. /*     AmigaDOS conversion copyright 1989 by Charlie Gibbs.        */
  20. /*                                    */
  21. /*------------------------------------------------------------------*/
  22.  
  23. #ifdef PRIMARY
  24. #define    GLOBAL
  25. #else
  26. #define    GLOBAL extern
  27. #endif
  28.  
  29. GLOBAL char SourceFN[MAXFN];    /* Source file name */
  30. GLOBAL char HeaderFN[MAXFN];    /* Header file name (-h) */
  31. GLOBAL char SrecFN[MAXFN];    /* Object file name (-o) */
  32. GLOBAL char InclList[MAXLINE];    /* List    of directories to search (-i) */
  33. GLOBAL char IdntName[MAXLINE];    /* Program unit    name */
  34.  
  35. struct fs {
  36.     int    fd;        /* File    handle */
  37.     char *Buf;        /* Pointer to buffer */
  38.     char *Ptr;        /* Current position in buffer */
  39.     char *Lim;        /* Logical end of buffer */
  40. };
  41. GLOBAL struct fs In;    /* Input file */
  42. GLOBAL struct fs Eq;    /* Equate file */
  43. GLOBAL struct fs List;    /* Listing file    */
  44. GLOBAL struct fs Srec;    /* Object file */
  45.  
  46. /*    Command-line options    */
  47. GLOBAL int DumpSym;    /* -d Dump the symbol table */
  48. GLOBAL int FwdProc;    /* -f Special processing for forward references    */
  49. GLOBAL int KeepTabs;    /* -k Keep tabs    in the listing file */
  50. GLOBAL int SuppList;    /* (neither -l nor -x) Suppress    listing    file */
  51. GLOBAL int LnMax;    /* -p Maximum number of    lines per page */
  52. GLOBAL int Quiet;    /* -q Line no. display interval    (0 to suppress)    */
  53. GLOBAL long HashSize;    /* -w Number of    entries    in the hash table */
  54. GLOBAL int XrefList;    /* -x Produce a    cross-reference    listing    */
  55. GLOBAL int HashStats;    /* -y Display hashing statistics */
  56. GLOBAL int DebugStart;    /* -z Debug display starts here    */
  57. GLOBAL int DebugEnd;    /* -z Debug display ends here */
  58.  
  59. GLOBAL char TTLstring[MAXLINE];    /* Title string    */
  60.  
  61. GLOBAL int  LabLine;        /* Last    labeled    line number */
  62. GLOBAL int  LineCount;        /* Source line counter */
  63. GLOBAL char Line[MAXLINE];    /* Current source line */
  64. GLOBAL char Label[MAXLINE];    /* Instruction label */
  65. GLOBAL char OpCode[MAXLINE];    /* Instruction mnemonic    */
  66. GLOBAL char SrcOp[MAXLINE];    /* First (source) operand */
  67. GLOBAL char DestOp[MAXLINE];    /* Second (destination)    operand    */
  68. GLOBAL int  LabLoc, OpLoc;    /* Label and mnemonic start here */
  69. GLOBAL int  SrcLoc, DestLoc;    /* Operands start here */
  70. GLOBAL int  Dir, PrevDir;    /* Assembler directive */
  71. GLOBAL int  NumSyms;        /* Number of symbols */
  72. GLOBAL long ObjOp;        /* OpCode object code */
  73. GLOBAL long ObjSrc;        /* Source operand object code */
  74. GLOBAL long ObjDest;        /* Destination operand object code */
  75. GLOBAL char ObjString[MAXLINE];    /* String data */
  76. GLOBAL int  nO,    nS, nD,    nX;    /* Length of above components */
  77. GLOBAL int  PrntAddr;        /* Print AddrCnt on listing */
  78. GLOBAL int  MakeHunk;        /* We must make    a hunk */
  79. GLOBAL int  ListOff;        /* NOLIST is supressing    listing    lines */
  80. GLOBAL int  LnCnt;        /* Number of lines on current page */
  81. GLOBAL int  PgCnt;        /* Page    number */
  82. GLOBAL long Hunk2;        /* Hunk    number (from GetValue) */
  83. GLOBAL int  DefLine2;        /* Definition line number */
  84. GLOBAL int  GotEqur;        /* We have register equates */
  85. GLOBAL int  SmallData;        /* Small data model */
  86. GLOBAL int  AnyNear;        /* We got at least one NEAR directive */
  87. GLOBAL int  FwdShort;        /* Forward reference could be made short */
  88.  
  89. GLOBAL int  Pass2;    /* Pass    2 flag */
  90. GLOBAL long AddrCnt;    /* Location counter */
  91. GLOBAL long AddrAdv;    /* Bump    AddrCnt    by this    much */
  92. GLOBAL long OrgHigh;    /* Highest address reached if we ORG backwards */
  93. GLOBAL long OrgSeek;    /* Return here in Srec if we ORG backwards */
  94. GLOBAL long EndAddr;    /* END statement transfer address */
  95. GLOBAL long SectStart;    /* Current section (or portion)    starts here */
  96. GLOBAL int  SectLine;    /* Line    number where section started */
  97. GLOBAL int  HunkSeq;    /* Hunk    sequence number    */
  98. GLOBAL long HunkType;    /* Current hunk    type */
  99. GLOBAL long HunkFlags;    /* Hunk    flags (MEMF_FAST or MEMF_CHIP) */
  100. GLOBAL long CurrHunk;    /* Current hunk    number */
  101. GLOBAL long NextHunk;    /* Next    available hunk number */
  102. GLOBAL long LenPos;    /* Seek    position of current hunk length    */
  103. GLOBAL char *LenPtr;    /* Pointer to length if    in buffer, else    NULL */
  104. GLOBAL int  InclErrs;    /* Error processing INCLUDE statement(s) */
  105. GLOBAL int  InnrFMac;    /* An inner file has been read by a user macro */
  106. GLOBAL int  OrgFlag;    /* ORG may require object file fixup */
  107.  
  108. GLOBAL int  SFormat;    /* Generate S-record format */
  109. GLOBAL long StartAddr;    /* Address that    record starts on */
  110. GLOBAL long TempAddr;    /* Address of where we are now */
  111.  
  112. GLOBAL int  IncStart;    /* Start line number of    skippable INCLUDE */
  113. GLOBAL struct InFCtl *IncPtr;    /* Copy    of InF for skippable INCLUDE */
  114. struct SkipEnt {        /* Skippable INCLUDE description */
  115.     struct SetFixup *Set1;    /*  Pointer to first SET fixup */
  116.     int    Start;            /*  Starting line number of INCLUDE */
  117.     int    Finish;            /*  Ending line    number of INCLUDE */
  118.     int    MCount;            /*  Value of MacCount at end of    INCLUDE    */
  119. };
  120. struct SetFixup    {        /* SET symbol fixup entry */
  121.     struct SymTab *Sym;        /* Pointer to symbol table entry */
  122.     long Val;            /* Fixup value */
  123.     long Hunk;            /* Fixup hunk number */
  124. };
  125. GLOBAL struct SkipEnt *SkipLim;    /* Logical end of skippable INCLUDEs */
  126. GLOBAL struct SkipEnt *SkipIdx;    /* Current skippable INCLUDE entry */
  127. GLOBAL struct SetFixup *SetFixLim;    /* Next    available SetFixup */
  128.  
  129. struct SymTab {                /* Symbol table    */
  130.     struct SymTab *Link;    /* Link    to next    entry in hash chain */
  131.     char *Nam;    /* Pointer to symbol */
  132.     long Val;    /* Value */
  133.     long Hunk;    /* Hunk    number (ORed with MEMF_CHIP or MEM_FAST
  134.             if applicable SECTION
  135.            ~(pointer to    symbol)    if XREF
  136.            Pointer to macro text if MACRO        */
  137.     int     Defn;    /* Line    number where defined */
  138.     int     Flags;    /* Flags bits:    0 - XREF
  139.                 1 - XDEF
  140.                 2 - SET
  141.                 3 - MACRO (symbol is preceded by blank)
  142.                 4 - SECTION (name preceded by 2    blanks
  143.                     and 4-digit hex    sequence number)
  144.                 5 - register name (EQUR)
  145.                 6 - register list (REG)
  146.                 7 - PUBLIC (XREF or XDEF will be set) */
  147.     struct Ref *Ref1;    /* Pointer to first reference entry */
  148. };
  149. GLOBAL struct SymTab *SymStart;    /* The symbol table starts here    */
  150. GLOBAL struct SymTab *SymLim;    /* The symbol table ends here */
  151. GLOBAL struct SymTab *SymCurr;    /* Start of current chunk of data */
  152. GLOBAL struct SymTab *Sym;    /* ReadSymTab sets this    up */
  153. GLOBAL struct SymTab *Sect;    /* Current section's entry */
  154. GLOBAL struct SymTab *SymChunk;    /* Current symbol chunk    for NextSym */
  155. GLOBAL struct SymTab *SymChLim;    /* End of *SymChunk chunk */
  156. GLOBAL struct SymTab **Hash;    /* Pointer to hash table */
  157. GLOBAL struct SymTab **SymSort;    /* Symbol sort area */
  158. GLOBAL int  *HashCount;        /* Hashing summary table */
  159.  
  160. struct NameChunk {        /* Chunk of labels or macro text */
  161.     struct NameChunk *Link;    /* Link    to the next chunk */
  162.     char *Data[CHUNKSIZE-sizeof(struct NameChunk *)];    /* Data    area */
  163. };
  164. GLOBAL struct NameChunk    *NameStart;    /* Start of first name chunk */
  165. GLOBAL char        *NameLim;    /* Next    available name entry */
  166. GLOBAL struct NameChunk    *NameCurr;    /* Start of current name chunk */
  167.  
  168. struct Ref {            /* Reference entry */
  169.     struct Ref *NextRef;    /* Pointer to next reference entry */
  170.     int    RefNum[MAXREF];        /* Reference line numbers */
  171. };
  172. GLOBAL struct Ref *RefLim;    /* Next    available reference entry */
  173.  
  174. struct RelTab {            /* Relocation table entry */
  175.     struct RelTab *Link;    /* Link    to the next entry */
  176.     long Offset;        /* Offset to relocatable value */
  177.     long Hunk;            /* Hunk    type to    relocate relative to */
  178.     int    Size;            /* Size    of relocatable value */
  179. };
  180. GLOBAL struct RelTab *RelStart;    /* Relocation data starts here */
  181. GLOBAL struct RelTab *RelLim;    /* Relocation data ends    here */
  182. GLOBAL struct RelTab *RelCurr;    /* Start of current chunk of data */
  183. GLOBAL struct RelTab *RelLast;    /* Last    relocation entry added */
  184.  
  185. struct TermStack {        /* Parser's term stack */
  186.     long value;        /* Value */
  187.     long hunk;        /* Hunk    number */
  188.     int     oploc;        /* Location in source statement    */
  189.     int     defline;    /* Line    number where defined */
  190. };
  191. GLOBAL struct TermStack    *Term;    /* Term    stack pointer */
  192.  
  193. struct OpStack {        /* Parser's operator stack */
  194.     char chr;        /* Operator character */
  195.     int     prec;        /* Precedence */
  196. };
  197. GLOBAL struct OpStack *Ops;    /* Operator stack pointer */
  198.  
  199. GLOBAL char OpPrec[256];    /* Operator precedence look-up table */
  200.  
  201. GLOBAL int  InFNum;        /* Current input nesting level */
  202. struct InFCtl {
  203.     long Pos;            /* Current position in input */
  204.     char *UPtr;            /* Current position in user macro or 0 */
  205.     char *NPtr;            /* File    name stack pointer */
  206.     int     Line;            /* Current line    number in this file */
  207.     int     NArg;            /* Number of macro arguments or    -1 */
  208.     int     MCnt;            /* Macro expansion number (for \@) */
  209. };
  210. GLOBAL struct InFCtl *InF;    /* Macro/include file stack pointer */
  211. GLOBAL struct InFCtl *LowInF;    /* "Low-water mark" for InF */
  212. GLOBAL char *Heap2;        /* Secondary heap */
  213. GLOBAL char *NextFNS;        /* Next    input file path/name */
  214. GLOBAL char *High2;        /* Secondary high-water    mark */
  215. GLOBAL char *Low2;        /* Low limit from top of heap */
  216.  
  217. GLOBAL int  OuterMac;        /* Level number    of outermost macro */
  218. GLOBAL int  MacCount;        /* Number of macros expanded */
  219. GLOBAL int  SkipNest;        /* Skipped IF/ENDC nesting count */
  220. GLOBAL char MacSize[2];        /* Macro call size ("B", "W", or "L") */
  221.  
  222. struct OpConfig    {        /* Operand configuration */
  223.     long Value;    /* Value */
  224.     long Hunk;    /* Hunk    number */
  225.     int     Defn;    /* Line    number where defined */
  226.     int     Mode;    /* Addressing mode */
  227.     int     Loc;    /* Location of operand on Line */
  228.     int     Rn;    /* Register number */
  229.     int     Xn;    /* Index register number */
  230.     int     Xsize;    /* Size    of index */
  231.     int     X;    /* Is index Data or Address reg? */
  232. };
  233. GLOBAL struct OpConfig Src, Dest;   /* Source and destination operands */
  234.  
  235. GLOBAL int Size;    /* size    for OpCode */
  236. GLOBAL int InstSize;    /* Size    of instruction,    including operands */
  237. GLOBAL int AdrModeA;    /* Addressing modes for    this instruction */
  238. GLOBAL int AdrModeB;    /*         ditto             */
  239. GLOBAL int Op;        /* Raw bit pattern for OpCode */
  240.  
  241. GLOBAL int ErrorCount;
  242.  
  243. /* Error message tables    */
  244. GLOBAL int ErrLim, ErrCode[ERRMAX], ErrPos[ERRMAX];
  245.