URL https://opencores.org/ocsvn/rf6809/rf6809/trunk
Subversion Repositories rf6809

[/] [rf6809/] [trunk/] [software/] [a09/] [a09.c] - Blame information for rev 16

Go to most recent revision | Details | Compare with Previous | View Log

/* A09, 6809 Assembler.
 
   (C) Copyright 1993,1994 L.C. Benschop.
   Parts (C) Copyright 2001-2010 H. Seib.
   Mods for 12-bit FPGA core 6809 by R. Finch
 
   This version of the program is distributed under the terms and conditions
   of the GNU General Public License version 2. See file the COPYING for details.
   THERE IS NO WARRANTY ON THIS PROGRAM.
 
   Generates binary image file from the lowest to
   the highest address with actually assembled data.
 
   Machine dependencies:
                  char is 8 bits.
                  short is 16 bits.
                  integer arithmetic is twos complement.
 
   syntax:
     a09 [-{b|r|s|x|f}filename]|[-c] [-lfilename] [-ooption] [-dsym=value]* sourcefile.
 
   Options
   -Vfilename    Verilog rommem declaration output
   -c suppresses code output
   -bfilename    binary output file name (default name minus a09 suffix plus .bin)
   -rfilename    Flex9 RELASMB-compatible output file name (relocatable)
   -sfilename    s-record output file name (default its a binary file)
   -xfilename    intel hex output file name (-"-)
   -ffilename    Flex9 output file name (-"-)
   -lfilename    list file name (default no listing)
   -dsym[=value] define a symbol
   -oopt defines an option
 
   recognized pseudoops:
    ext        defines an external symbol (relocating mode only)
    extern     -"-
    public     defines a public symbol (effective in relocating mode only)
    macro      defines a macro
    exitm      terminates a macro expansion
    endm       ends a macro definition
    if
    ifn
    ifc
    ifnc
    else
    endif
    dup
    endd
    org
    equ
    set
    setdp      sets direct page in 6809 / 6309 mode
    text
    fcb
    fcw
    fdb
    fcc
    rmb
    reg
    end
    include
    title
    nam
    ttl
    sttl
    setpg
    pag
    spc
    rep
    rpt
    repeat
    opt        define an option (see below for possible options)
    err
    abs        force absolute mode
    common
    endcom
    def
    define
    enddef
    name
    symlen
    bin, binary includes a binary file at the current position
 
   recognized options:
     On | Off         Meaning
    ------------------------------------------------------------
    PAG | NOP*        Page Formatting
    CON | NOC*        Print skipped conditional code
    MAC*| NOM         Print macro calling line
    EXP | NOE*        Print macro expansion lines
    SYM*| NOS         Print symbol table
    MUL*| NMU         Print multiple object code lines
    LIS*| NOL         Print assembler listing
    LP1 | NO1*        Print Pass 1 Listing
    DAT*| NOD         Print date in listing
    NUM | NON*        Print line numbers
    INV | NOI*        Print invisible lines
    TSC | NOT*        Strict TSC Compatibility
    WAR*| NOW         Print warnings
    CLL*| NCL         Check line length
    LFN | NLF*        Print long file names
    LLL*| NLL         List library lines
    GAS | NOG*        Gnu AS source style compatibility
    REL*| NOR         Print Relocation table in Relocating mode
    M68*| H63 | M00   MC6809 / HD6309 / MC6800 mode
    TXT | NTX*        Print text table
    LPA | LNP*        Listing in f9dasm patch format
    * denotes default value
 
 
   v0.1 93/11/03 Initial version.
 
   v0.2 94/03/21 Fixed PC relative addressing bug
                 Added SET, SETDP, INCLUDE. IF/ELSE/ENDIF
                 No macros yet, and no separate linkable modules.
 
   v0.1.X 99/12/20 added Intel hex option (SLB)
 
-- H.Seib Additions: --
 
   v0.2.S 01/10/13 converted to readable format
   v0.3   01/10/15 added transfer address processing
                   increased max. #symbols and other constants
                     (hey, this isn't CP/M anymore :-)
                   added a bit of intelligence to command line processing
                   loads file(s) into internal storage prior to processing
                     (this aids a lot in preventing recursive invocations)
                   added LIB,LIBRARY pseudoop (same as INCLUDE)
                   added OPT,OPTION pseudoop
   v0.4   01/10/22 added -t switch to increase compatibility with the
                   TSC FLEX Assembler line, which uses a slightly more
                   rigid source file format
   v0.5   01/10/23 added SETPG, SETLI, PAG, SPC, NAM(TTL,TITLE), STTL, REP(RPT,REPEAT)
   v0.6   01/10/23 added EXITM, IFN, IFC, IFNC, DUP, ENDD
   v0.7   01/10/29 added REG, ERR, TEXT
   v0.8   01/10/30 converted command line handling to -O switch for options
                   and added a bunch of options
                   RZB pseudoop added
   v0.9   01/11/05 clean-ups, increased TSC FLEX Assembler compatibility
   v0.10  01/11/15 ASM and VERSION texts predefined
   v0.11  01/11/27 increased TSC FLEX Assembler compatibility (labels made case sensitive)
   v0.12  01/11/28 added some convenience mnemonics and simulated 6800 instructions to
                   increase TSC FLEX Assembler compatibility
   v1.02  01/04/11 check for address range overlaps implemented
   v1.03  02/09/24 macro parser had an error; corrected
   v1.04  02/12/10 error message output adjusted for Visual C++ 6.0 IDE compatibility
                   added OPT LFN/NLF for that purpose
   v1.05  02/12/23 crude form of backwards ORG added to binary output
   v1.06  03/06/10 added OPT LLL/NLL to include/suppress listing of LIB lines
   v1.07  03/06/23 outsymtable() only starts with a page feed if current line
                   is is NOT the first line on a page
   v1.08  03/07/01 SKIP count for the IF(N) and IF(N)C statements added to
                   normal statements (i.e., outside macro definitions)
   v1.09  05/06/02 some cleanups
                   added -r format for FLEX9 RELASMB compatible output
                   added ABS, GLOBAL, EXT, DEFINE, ENDDEF, COMMON, ENDCOM
                   REL|NOR option added
                   GAS|NOG option added (rudimentary)
                   M68|H63 option added
   v1.10  05/06/03 made options available as numeric strings
                   added local label support
                   added SYMLEN
                   TXT|NTX option added
   v1.11  05/06/06 IFD/IFND directives added
                   added special checks for "0,-[-]indexreg" and "0,indexreg+[+]"
                   when determining the postbyte for indexed addressing modes
   v1.12  05/06/20 OPT CON|NOC correctly implemented
   v1.13           skipped for users that might have an uneasy feeling about
                   the number "13" >:-)
   v1.14  05/08/01 text symbol replacement enhanced; it was a bit TOO general.
                   Now, &xxx is only treated as a text variable when xxx REALLY
                   is a text symbol; in all other cases, it's not preprocessed.
                   Let the assembler engine handle eventual errors.
                   Thanks to Peter from Australia for pointing this out!
   v1.15  05/08/02 only 1 local label was allowed per address; now, as many as
                   possible can be at the same location.
                   Thanks to Peter from Australia for pointing this out!
   v1.16  05/08/05 SETDP is illegal in relocating mode!
                   SETDP without any parameter DISABLES Direct mode entirely.
                   Cured an interesting bug... the following sequence:
                              ORG 1
                              LDA TEST
                       SHIT   NOP
                              ORG 1
                       TEST   RMB 1
                   caused a phase error; this was caused by the invalid
                   assumption in scanlabel() that forward references have
                   a higher memory location than the current address.
                   Thanks to Peter from Australia for pointing this out!
   v1.17  08/08/05 made tests for above problem more rigorous; now ANY forward
                   reference to a label that's not yet defined is treated as
                   uncertain.
                   Removed a nasty bug that caused the following code to produce
                   incorrect values:
                            org $8000  (anything >= $8000 will do)
                         lbl rmb 8
                         SizeBad equ (*-lbl)/2
                   OPT NOL changed to OPT NO1 to allow implementing OPT LIS|NOL.
                   OPT LIS*|NOL added
                   Thanks to Peter from Australia for pointing these out!
   v1.18  09/08/05 backward search for local labels now searches for "<= local
                   address" instead of "< local address"
                   Thanks to Peter from Australia for pointing this out!
                   Added INCD / DECD convenience mnemonics
                   (realized as ADDD/SUBD 1)
   v1.19  10/08/05 Added a bunch of 6800-style mnemonics; if they conflict
                   with 6809 mnemonics ("INC A" for example), they are only
                   active in TSC mode
   v1.20  16/08/05 changed special checks for
                     "0,-[-]indexreg" and "0,indexreg+[+]"
                   to include all known labels and changed the scope to
                     ",[-[-]]indexreg[+[+]]"
   v1.21  21/02/06 Bug in "xxx  >0,reg" found by Margus Kliimask
   v1.22  03/09/08 Addded BIN(ARY) pseudo-op to include binary files
   v1.23  13/02/09 6800 code generation added
                   accept multiple input files (first one defines default
                     output and listing file names)
   v1.24  13/02/09 made compilable with gcc
   v1.25  05/03/09 6800 alternate mnemonics work better now
   v1.26  14/03/09 assembling DOS format files in Loonix works better now
   v1.27  20/01/10 LPA/NLP options added
   v1.28  21/04/10 INCD/DECD produced invalid code
 
*/
 
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <malloc.h>
#include <stdarg.h>
#include <stdlib.h>
#include <time.h>
 
/*****************************************************************************/
/* Definitions                                                               */
/*****************************************************************************/
 
#define VERSION      "1.30"
#define VERSNUM      "$011D"            /* can be queried as &VERSION        */
 
#define UNIX 0                          /* set to != 0 for UNIX specials     */
 
#define MAX_PASSNO      9
#define MAXLABELS    8192
#define MAXMACROS    1024
#define MAXTEXTS     1024
#define MAXRELOCS    32768
#define MAXIDLEN     32
#define MAXLISTBYTES 7
#define FNLEN        256
#define LINELEN      1024
 
/*****************************************************************************/
/* Line buffer definitions                                                   */
/*****************************************************************************/
 
struct linebuf
  {
  struct linebuf * next;                /* pointer to next line              */
  struct linebuf * prev;                /* pointer to previous line          */
  char *fn;                             /* pointer to original file name     */
  long ln;                              /* line number therein               */
  unsigned char lvl;                    /* line level                        */
  unsigned char rel;                    /* relocation mode                   */
  char txt[1];                          /* text buffer                       */
  };
 
char *fnms[128] = {0};                  /* we process up to 128 different fls*/
short nfnms;                            /* # loaded files                    */
 
                                        /* special bits in lvl :             */
#define LINCAT_MACDEF       0x20        /* macro definition                  */
#define LINCAT_MACEXP       0x40        /* macro expansion                   */
#define LINCAT_INVISIBLE    0x80        /* does not appear in listing        */
#define LINCAT_LVLMASK      0x1F        /* mask for line levels (0..31)      */
 
struct linebuf *rootline = NULL;        /* pointer to 1st line of the file   */
struct linebuf *curline = NULL;         /* pointer to currently processed ln */
 
/*****************************************************************************/
/* Opcode definitions                                                        */
/*****************************************************************************/
 
struct oprecord
  {
  char * name;                          /* opcode mnemonic                   */
  unsigned char cat;                    /* opcode category                   */
  unsigned __int64 code;                /* category-dependent additional code*/
  unsigned char tgtNdx;
  };
 
                                        /* Instruction categories :          */
#define OPCAT_ONEBYTE        0x00       /* one byte opcodes             NOP  */
#define OPCAT_TWOBYTE        0x01       /* two byte opcodes             SWI2 */
#define OPCAT_THREEBYTE      0x02       /* three byte opcodes            TAB */
#define OPCAT_FOURBYTE       0x03       /* four byte opcodes             ABA */
#define OPCAT_IMMBYTE        0x04       /* opcodes w. imm byte         ANDCC */
#define OPCAT_LEA            0x05       /* load effective address       LEAX */
#define OPCAT_SBRANCH        0x06       /* short branches               BGE  */
#define OPCAT_LBR2BYTE       0x07       /* long branches 2 byte opc     LBGE */
#define OPCAT_LBR1BYTE       0x08       /* long branches 2 byte opc     LBRA */
#define OPCAT_ARITH          0x09       /* accumulator instr.           ADDA */
#define OPCAT_DBLREG1BYTE    0x0a       /* double reg instr 1 byte opc  LDX  */
#define OPCAT_DBLREG2BYTE    0x0b       /* double reg instr 2 byte opc  LDY  */
#define OPCAT_SINGLEADDR     0x0c       /* single address instrs        NEG  */
#define OPCAT_2REG           0x0d       /* 2 register instr         TFR,EXG  */
#define OPCAT_STACK          0x0e       /* stack instr             PSHx,PULx */
#define OPCAT_BITDIRECT      0x0f       /* direct bitmanipulation       AIM  */
#define OPCAT_BITTRANS       0x10       /* direct bit transfer         BAND  */
#define OPCAT_BLOCKTRANS     0x11       /* block transfer               TFM  */
#define OPCAT_IREG           0x12       /* inter-register operations   ADCR  */
#define OPCAT_QUADREG1BYTE   0x13       /* quad reg instr 1 byte opc    LDQ  */
#define OPCAT_2IMMBYTE       0x14       /* 2byte opcode w. imm byte    BITMD */
#define OPCAT_2ARITH         0x15       /* 2byte opcode accum. instr.   SUBE */
#define OPCAT_ACCARITH       0x16       /* acc. instr. w.explicit acc   ADD  */
#define OPCAT_IDXEXT         0x17       /* indexed/extended, 6800-style JMP  */
#define OPCAT_ACCADDR        0x18       /* single address instrs, 6800  NEG  */
#define OPCAT_PSEUDO         0x3f       /* pseudo-ops                        */
#define OPCAT_6309           0x40       /* valid for 6309 only!              */
#define OPCAT_NOIMM          0x80       /* immediate not allowed!       STD  */
 
                                        /* the various Pseudo-Ops            */
#define PSEUDO_RMB            0
#define PSEUDO_ELSE           1
#define PSEUDO_END            2
#define PSEUDO_ENDIF          3
#define PSEUDO_ENDM           4
#define PSEUDO_EQU            5
#define PSEUDO_EXT            6
#define PSEUDO_FCB            7
#define PSEUDO_FCC            8
#define PSEUDO_FCW            9
#define PSEUDO_IF            10
#define PSEUDO_MACRO         11
#define PSEUDO_ORG           12
#define PSEUDO_PUB           13
#define PSEUDO_SETDP         14
#define PSEUDO_SET           15
#define PSEUDO_INCLUDE       16
#define PSEUDO_OPT           17
#define PSEUDO_NAM           18
#define PSEUDO_STTL          19
#define PSEUDO_PAG           20
#define PSEUDO_SPC           21
#define PSEUDO_REP           22
#define PSEUDO_SETPG         23
#define PSEUDO_SETLI         24
#define PSEUDO_EXITM         25
#define PSEUDO_IFN           26
#define PSEUDO_IFC           27
#define PSEUDO_IFNC          28
#define PSEUDO_DUP           29
#define PSEUDO_ENDD          30
#define PSEUDO_REG           31
#define PSEUDO_ERR           32
#define PSEUDO_TEXT          33
#define PSEUDO_RZB           34
#define PSEUDO_ABS           35
#define PSEUDO_DEF           36
#define PSEUDO_ENDDEF        37
#define PSEUDO_COMMON        38
#define PSEUDO_ENDCOM        39
#define PSEUDO_NAME          40
#define PSEUDO_SYMLEN        41
#define PSEUDO_IFD           42
#define PSEUDO_IFND          43
#define PSEUDO_BINARY        44
#define PSEUDO_FCDW          45
 
struct oprecord optable09[]=
  {
  { "ABA",     OPCAT_FOURBYTE,    0x0340040ab0e0LL, 0 },
  { "ABS",     OPCAT_PSEUDO,      PSEUDO_ABS, 0 },
  { "ABX",     OPCAT_ONEBYTE,     0x3a, 0 },
  { "ABY",     OPCAT_TWOBYTE,     0x0310a5, 0 },
  { "ADC",     OPCAT_ACCARITH,    0x89, 0 },
  { "ADCA",    OPCAT_ARITH,       0x89, 0 },
  { "ADCB",    OPCAT_ARITH,       0xc9, 0 },
  { "ADCD",    OPCAT_6309 |
               OPCAT_DBLREG1BYTE, 0x189, 0 },
  { "ADCR",    OPCAT_6309 |
               OPCAT_IREG,        0x1031, 0 },
  { "ADD",     OPCAT_ACCARITH,    0x8b, 0 },
  { "ADDA",    OPCAT_ARITH,       0x8b, 0 },
  { "ADDB",    OPCAT_ARITH,       0xcb, 0 },
  { "ADDD",    OPCAT_DBLREG1BYTE, 0xc3, 0 },
  { "ADDE",    OPCAT_6309 |
               OPCAT_2ARITH,      0x118b, 0 },
  { "ADDF",    OPCAT_6309 |
               OPCAT_2ARITH,      0x11cb, 0 },
  { "ADDR",    OPCAT_6309 |
               OPCAT_IREG,        0x1030, 0 },
  { "ADDW",    OPCAT_6309 |
               OPCAT_DBLREG2BYTE, 0x108b, 0 },
  { "AIM",     OPCAT_6309 |
               OPCAT_BITDIRECT,   0x02, 0 },
  { "AND",     OPCAT_ACCARITH,    0x84, 0 },
  { "ANDA",    OPCAT_ARITH,       0x84, 0 },
  { "ANDB",    OPCAT_ARITH,       0xc4, 0 },
  { "ANDCC",   OPCAT_IMMBYTE,     0x1c, 0 },
  { "ANDD",    OPCAT_6309 |
               OPCAT_DBLREG1BYTE, 0x184, 0 },
  { "ANDR",    OPCAT_6309 |
               OPCAT_IREG,        0x1034, 0 },
  { "ASL",     OPCAT_SINGLEADDR,  0x08, 0 },
  { "ASLA",    OPCAT_ONEBYTE,     0x48, 0 },
  { "ASLB",    OPCAT_ONEBYTE,     0x58, 0 },
  { "ASLD",    OPCAT_TWOBYTE,     0x058049, 0 },
  { "ASLD63",  OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1048, 0 },
  { "ASR",     OPCAT_SINGLEADDR,  0x07, 0 },
  { "ASRA",    OPCAT_ONEBYTE,     0x47, 0 },
  { "ASRB",    OPCAT_ONEBYTE,     0x57, 0 },
  { "ASRD",    OPCAT_TWOBYTE,     0x047056, 0 },
  { "ASRD63",  OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1047, 0 },
  { "BAND",    OPCAT_6309 |
               OPCAT_BITTRANS,    0x1130, 0 },
  { "BCC",     OPCAT_SBRANCH,     0x24, 0 },
  { "BCS",     OPCAT_SBRANCH,     0x25, 0 },
  { "BEC",     OPCAT_SBRANCH,     0x24, 0 },
  { "BEOR",    OPCAT_6309 |
               OPCAT_BITTRANS,    0x1134, 0 },
  { "BEQ",     OPCAT_SBRANCH,     0x27, 0 },
  { "BES",     OPCAT_SBRANCH,     0x25, 0 },
  { "BGE",     OPCAT_SBRANCH,     0x2c, 0 },
  { "BGT",     OPCAT_SBRANCH,     0x2e, 0 },
  { "BHI",     OPCAT_SBRANCH,     0x22, 0 },
  { "BHS",     OPCAT_SBRANCH,     0x24, 0 },
  { "BIAND",   OPCAT_6309 |
               OPCAT_BITTRANS,    0x1131, 0 },
  { "BIEOR",   OPCAT_6309 |
               OPCAT_BITTRANS,    0x1135, 0 },
  { "BIN",     OPCAT_PSEUDO,      PSEUDO_BINARY, 0 },
  { "BINARY",  OPCAT_PSEUDO,      PSEUDO_BINARY, 0 },
  { "BIOR",    OPCAT_6309 |
               OPCAT_BITTRANS,    0x1133, 0 },
  { "BIT",     OPCAT_ACCARITH,    0x85, 0 },
  { "BITA",    OPCAT_ARITH,       0x85, 0 },
  { "BITB",    OPCAT_ARITH,       0xc5, 0 },
  { "BITD",    OPCAT_6309 |
               OPCAT_DBLREG1BYTE, 0x185, 0 },
  { "BITMD",   OPCAT_6309 |
               OPCAT_2IMMBYTE,    0x113c, 0 },
  { "BLE",     OPCAT_SBRANCH,     0x2f, 0 },
  { "BLO",     OPCAT_SBRANCH,     0x25, 0 },
  { "BLS",     OPCAT_SBRANCH,     0x23, 0 },
  { "BLT",     OPCAT_SBRANCH,     0x2d, 0 },
  { "BMI",     OPCAT_SBRANCH,     0x2b, 0 },
  { "BNE",     OPCAT_SBRANCH,     0x26, 0 },
  { "BOR",     OPCAT_6309 |
               OPCAT_BITTRANS,    0x1132, 0 },
  { "BPL",     OPCAT_SBRANCH,     0x2a, 0 },
  { "BRA",     OPCAT_SBRANCH,     0x20, 0 },
  { "BRN",     OPCAT_SBRANCH,     0x21, 0 },
  { "BSR",     OPCAT_SBRANCH,     0x8d, 0 },
  { "BVC",     OPCAT_SBRANCH,     0x28, 0 },
  { "BVS",     OPCAT_SBRANCH,     0x29, 0 },
  { "CBA",     OPCAT_FOURBYTE,    0x0340040a10e0LL, 0 },
  { "CLC",     OPCAT_TWOBYTE,     0x1c0fe, 0 },
  { "CLF",     OPCAT_TWOBYTE,     0x1c0bf, 0 },
  { "CLI",     OPCAT_TWOBYTE,     0x1c0ef, 0 },
  { "CLIF",    OPCAT_TWOBYTE,     0x1c0af, 0 },
  { "CLR",     OPCAT_SINGLEADDR,  0x0f, 0 },
  { "CLRA",    OPCAT_ONEBYTE,     0x4f, 0 },
  { "CLRB",    OPCAT_ONEBYTE,     0x5f, 0 },
  { "CLRD",    OPCAT_TWOBYTE,     0x4f05f, 0 },
  { "CLRD63",  OPCAT_6309 |
               OPCAT_TWOBYTE,     0x104f, 0 },
  { "CLRE",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x114f, 0 },
  { "CLRF",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x115f, 0 },
  { "CLRW",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x105f, 0 },
  { "CLV",     OPCAT_TWOBYTE,     0x1c0fd, 0 },
  { "CLZ",     OPCAT_TWOBYTE,     0x1c0fb, 0 },
  { "CMP",     OPCAT_ACCARITH,    0x81, 0 },
  { "CMPA",    OPCAT_ARITH,       0x81, 0 },
  { "CMPB",    OPCAT_ARITH,       0xc1, 0 },
  { "CMPD",    OPCAT_DBLREG1BYTE, 0x183, 0 },
  { "CMPE",    OPCAT_6309 |
               OPCAT_2ARITH,      0x1181, 0 },
  { "CMPF",    OPCAT_6309 |
               OPCAT_2ARITH,      0x11c1, 0 },
  { "CMPR",    OPCAT_6309 |
               OPCAT_IREG,        0x1037, 0 },
  { "CMPS",    OPCAT_DBLREG1BYTE, 0x28c, 4 },
  { "CMPU",    OPCAT_DBLREG1BYTE, 0x283, 3 },
  { "CMPW",    OPCAT_6309 |
               OPCAT_DBLREG2BYTE, 0x1081, 0 },
  { "CMPX",    OPCAT_DBLREG1BYTE, 0x8c, 1 },
  { "CMPY",    OPCAT_DBLREG1BYTE, 0x18c, 2 },
  { "COM",     OPCAT_SINGLEADDR,  0x03, 0 },
  { "COMA",    OPCAT_ONEBYTE,     0x43, 0 },
  { "COMB",    OPCAT_ONEBYTE,     0x53, 0 },
  { "COMD",    OPCAT_6309 |
               OPCAT_ONEBYTE,     0x143, 0 },
  { "COME",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1143, 0  },
  { "COMF",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1153, 0 },
  { "COMW",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1053, 0 },
  { "COMMON",  OPCAT_PSEUDO,      PSEUDO_COMMON, 0 },
  { "CPD",     OPCAT_DBLREG1BYTE, 0x183, 0 },
  { "CPX",     OPCAT_DBLREG1BYTE, 0x8c, 1 },
  { "CPY",     OPCAT_DBLREG1BYTE, 0x18c, 2 },
  { "CWAI",    OPCAT_IMMBYTE,     0x3c, 0 },
  { "DAA",     OPCAT_ONEBYTE,     0x19, 0 },
  { "DEC",     OPCAT_SINGLEADDR,  0x0a, 0 },
  { "DECA",    OPCAT_ONEBYTE,     0x4a, 0 },
  { "DECB",    OPCAT_ONEBYTE,     0x5a, 0 },
  { "DECD",    OPCAT_THREEBYTE,   0x083000001LL, 0 },
  { "DECD63",  OPCAT_6309 |
               OPCAT_TWOBYTE,     0x104a, 0 },
  { "DECE",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x114a, 0 },
  { "DECF",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x115a, 0 },
  { "DECW",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x105a, 0 },
  { "DEF",     OPCAT_PSEUDO,      PSEUDO_DEF, 0 },
  { "DEFINE",  OPCAT_PSEUDO,      PSEUDO_DEF, 0 },
  { "DES",     OPCAT_TWOBYTE,     0x327ff, 4 },
  { "DEU",     OPCAT_TWOBYTE,     0x335ff, 3 },
  { "DEX",     OPCAT_TWOBYTE,     0x301ff, 1 },
  { "DEY",     OPCAT_TWOBYTE,     0x313ff, 2 },
  { "DIVD",    OPCAT_6309 |
               OPCAT_2ARITH,      0x118d, 0 },
  { "DIVQ",    OPCAT_6309 |
               OPCAT_DBLREG2BYTE, 0x118e, 0 },
  { "DUP",     OPCAT_PSEUDO,      PSEUDO_DUP, 0 },
  { "EIM",     OPCAT_6309 |
               OPCAT_BITDIRECT,   0x05, 0 },
  { "ELSE",    OPCAT_PSEUDO,      PSEUDO_ELSE, 0 },
  { "END",     OPCAT_PSEUDO,      PSEUDO_END, 0 },
  { "ENDCOM",  OPCAT_PSEUDO,      PSEUDO_ENDCOM, 0 },
  { "ENDD",    OPCAT_PSEUDO,      PSEUDO_ENDD, 0 },
  { "ENDDEF",  OPCAT_PSEUDO,      PSEUDO_ENDDEF, 0 },
  { "ENDIF",   OPCAT_PSEUDO,      PSEUDO_ENDIF, 0 },
  { "ENDM",    OPCAT_PSEUDO,      PSEUDO_ENDM, 0 },
  { "EOR",     OPCAT_ACCARITH,    0x88, 0 },
  { "EORA",    OPCAT_ARITH,       0x88, 0 },
  { "EORB",    OPCAT_ARITH,       0xc8, 0 },
  { "EORD",    OPCAT_6309 |
               OPCAT_DBLREG1BYTE, 0x188, 0 },
  { "EORR",    OPCAT_6309 |
               OPCAT_IREG,        0x1036, 0 },
  { "EQU",     OPCAT_PSEUDO,      PSEUDO_EQU, 0 },
  { "ERR",     OPCAT_PSEUDO,      PSEUDO_ERR, 0 },
  { "EXG",     OPCAT_2REG,        0x1e, 0 },
  { "EXITM",   OPCAT_PSEUDO,      PSEUDO_EXITM, 0 },
  { "EXT",     OPCAT_PSEUDO,      PSEUDO_EXT, 0 },
  { "EXTERN",  OPCAT_PSEUDO,      PSEUDO_EXT, 0 },
  { "FCB",     OPCAT_PSEUDO,      PSEUDO_FCB, 0 },
  { "FCC",     OPCAT_PSEUDO,      PSEUDO_FCC, 0 },
  { "FCDW",    OPCAT_PSEUDO,      PSEUDO_FCDW, 0 },
  { "FCW",     OPCAT_PSEUDO,      PSEUDO_FCW, 0 },
  { "FDB",     OPCAT_PSEUDO,      PSEUDO_FCW, 0 },
  { "GLOBAL",  OPCAT_PSEUDO,      PSEUDO_PUB, 0 },
  { "IF",      OPCAT_PSEUDO,      PSEUDO_IF, 0 },
  { "IFC",     OPCAT_PSEUDO,      PSEUDO_IFC, 0 },
  { "IFD",     OPCAT_PSEUDO,      PSEUDO_IFD, 0 },
  { "IFN",     OPCAT_PSEUDO,      PSEUDO_IFN, 0 },
  { "IFNC",    OPCAT_PSEUDO,      PSEUDO_IFNC, 0 },
  { "IFND",    OPCAT_PSEUDO,      PSEUDO_IFND, 0 },
  { "INC",     OPCAT_SINGLEADDR,  0x0c, 0 },
  { "INCA",    OPCAT_ONEBYTE,     0x4c, 0 },
  { "INCB",    OPCAT_ONEBYTE,     0x5c, 0 },
  { "INCD",    OPCAT_THREEBYTE,   0x0c3000001LL, 0 },
  { "INCD63",  OPCAT_6309 |
               OPCAT_TWOBYTE,     0x104c, 0 },
  { "INCE",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x114c, 0 },
  { "INCF",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x115c, 0 },
  { "INCLUDE", OPCAT_PSEUDO,      PSEUDO_INCLUDE, 0 },
  { "INCW",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x105c, 0 },
  { "INS",     OPCAT_TWOBYTE,     0x32601, 4 },
  { "INU",     OPCAT_TWOBYTE,     0x33401, 3 },
  { "INX",     OPCAT_TWOBYTE,     0x30001, 1 },
  { "INY",     OPCAT_TWOBYTE,     0x31201, 2 },
  { "JMP",     OPCAT_SINGLEADDR,  0x0e, 0 },
  { "JSR",     OPCAT_DBLREG1BYTE, 0x8d, 0 },
  { "LBCC",    OPCAT_LBR1BYTE,    0x124, 0 },
  { "LBCS",    OPCAT_LBR1BYTE,    0x125, 0 },
  { "LBEC",    OPCAT_LBR1BYTE,    0x124, 0 },
  { "LBEQ",    OPCAT_LBR1BYTE,    0x127, 0 },
  { "LBES",    OPCAT_LBR1BYTE,    0x125, 0 },
  { "LBGE",    OPCAT_LBR1BYTE,    0x12c, 0 },
  { "LBGT",    OPCAT_LBR1BYTE,    0x12e, 0 },
  { "LBHI",    OPCAT_LBR1BYTE,    0x122, 0 },
  { "LBHS",    OPCAT_LBR1BYTE,    0x124, 0 },
  { "LBLE",    OPCAT_LBR1BYTE,    0x12f, 0 },
  { "LBLO",    OPCAT_LBR1BYTE,    0x125, 0 },
  { "LBLS",    OPCAT_LBR1BYTE,    0x123, 0 },
  { "LBLT",    OPCAT_LBR1BYTE,    0x12d, 0 },
  { "LBMI",    OPCAT_LBR1BYTE,    0x12b, 0 },
  { "LBNE",    OPCAT_LBR1BYTE,    0x126, 0 },
  { "LBPL",    OPCAT_LBR1BYTE,    0x12a, 0 },
  { "LBRA",    OPCAT_LBR1BYTE,    0x16, 0 },
  { "LBRN",    OPCAT_LBR1BYTE,    0x121, 0 },
  { "LBSR",    OPCAT_LBR1BYTE,    0x17, 0 },
  { "LBVC",    OPCAT_LBR1BYTE,    0x128, 0 },
  { "LBVS",    OPCAT_LBR1BYTE,    0x129, 0 },
  { "LD",      OPCAT_ACCARITH,    0x86, 0 },
  { "LDA",     OPCAT_ARITH,       0x86, 0 },
  { "LDAA",    OPCAT_ARITH,       0x86, 0 },
  { "LDAB",    OPCAT_ARITH,       0xc6, 0 },
  { "LDAD",    OPCAT_DBLREG1BYTE, 0xcc, 0 },
  { "LDB",     OPCAT_ARITH,       0xc6, 0 },
  { "LDBT",    OPCAT_6309 |
               OPCAT_BITTRANS,    0x1136, 0 },
  { "LDD",     OPCAT_DBLREG1BYTE, 0xcc, 0 },
  { "LDE",     OPCAT_6309 |
               OPCAT_2ARITH,      0x1186, 0 },
  { "LDF",     OPCAT_6309 |
               OPCAT_2ARITH,      0x11c6, 0 },
  { "LDMD",    OPCAT_6309 |
               OPCAT_2IMMBYTE,    0x113d, 0 },
  { "LDQ",     OPCAT_6309 |
               OPCAT_QUADREG1BYTE,0x10cc, 0 },
  { "LDS",     OPCAT_DBLREG1BYTE, 0x1ce, 4 },
  { "LDU",     OPCAT_DBLREG1BYTE, 0xce, 3 },
  { "LDW",     OPCAT_6309 |
               OPCAT_DBLREG2BYTE, 0x1086, 0 },
  { "LDX",     OPCAT_DBLREG1BYTE, 0x8e, 1 },
  { "LDY",     OPCAT_DBLREG1BYTE, 0x18e, 2 },
  { "LEAS",    OPCAT_LEA,         0x32, 4 },
  { "LEAU",    OPCAT_LEA,         0x33, 3 },
  { "LEAX",    OPCAT_LEA,         0x30, 1 },
  { "LEAY",    OPCAT_LEA,         0x31, 2 },
  { "LIB",     OPCAT_PSEUDO,      PSEUDO_INCLUDE, 0 },
  { "LIBRARY", OPCAT_PSEUDO,      PSEUDO_INCLUDE, 0 },
  { "LSL",     OPCAT_SINGLEADDR,  0x08, 0 },
  { "LSLA",    OPCAT_ONEBYTE,     0x48, 0 },
  { "LSLB",    OPCAT_ONEBYTE,     0x58, 0 },
  { "LSLD",    OPCAT_TWOBYTE,     0x58049, 0 },
  { "LSLD63",  OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1048, 0 },
  { "LSR",     OPCAT_SINGLEADDR,  0x04, 0 },
  { "LSRA",    OPCAT_ONEBYTE,     0x44, 0 },
  { "LSRB",    OPCAT_ONEBYTE,     0x54, 0 },
  { "LSRD",    OPCAT_TWOBYTE,     0x44056, 0 },
  { "LSRD63",  OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1044, 0 },
  { "LSRW",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1054, 0 },
  { "MACRO",   OPCAT_PSEUDO,      PSEUDO_MACRO, 0 },
  { "MUL",     OPCAT_ONEBYTE,     0x3d, 0 },
  { "MULD",    OPCAT_6309 |
               OPCAT_DBLREG2BYTE, 0x118f, 0 },
  { "NAM",     OPCAT_PSEUDO,      PSEUDO_NAM, 0 },
  { "NAME",    OPCAT_PSEUDO,      PSEUDO_NAME, 0 },
  { "NEG",     OPCAT_SINGLEADDR,  0x00, 0 },
  { "NEGA",    OPCAT_ONEBYTE,     0x40, 0 },
  { "NEGB",    OPCAT_ONEBYTE,     0x50, 0 },
  { "NEGD",    OPCAT_6309 |
               OPCAT_ONEBYTE,     0x140, 0 },
  { "NOP",     OPCAT_ONEBYTE,     0x12, 0 },
  { "OIM",     OPCAT_6309 |
               OPCAT_BITDIRECT,   0x01, 0 },
  { "OPT",     OPCAT_PSEUDO,      PSEUDO_OPT, 0 },
  { "OPTION",  OPCAT_PSEUDO,      PSEUDO_OPT, 0 },
  { "ORA",     OPCAT_ARITH,       0x8a, 0 },
  { "ORAA",    OPCAT_ARITH,       0x8a, 0 },
  { "ORAB",    OPCAT_ARITH,       0xca, 0 },
  { "ORB",     OPCAT_ARITH,       0xca, 0 },
  { "ORCC",    OPCAT_IMMBYTE,     0x1a, 0 },
  { "ORD",     OPCAT_6309 |
               OPCAT_DBLREG1BYTE, 0x18a, 0 },
  { "ORG",     OPCAT_PSEUDO,      PSEUDO_ORG, 0 },
  { "ORR",     OPCAT_6309 |
               OPCAT_IREG,        0x1035, 0 },
  { "PAG",     OPCAT_PSEUDO,      PSEUDO_PAG, 0 },
  { "PAGE",    OPCAT_PSEUDO,      PSEUDO_PAG, 0 },
  { "PSH",     OPCAT_STACK,       0x34, 0 },
  { "PSHA",    OPCAT_TWOBYTE,     0x34002, 0 },
  { "PSHB",    OPCAT_TWOBYTE,     0x34004, 0 },
  { "PSHD",    OPCAT_TWOBYTE,     0x34006, 0 },
  { "PSHS",    OPCAT_STACK,       0x34, 4 },
  { "PSHSW",   OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1038, 0 },
  { "PSHU",    OPCAT_STACK,       0x36, 3 },
  { "PSHUW",   OPCAT_6309 |
               OPCAT_TWOBYTE,     0x103a, 0 },
  { "PSHX",    OPCAT_TWOBYTE,     0x34010, 1 },
  { "PSHY",    OPCAT_TWOBYTE,     0x34020, 2 },
  { "PUB",     OPCAT_PSEUDO,      PSEUDO_PUB, 0 },
  { "PUBLIC",  OPCAT_PSEUDO,      PSEUDO_PUB, 0 },
  { "PUL",     OPCAT_STACK,       0x35, 0 },
  { "PULA",    OPCAT_TWOBYTE,     0x35002, 0 },
  { "PULB",    OPCAT_TWOBYTE,     0x35004, 0 },
  { "PULD",    OPCAT_TWOBYTE,     0x35006, 0 },
  { "PULS",    OPCAT_STACK,       0x35, 4 },
  { "PULSW",   OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1039, 0 },
  { "PULU",    OPCAT_STACK,       0x37, 3 },
  { "PULUW",   OPCAT_6309 |
               OPCAT_TWOBYTE,     0x103b, 0 },
  { "PULX",    OPCAT_TWOBYTE,     0x35010, 1 },
  { "PULY",    OPCAT_TWOBYTE,     0x35020, 2 },
  { "REG",     OPCAT_PSEUDO,      PSEUDO_REG, 0 },
  { "REP",     OPCAT_PSEUDO,      PSEUDO_REP, 0 },
  { "REPEAT",  OPCAT_PSEUDO,      PSEUDO_REP, 0 },
  { "RESET",   OPCAT_ONEBYTE,     0x3e, 0 },
  { "RMB",     OPCAT_PSEUDO,      PSEUDO_RMB, 0 },
  { "ROL",     OPCAT_SINGLEADDR,  0x09, 0 },
  { "ROLA",    OPCAT_ONEBYTE,     0x49, 0 },
  { "ROLB",    OPCAT_ONEBYTE,     0x59, 0 },
  { "ROLD",    OPCAT_6309 |
               OPCAT_ONEBYTE,     0x149, 0 },
  { "ROLW",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1059, 0 },
  { "ROR",     OPCAT_SINGLEADDR,  0x06, 0 },
  { "RORA",    OPCAT_ONEBYTE,     0x46, 0 },
  { "RORB",    OPCAT_ONEBYTE,     0x56, 0 },
  { "RORD",    OPCAT_6309 |
               OPCAT_ONEBYTE,     0x146, 0 },
  { "RORW",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x1056, 0 },
  { "RPT",     OPCAT_PSEUDO,      PSEUDO_REP, 0 },
  { "RTF",     OPCAT_ONEBYTE,     0x38, 0 },
  { "RTI",     OPCAT_ONEBYTE,     0x3b, 0 },
  { "RTS",     OPCAT_ONEBYTE,     0x39, 0 },
  { "RZB",     OPCAT_PSEUDO,      PSEUDO_RZB, 0 },
  { "SBA",     OPCAT_FOURBYTE,    0x0340040a00e0LL, 0 },
  { "SBC",     OPCAT_ACCARITH,    0x82, 0 },
  { "SBCA",    OPCAT_ARITH,       0x82, 0 },
  { "SBCB",    OPCAT_ARITH,       0xc2, 0 },
  { "SBCD",    OPCAT_6309 |
               OPCAT_DBLREG1BYTE, 0x182, 0 },
  { "SBCR",    OPCAT_6309 |
               OPCAT_IREG,        0x1033, 0 },
  { "SEC",     OPCAT_TWOBYTE,     0x1a001, 0 },
  { "SEF",     OPCAT_TWOBYTE,     0x1a040, 0 },
  { "SEI",     OPCAT_TWOBYTE,     0x1a010, 0 },
  { "SEIF",    OPCAT_TWOBYTE,     0x1a050, 0 },
  { "SET",     OPCAT_PSEUDO,      PSEUDO_SET, 0 },
  { "SETDP",   OPCAT_PSEUDO,      PSEUDO_SETDP, 0 },
  { "SETLI",   OPCAT_PSEUDO,      PSEUDO_SETLI, 0 },
  { "SETPG",   OPCAT_PSEUDO,      PSEUDO_SETPG, 0 },
  { "SEV",     OPCAT_TWOBYTE,     0x1a002, 0 },
  { "SEX",     OPCAT_ONEBYTE,     0x1d, 0 },
  { "SEXW",    OPCAT_6309 |
               OPCAT_ONEBYTE,     0x14, 0 },
  { "SEZ",     OPCAT_TWOBYTE,     0x1a004, 0 },
  { "SPC",     OPCAT_PSEUDO,      PSEUDO_SPC, 0 },
  { "STA",     OPCAT_NOIMM |
               OPCAT_ARITH,       0x87, 0 },
  { "STAA",    OPCAT_NOIMM |
               OPCAT_ARITH,       0x87, 0 },
  { "STAB",    OPCAT_NOIMM |
               OPCAT_ARITH,       0xc7, 0 },
  { "STAD",    OPCAT_NOIMM |
               OPCAT_DBLREG1BYTE, 0xcd, 0 },
  { "STB",     OPCAT_NOIMM |
               OPCAT_ARITH,       0xc7, 0 },
  { "STBT",    OPCAT_6309 |
               OPCAT_BITTRANS,    0x1137, 0 },
  { "STD",     OPCAT_NOIMM |
               OPCAT_DBLREG1BYTE, 0xcd, 0 },
  { "STE",     OPCAT_NOIMM |
               OPCAT_6309 |
               OPCAT_2ARITH,      0x1187, 0 },
  { "STF",     OPCAT_NOIMM |
               OPCAT_6309 |
               OPCAT_2ARITH,      0x11c7, 0 },
  { "STQ",     OPCAT_NOIMM |
               OPCAT_6309 |
               OPCAT_QUADREG1BYTE,0x10cd, 0 },
  { "STS",     OPCAT_NOIMM |
               OPCAT_DBLREG1BYTE, 0x1cf, 4 },
  { "STTL",    OPCAT_PSEUDO,      PSEUDO_STTL, 0 },
  { "STU",     OPCAT_NOIMM |
               OPCAT_DBLREG1BYTE, 0xcf, 3 },
  { "STW",     OPCAT_NOIMM |
               OPCAT_6309 |
               OPCAT_DBLREG2BYTE, 0x1087, 0 },
  { "STX",     OPCAT_NOIMM |
               OPCAT_DBLREG1BYTE, 0x8f, 1 },
  { "STY",     OPCAT_NOIMM |
               OPCAT_DBLREG1BYTE, 0x18f, 2 },
  { "SUB",     OPCAT_ACCARITH,    0x80, 0 },
  { "SUBA",    OPCAT_ARITH,       0x80, 0 },
  { "SUBB",    OPCAT_ARITH,       0xc0, 0 },
  { "SUBD",    OPCAT_DBLREG1BYTE, 0x83, 0 },
  { "SUBE",    OPCAT_6309 |
               OPCAT_2ARITH,      0x1180, 0 },
  { "SUBF",    OPCAT_6309 |
               OPCAT_2ARITH,      0x11c0, 0 },
  { "SUBW",    OPCAT_6309 |
               OPCAT_DBLREG2BYTE, 0x1080, 0 },
  { "SUBR",    OPCAT_6309 |
               OPCAT_IREG,        0x1032, 0 },
  { "SWI",     OPCAT_ONEBYTE,     0x3f, 0 },
  { "SWI2",    OPCAT_ONEBYTE,     0x13f, 0 },
  { "SWI3",    OPCAT_ONEBYTE,     0x23f, 0 },
  { "SYMLEN",  OPCAT_PSEUDO,      PSEUDO_SYMLEN, 0 },
  { "SYNC",    OPCAT_ONEBYTE,     0x13, 0 },
  { "TAB",     OPCAT_THREEBYTE,   0x1f08904d, 0 },
  { "TAP",     OPCAT_TWOBYTE,     0x1f08a, 0 },
  { "TBA",     OPCAT_THREEBYTE,   0x1f09804dLL, 0 },
  { "TEXT",    OPCAT_PSEUDO,      PSEUDO_TEXT, 0 },
  { "TFM",     OPCAT_6309 |
               OPCAT_BLOCKTRANS,  0x1138, 0 },
  { "TFR",     OPCAT_2REG,        0x1f, 0 },
  { "TIM",     OPCAT_6309 |
               OPCAT_BITDIRECT,   0x0b, 0 },
  { "TITLE",   OPCAT_PSEUDO,      PSEUDO_NAM, 0 },
  { "TPA",     OPCAT_TWOBYTE,     0x1f0a8, 0 },
  { "TST",     OPCAT_SINGLEADDR,  0x0d, 0 },
  { "TSTA",    OPCAT_ONEBYTE,     0x4d, 0 },
  { "TSTB",    OPCAT_ONEBYTE,     0x5d, 0 },
  { "TSTD",    OPCAT_6309 |
               OPCAT_ONEBYTE,     0x14d, 0 },
  { "TSTE",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x114d, 0 },
  { "TSTF",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x115d, 0 },
  { "TSTW",    OPCAT_6309 |
               OPCAT_TWOBYTE,     0x105d, 0 },
  { "TSX",     OPCAT_TWOBYTE,     0x1f041, 1 },
  { "TSY",     OPCAT_FOURBYTE,    0x034040035020LL, 2 },  /* PSHS S/PULS Y */
  { "TTL",     OPCAT_PSEUDO,      PSEUDO_NAM, 0 },
  { "TXS",     OPCAT_TWOBYTE,     0x1f014, 4 },
  { "TYS",     OPCAT_FOURBYTE,    0x034020035040LL, 4 },  /* PSHS Y/PULS S */
  { "WAI",     OPCAT_TWOBYTE,     0x3c0ff, 0 },
  { "WORD",    OPCAT_PSEUDO,      PSEUDO_FCW, 0 },
};
 
struct oprecord optable00[]=
  {
  { "ABA",     OPCAT_ONEBYTE,     0x1b },
  { "ABS",     OPCAT_PSEUDO,      PSEUDO_ABS },
  { "ADC",     OPCAT_ACCARITH,    0x89 },
  { "ADCA",    OPCAT_ARITH,       0x89 },
  { "ADCB",    OPCAT_ARITH,       0xc9 },
  { "ADD",     OPCAT_ACCARITH,    0x8b },
  { "ADDA",    OPCAT_ARITH,       0x8b },
  { "ADDB",    OPCAT_ARITH,       0xcb },
  { "AND",     OPCAT_ACCARITH,    0x84 },
  { "ANDA",    OPCAT_ARITH,       0x84 },
  { "ANDB",    OPCAT_ARITH,       0xc4 },
  { "ASL",     OPCAT_ACCADDR,     0x08 },
  { "ASLA",    OPCAT_ONEBYTE,     0x48 },
  { "ASLB",    OPCAT_ONEBYTE,     0x58 },
  { "ASR",     OPCAT_ACCADDR,     0x07 },
  { "ASRA",    OPCAT_ONEBYTE,     0x47 },
  { "ASRB",    OPCAT_ONEBYTE,     0x57 },
  { "BCC",     OPCAT_SBRANCH,     0x24 },
  { "BCS",     OPCAT_SBRANCH,     0x25 },
  { "BEC",     OPCAT_SBRANCH,     0x24 },
  { "BEQ",     OPCAT_SBRANCH,     0x27 },
  { "BES",     OPCAT_SBRANCH,     0x25 },
  { "BGE",     OPCAT_SBRANCH,     0x2c },
  { "BGT",     OPCAT_SBRANCH,     0x2e },
  { "BHI",     OPCAT_SBRANCH,     0x22 },
  { "BHS",     OPCAT_SBRANCH,     0x24 },
  { "BIN",     OPCAT_PSEUDO,      PSEUDO_BINARY },
  { "BINARY",  OPCAT_PSEUDO,      PSEUDO_BINARY },
  { "BIT",     OPCAT_ACCARITH,    0x85 },
  { "BITA",    OPCAT_ARITH,       0x85 },
  { "BITB",    OPCAT_ARITH,       0xc5 },
  { "BLE",     OPCAT_SBRANCH,     0x2f },
  { "BLO",     OPCAT_SBRANCH,     0x25 },
  { "BLS",     OPCAT_SBRANCH,     0x23 },
  { "BLT",     OPCAT_SBRANCH,     0x2d },
  { "BMI",     OPCAT_SBRANCH,     0x2b },
  { "BNE",     OPCAT_SBRANCH,     0x26 },
  { "BPL",     OPCAT_SBRANCH,     0x2a },
  { "BRA",     OPCAT_SBRANCH,     0x20 },
  { "BSR",     OPCAT_SBRANCH,     0x8d },
  { "BVC",     OPCAT_SBRANCH,     0x28 },
  { "BVS",     OPCAT_SBRANCH,     0x29 },
  { "CBA",     OPCAT_ONEBYTE,     0x11 },
  { "CLC",     OPCAT_ONEBYTE,     0x0c },
  { "CLI",     OPCAT_ONEBYTE,     0x0e },
  { "CLR",     OPCAT_ACCADDR,     0x0f },
  { "CLRA",    OPCAT_ONEBYTE,     0x4f },
  { "CLRB",    OPCAT_ONEBYTE,     0x5f },
  { "CLV",     OPCAT_ONEBYTE,     0x0a },
  { "CMP",     OPCAT_ACCARITH,    0x81 },
  { "CMPA",    OPCAT_ARITH,       0x81 },
  { "CMPB",    OPCAT_ARITH,       0xc1 },
  { "COM",     OPCAT_ACCADDR,     0x03 },
  { "COMA",    OPCAT_ONEBYTE,     0x43 },
  { "COMB",    OPCAT_ONEBYTE,     0x53 },
  { "CPX",     OPCAT_DBLREG1BYTE, 0x8c },
  { "DAA",     OPCAT_ONEBYTE,     0x19 },
  { "DEC",     OPCAT_ACCADDR,     0x0a },
  { "DECA",    OPCAT_ONEBYTE,     0x4a },
  { "DECB",    OPCAT_ONEBYTE,     0x5a },
  { "DEF",     OPCAT_PSEUDO,      PSEUDO_DEF },
  { "DEFINE",  OPCAT_PSEUDO,      PSEUDO_DEF },
  { "DES",     OPCAT_ONEBYTE,     0x34 },
  { "DEX",     OPCAT_ONEBYTE,     0x09 },
  { "DUP",     OPCAT_PSEUDO,      PSEUDO_DUP },
  { "ELSE",    OPCAT_PSEUDO,      PSEUDO_ELSE },
  { "END",     OPCAT_PSEUDO,      PSEUDO_END },
  { "ENDCOM",  OPCAT_PSEUDO,      PSEUDO_ENDCOM },
  { "ENDD",    OPCAT_PSEUDO,      PSEUDO_ENDD },
  { "ENDDEF",  OPCAT_PSEUDO,      PSEUDO_ENDDEF },
  { "ENDIF",   OPCAT_PSEUDO,      PSEUDO_ENDIF },
  { "ENDM",    OPCAT_PSEUDO,      PSEUDO_ENDM },
  { "EOR",     OPCAT_ACCARITH,    0x88 },
  { "EORA",    OPCAT_ARITH,       0x88 },
  { "EORB",    OPCAT_ARITH,       0xc8 },
  { "EQU",     OPCAT_PSEUDO,      PSEUDO_EQU },
  { "ERR",     OPCAT_PSEUDO,      PSEUDO_ERR },
  { "EXITM",   OPCAT_PSEUDO,      PSEUDO_EXITM },
  { "EXT",     OPCAT_PSEUDO,      PSEUDO_EXT },
  { "EXTERN",  OPCAT_PSEUDO,      PSEUDO_EXT },
  { "FCB",     OPCAT_PSEUDO,      PSEUDO_FCB },
  { "FCC",     OPCAT_PSEUDO,      PSEUDO_FCC },
  { "FCW",     OPCAT_PSEUDO,      PSEUDO_FCW },
  { "FDB",     OPCAT_PSEUDO,      PSEUDO_FCW },
  { "GLOBAL",  OPCAT_PSEUDO,      PSEUDO_PUB },
  { "IF",      OPCAT_PSEUDO,      PSEUDO_IF },
  { "IFC",     OPCAT_PSEUDO,      PSEUDO_IFC },
  { "IFD",     OPCAT_PSEUDO,      PSEUDO_IFD },
  { "IFN",     OPCAT_PSEUDO,      PSEUDO_IFN },
  { "IFNC",    OPCAT_PSEUDO,      PSEUDO_IFNC },
  { "IFND",    OPCAT_PSEUDO,      PSEUDO_IFND },
  { "INC",     OPCAT_ACCADDR,     0x0c },
  { "INCA",    OPCAT_ONEBYTE,     0x4c },
  { "INCB",    OPCAT_ONEBYTE,     0x5c },
  { "INCLUDE", OPCAT_PSEUDO,      PSEUDO_INCLUDE },
  { "INS",     OPCAT_ONEBYTE,     0x31 },
  { "INX",     OPCAT_ONEBYTE,     0x08 },
  { "JMP",     OPCAT_IDXEXT,      0x4e },
  { "JSR",     OPCAT_IDXEXT,      0x8d },
  { "LDA",     OPCAT_ACCARITH,    0x86 },
  { "LDAA",    OPCAT_ARITH,       0x86 },
  { "LDAB",    OPCAT_ARITH,       0xc6 },
  { "LDB",     OPCAT_ARITH,       0xc6 },
  { "LDS",     OPCAT_DBLREG1BYTE, 0x8e },
  { "LDX",     OPCAT_DBLREG1BYTE, 0xce },
  { "LIB",     OPCAT_PSEUDO,      PSEUDO_INCLUDE },
  { "LIBRARY", OPCAT_PSEUDO,      PSEUDO_INCLUDE },
  { "LSL",     OPCAT_ACCADDR,     0x08 },
  { "LSLA",    OPCAT_ONEBYTE,     0x48 },
  { "LSLB",    OPCAT_ONEBYTE,     0x58 },
  { "LSR",     OPCAT_ACCADDR,     0x04 },
  { "LSRA",    OPCAT_ONEBYTE,     0x44 },
  { "LSRB",    OPCAT_ONEBYTE,     0x54 },
  { "MACRO",   OPCAT_PSEUDO,      PSEUDO_MACRO },
  { "NAM",     OPCAT_PSEUDO,      PSEUDO_NAM },
  { "NAME",    OPCAT_PSEUDO,      PSEUDO_NAME },
  { "NEG",     OPCAT_ACCADDR,     0x00 },
  { "NEGA",    OPCAT_ONEBYTE,     0x40 },
  { "NEGB",    OPCAT_ONEBYTE,     0x50 },
  { "NOP",     OPCAT_ONEBYTE,     0x01 },
  { "OPT",     OPCAT_PSEUDO,      PSEUDO_OPT },
  { "OPTION",  OPCAT_PSEUDO,      PSEUDO_OPT },
  { "ORA",     OPCAT_ARITH,       0x8a },
  { "ORAA",    OPCAT_ARITH,       0x8a },
  { "ORAB",    OPCAT_ARITH,       0xca },
  { "ORB",     OPCAT_ARITH,       0xca },
  { "ORG",     OPCAT_PSEUDO,      PSEUDO_ORG },
  { "PAG",     OPCAT_PSEUDO,      PSEUDO_PAG },
  { "PAGE",    OPCAT_PSEUDO,      PSEUDO_PAG },
  { "PSHA",    OPCAT_ONEBYTE,     0x36 },
  { "PSHB",    OPCAT_ONEBYTE,     0x37 },
  { "PUB",     OPCAT_PSEUDO,      PSEUDO_PUB },
  { "PUBLIC",  OPCAT_PSEUDO,      PSEUDO_PUB },
  { "PULA",    OPCAT_ONEBYTE,     0x32 },
  { "PULB",    OPCAT_ONEBYTE,     0x33 },
  { "REG",     OPCAT_PSEUDO,      PSEUDO_REG },
  { "REP",     OPCAT_PSEUDO,      PSEUDO_REP },
  { "REPEAT",  OPCAT_PSEUDO,      PSEUDO_REP },
  { "RMB",     OPCAT_PSEUDO,      PSEUDO_RMB },
  { "ROL",     OPCAT_ACCADDR,     0x09 },
  { "ROLA",    OPCAT_ONEBYTE,     0x49 },
  { "ROLB",    OPCAT_ONEBYTE,     0x59 },
  { "ROR",     OPCAT_ACCADDR,     0x06 },
  { "RORA",    OPCAT_ONEBYTE,     0x46 },
  { "RORB",    OPCAT_ONEBYTE,     0x56 },
  { "RPT",     OPCAT_PSEUDO,      PSEUDO_REP },
  { "RTI",     OPCAT_ONEBYTE,     0x3b },
  { "RTS",     OPCAT_ONEBYTE,     0x39 },
  { "RZB",     OPCAT_PSEUDO,      PSEUDO_RZB },
  { "SBA",     OPCAT_ONEBYTE,     0x10 },
  { "SBC",     OPCAT_ACCARITH,    0x82 },
  { "SBCA",    OPCAT_ARITH,       0x82 },
  { "SBCB",    OPCAT_ARITH,       0xc2 },
  { "SEC",     OPCAT_ONEBYTE,     0x0d },
  { "SEI",     OPCAT_ONEBYTE,     0x0f },
  { "SET",     OPCAT_PSEUDO,      PSEUDO_SET },
//{ "SETDP",   OPCAT_PSEUDO,      PSEUDO_SETDP },
  { "SETLI",   OPCAT_PSEUDO,      PSEUDO_SETLI },
  { "SETPG",   OPCAT_PSEUDO,      PSEUDO_SETPG },
  { "SEV",     OPCAT_ONEBYTE,     0x0b },
  { "SPC",     OPCAT_PSEUDO,      PSEUDO_SPC },
  { "STA",     OPCAT_NOIMM |
               OPCAT_ACCARITH,    0x87 },
  { "STAA",    OPCAT_NOIMM |
               OPCAT_ARITH,       0x87 },
  { "STAB",    OPCAT_NOIMM |
               OPCAT_ARITH,       0xc7 },
  { "STS",     OPCAT_NOIMM |
               OPCAT_DBLREG1BYTE, 0x8f },
  { "STTL",    OPCAT_PSEUDO,      PSEUDO_STTL },
  { "STX",     OPCAT_NOIMM |
               OPCAT_DBLREG1BYTE, 0xcf },
  { "SUB",     OPCAT_ACCARITH,    0x80 },
  { "SUBA",    OPCAT_ARITH,       0x80 },
  { "SUBB",    OPCAT_ARITH,       0xc0 },
  { "SWI",     OPCAT_ONEBYTE,     0x3f },
  { "SYMLEN",  OPCAT_PSEUDO,      PSEUDO_SYMLEN },
  { "TAB",     OPCAT_ONEBYTE,     0x16 },
  { "TAP",     OPCAT_ONEBYTE,     0x06 },
  { "TBA",     OPCAT_ONEBYTE,     0x17 },
  { "TEXT",    OPCAT_PSEUDO,      PSEUDO_TEXT },
  { "TITLE",   OPCAT_PSEUDO,      PSEUDO_NAM },
  { "TPA",     OPCAT_ONEBYTE,     0x07 },
  { "TST",     OPCAT_ACCADDR,     0x0d },
  { "TSTA",    OPCAT_ONEBYTE,     0x4d },
  { "TSTB",    OPCAT_ONEBYTE,     0x5d },
  { "TSX",     OPCAT_ONEBYTE,     0x30 },
  { "TTL",     OPCAT_PSEUDO,      PSEUDO_NAM },
  { "TXS",     OPCAT_ONEBYTE,     0x35 },
  { "WAI",     OPCAT_ONEBYTE,     0x3e },
  };
 
/* expression categories...
   all zeros is ordinary constant.
   bit 1 indicates address within module.
   bit 2 indicates external address.
   bit 4 indicates this can't be relocated if it's an address.
   bit 5 indicates address (if any) is negative.
*/
 
#define EXPRCAT_INTADDR       0x02
#define EXPRCAT_EXTADDR       0x04
#define EXPRCAT_PUBLIC        0x08
#define EXPRCAT_FIXED         0x10
#define EXPRCAT_NEGATIVE      0x20
 
/*****************************************************************************/
/* Symbol definitions                                                        */
/*****************************************************************************/
 
struct symrecord
  {
  char name[MAXIDLEN + 1];              /* symbol name                       */
  char cat;                             /* symbol category                   */
  char isFar;                                           /* far assumed */
  char isFarkw;                                         /* FAR keyword used in symbol definiton */
  unsigned value;                 /* symbol value                      */
  union
    {
    struct symrecord *parent;           /* parent symbol (for COMMON)        */
    long flags;                         /* forward reference flag (otherwise)*/
    } u;
  };
 
                                        /* symbol categories :               */
#define SYMCAT_CONSTANT       0x00      /* constant value (from equ)         */
#define SYMCAT_VARIABLE       0x01      /* variable value (from set)         */
#define SYMCAT_LABEL          0x02      /* address within module (label)     */
#define SYMCAT_VARADDR        0x03      /* variable containing address       */
#define SYMCAT_EXTERN         0x04      /* address in other module (extern)  */
#define SYMCAT_VAREXTERN      0x05      /* variable containing extern addr.  */
#define SYMCAT_UNRESOLVED     0x06      /* unresolved address                */
#define SYMCAT_VARUNRESOLVED  0x07      /* var. containing unresolved addr   */
#define SYMCAT_PUBLIC         0x08      /* public label                      */
#define SYMCAT_MACRO          0x09      /* macro definition                  */
#define SYMCAT_PUBLICUNDEF    0x0A      /* public label (yet undefined)      */
#define SYMCAT_PARMNAME       0x0B      /* parameter name                    */
#define SYMCAT_EMPTY          0x0D      /* empty                             */
#define SYMCAT_REG            0x0E      /* REG directive                     */
#define SYMCAT_TEXT           0x0F      /* /Dsymbol or TEXT label            */
#define SYMCAT_COMMONDATA     0x12      /* COMMON Data                       */
#define SYMCAT_COMMON         0x14      /* COMMON block                      */
#define SYMCAT_LOCALLABEL     0x22      /* local label                       */
#define SYMCAT_EMPTYLOCAL     0x26      /* empty local label                 */
 
                                        /* symbol flags:                     */
#define SYMFLAG_FORWARD       0x01      /* forward reference                 */
#define SYMFLAG_PASSED        0x02      /* passed forward reference          */
 
long symcounter = 0;                    /* # currently loaded symbols        */
struct symrecord symtable[MAXLABELS];   /* symbol table (fixed size)         */
long lclcounter = 0;                    /* # currently loaded local symbols  */
struct symrecord lcltable[MAXLABELS];   /* local symbol table (fixed size)   */
 
/*****************************************************************************/
/* regrecord structure definition                                            */
/*****************************************************************************/
 
struct regrecord
  {
  char *name;                           /* name of the register              */
  unsigned char tfr, psh;               /* bit value for tfr and psh/pul     */
  };
 
/*****************************************************************************/
/* regtable : table of all registers                                         */
/*****************************************************************************/
 
struct regrecord regtable09[]=
  {
  { "D",   0x00, 0x06 },
  { "X",   0x01, 0x10 },
  { "Y",   0x02, 0x20 },
  { "U",   0x03, 0x40 },
  { "S",   0x04, 0x40 },
  { "PC",  0x05, 0x80 },
  { "A",   0x08, 0x02 },
  { "B",   0x09, 0x04 },
  { "CC",  0x0a, 0x01 },
  { "CCR", 0x0a, 0x01 },
  { "DP",  0x0b, 0x08 },
  { "DPR", 0x0b, 0x08 },
  { 0,     0,    0    }
  };
 
struct regrecord regtable63[]=          /* same for HD6309                   */
  {
  { "D",   0x00, 0x06 },
  { "X",   0x01, 0x10 },
  { "Y",   0x02, 0x20 },
  { "U",   0x03, 0x40 },
  { "S",   0x04, 0x40 },
  { "PC",  0x05, 0x80 },
  { "W",   0x06, 0x00 },
  { "V",   0x07, 0x00 },
  { "A",   0x08, 0x02 },
  { "B",   0x09, 0x04 },
  { "CC",  0x0a, 0x01 },
  { "CCR", 0x0a, 0x01 },
  { "DP",  0x0b, 0x08 },
  { "DPR", 0x0b, 0x08 },
  { "0",   0x0c, 0x00 },
  { "E",   0x0e, 0x00 },
  { "F",   0x0f, 0x00 },
  { 0,     0,    0    }
  };
 
struct regrecord regtable00[]=
  {
  { "X",   0x01, 0x10 },
  { "S",   0x04, 0x40 },
  { "PC",  0x05, 0x80 },
  { "A",   0x08, 0x02 },
  { "B",   0x09, 0x04 },
  { "CC",  0x0a, 0x01 },
  { "CCR", 0x0a, 0x01 },
  { 0,     0,    0    }
  };
 
/*****************************************************************************/
/* bitregtable : table of all bit transfer registers                         */
/*****************************************************************************/
 
struct regrecord bitregtable09[] =
  {
  { "CC",  0x00, 0x00 },
  { "A",   0x01, 0x01 },
  { "B",   0x02, 0x02 },
  };
 
struct regrecord bitregtable00[] =
  {
  { "CC",  0x00, 0x00 },
  { "A",   0x01, 0x01 },
  { "B",   0x02, 0x02 },
  };
 
/*****************************************************************************/
/* relocrecord structure definition                                          */
/*****************************************************************************/
 
struct relocrecord
  {
  unsigned addr;                  /* address that needs relocation     */
  char exprcat;                         /* expression category               */
  struct symrecord *sym;                /* symbol for relocation             */
  };
 
long relcounter = 0;                    /* # currently defined relocations   */
struct relocrecord reltable[MAXRELOCS]; /* relocation table (fixed size)     */
long relhdrfoff;                        /* FLEX Relocatable Global Hdr Offset*/
 
/*****************************************************************************/
/* Options definitions                                                       */
/*****************************************************************************/
 
#define OPTION_M09    0x00000001L       /* MC6809 mode                       */
#define OPTION_H63    0x00000002L       /* HD6309 mode                       */
#define OPTION_M00    0x00000004L       /* MC6800 mode                       */
#define OPTION_PAG    0x00000008L       /* page formatting ON                */
#define OPTION_CON    0x00000010L       /* print cond. skipped code          */
#define OPTION_MAC    0x00000020L       /* print macro calling line (default)*/
#define OPTION_EXP    0x00000040L       /* print macro expansion lines       */
#define OPTION_SYM    0x00000080L       /* print symbol table (default)      */
#define OPTION_MUL    0x00000100L       /* print multiple oc lines (default) */
#define OPTION_LP1    0x00000200L       /* print pass 1 listing              */
#define OPTION_DAT    0x00000400L       /* print date in listing (default)   */
#define OPTION_NUM    0x00000800L       /* print line numbers                */
#define OPTION_INV    0x00001000L       /* print invisible lines             */
#define OPTION_TSC    0x00002000L       /* TSC-compatible source format      */
#define OPTION_WAR    0x00004000L       /* print warnings                    */
#define OPTION_CLL    0x00008000L       /* check line length (default)       */
#define OPTION_LFN    0x00010000L       /* print long file names             */
#define OPTION_LLL    0x00020000L       /* list library lines                */
#define OPTION_GAS    0x00040000L       /* Gnu AS compatibility              */
#define OPTION_REL    0x00080000L       /* print relocation table            */
#define OPTION_TXT    0x00100000L       /* print text table                  */
#define OPTION_LIS    0x00200000L       /* print assembler output listing    */
#define OPTION_LPA    0x00400000L       /* listing in f9dasm patch format    */
#define OPTION_RTF        0x00800000L
#define OPTION_X32        0x01000000L           /* 32 bit index registers            */
#define OPTION_X16        0x02000000L           /* 32 bit index registers            */
 
struct
  {
  char *Name;
  unsigned long dwAdd;
  unsigned long dwRem;
  } Options[] =
  {/*Name          Add      Remove */
  { "PAG",  OPTION_PAG,          0 },
  { "NOP",           0, OPTION_PAG },
  { "CON",  OPTION_CON,          0 },
  { "NOC",           0, OPTION_CON },
  { "MAC",  OPTION_MAC,          0 },
  { "NOM",           0, OPTION_MAC },
  { "EXP",  OPTION_EXP,          0 },
  { "NOE",           0, OPTION_EXP },
  { "SYM",  OPTION_SYM,          0 },
  { "NOS",           0, OPTION_SYM },
  { "MUL",  OPTION_MUL,          0 },
  { "NMU",           0, OPTION_MUL },
  { "LP1",  OPTION_LP1,          0 },
  { "NO1",           0, OPTION_LP1 },
  { "DAT",  OPTION_DAT,          0 },
  { "NOD",           0, OPTION_DAT },
  { "NUM",  OPTION_NUM,          0 },
  { "NON",           0, OPTION_NUM },
  { "INV",  OPTION_INV,          0 },
  { "NOI",           0, OPTION_INV },
  { "TSC",  OPTION_TSC,          0 },
  { "NOT",           0, OPTION_TSC },
  { "WAR",  OPTION_WAR,          0 },
  { "NOW",           0, OPTION_WAR },
  { "CLL",  OPTION_CLL,          0 },
  { "NCL",           0, OPTION_CLL },
  { "LFN",  OPTION_LFN,          0 },
  { "NLF",           0, OPTION_LFN },
  { "LLL",  OPTION_LLL,          0 },
  { "NLL",           0, OPTION_LLL },
  { "GAS",  OPTION_GAS,          0 },
  { "NOG",           0, OPTION_GAS },
  { "REL",  OPTION_REL,          0 },
  { "NOR",           0, OPTION_REL },
  { "H63",  OPTION_H63, OPTION_M09 | OPTION_M00 },
  { "M68",  OPTION_M09, OPTION_H63 | OPTION_M00 },
  { "M09",  OPTION_M09, OPTION_H63 | OPTION_M00 },
  { "M00",  OPTION_M00, OPTION_H63 | OPTION_M09 },
  { "TXT",  OPTION_TXT,          0 },
  { "NTX",           0, OPTION_TXT },
  { "LIS",  OPTION_LIS,          0 },
  { "NOL",           0, OPTION_LIS },
  { "LPA",  OPTION_LPA, OPTION_NUM | OPTION_CLL }, // LPA inhibits NUM / CLL!
  { "NLP",           0, OPTION_LPA },
  { "X32",  OPTION_X32, OPTION_X16 },
  { "X16",  OPTION_X16, OPTION_X32 }
  };
 
unsigned long dwOptions =               /* options flags, init to default    */
    OPTION_M09 |
    OPTION_MAC |
    OPTION_SYM |
    OPTION_MUL |
    OPTION_DAT |
    OPTION_WAR |
    OPTION_CLL |
    OPTION_LLL |
    OPTION_REL |
    OPTION_LIS;
 
/*****************************************************************************/
/* arrays of error/warning messages                                          */
/*****************************************************************************/
                                        /* defined error flags               */
#define ERR_OK            0x0000        /* all is well                       */
#define ERR_EXPR          0x0001        /* Error in expression               */
#define ERR_ILLEGAL_ADDR  0x0002        /* Illegal adressing mode            */
#define ERR_LABEL_UNDEF   0x0004        /* Undefined label                   */
#define ERR_LABEL_MULT    0x0008        /* Label multiply defined            */
#define ERR_RANGE         0x0010        /* Relative branch out of range      */
#define ERR_LABEL_MISSING 0x0020        /* Missing label                     */
#define ERR_OPTION_UNK    0x0040        /* Option unknown                    */
#define ERR_MALLOC        0x0080        /* Out of memory                     */
#define ERR_NESTING       0x0100        /* Nesting not allowed               */
#define ERR_RELOCATING    0x0200        /* Statement not valid for reloc mode*/
#define ERR_ERRTXT        0x4000        /* ERR text output                   */
#define ERR_ILLEGAL_MNEM  0x8000        /* Illegal mnemonic                  */
 
char *errormsg[]=
  {
  "Error in expression",                /* 1     ERR_EXPR                    */
  "Illegal addressing mode",            /* 2     ERR_ILLEGAL_ADDR            */
  "Undefined label",                    /* 4     ERR_LABEL_UNDEF             */
  "Multiple definitions of label",      /* 8     ERR_LABEL_MULT              */
  "Relative branch out of range",       /* 16    ERR_RANGE                   */
  "Missing label",                      /* 32    ERR_LABEL_MISSING           */
  "Unknown option specified",           /* 64    ERR_OPTION_UNK              */
  "Out of memory",                      /* 128   ERR_MALLOC                  */
  "Nesting not allowed",                /* 256   ERR_NESTING                 */
  "Illegal for current relocation mode",/* 512   ERR_RELOCATING              */
  "",                                   /* 1024                              */
  "",                                   /* 2048                              */
  "",                                   /* 4096                              */
  "",                                   /* 8192                              */
  NULL,                                 /* 16384 ERR_ERRTXT (ERR output)     */
  "Illegal mnemonic"                    /* 32768 ERR_ILLEGAL_MNEM            */
  };
 
                                        /* defined warning flags             */
#define WRN_OK            0x0000        /* All OK                            */
#define WRN_OPT           0x0001        /* Long branch in short range        */
#define WRN_SYM           0x0002        /* Symbolic text undefined           */
#define WRN_AREA          0x0004        /* Area already in use               */
#define WRN_AMBIG         0x0008        /* Ambiguous 6800 opcode             */
 
char *warningmsg[] =
  {
  "Long branch within short branch "    /* 1     WRN_OPT                     */
      "range could be optimized",
  "Symbolic text undefined",            /* 2     WRN_SYM                     */
  "Area already in use",                /* 4     WRN_AREA                    */
  "Ambiguous 6800 alternate notation",  /* 8     WRN_AMBIG                   */
  "",                                   /* 16                                */
  "",                                   /* 32                                */
  "",                                   /* 64                                */
  "",                                   /* 128                               */
  "",                                   /* 256                               */
  "",                                   /* 512                               */
  "",                                   /* 1024                              */
  "",                                   /* 2048                              */
  "",                                   /* 4096                              */
  "",                                   /* 8192                              */
  "",                                   /* 18384                             */
  ""                                    /* 32768                             */
  };
 
/*****************************************************************************/
/* Listing Definitions                                                       */
/*****************************************************************************/
 
#define LIST_OFF  0x00                  /* listing is generally off          */
#define LIST_ON   0x01                  /* listing is generally on           */
 
char listing = LIST_OFF;                /* listing flag                      */
 
/*****************************************************************************/
/* Global variables                                                          */
/*****************************************************************************/
 
FILE *listfile = NULL;                  /* list file                         */
FILE *objfile = NULL;                   /* object file                       */
char listname[FNLEN + 1];               /* list file name                    */
char objname[FNLEN + 1];                /* object file name                  */
char srcname[FNLEN + 1];                /* source file name                  */
 
                                        /* assembler mode specifics:         */
struct oprecord *optable = optable09;   /* used op table                     */
                                        /* size of this table                */
int optablesize = sizeof(optable09) / sizeof(optable09[0]);
struct regrecord *regtable = regtable09;/* used register table               */
                                        /* used bit register table           */
struct regrecord *bitregtable = bitregtable09;
void scanoperands09(struct relocrecord *pp);
void (*scanoperands)(struct relocrecord *) = scanoperands09;
 
char pass;                              /* Assembler pass = 1 or 2           */
char relocatable = 0;                   /* relocatable object flag           */
char absmode = 1;                       /* absolute mode                     */
long global = 0;                        /* all labels global flag            */
long common = 0;                        /* common definition flag            */
struct symrecord * commonsym = NULL;    /* current common main symbol        */
char terminate;                         /* termination flag                  */
char generating;                        /* code generation flag              */
unsigned loccounter,oldlc;        /* Location counter                  */
 
char inpline[LINELEN];                  /* Current input line (not expanded) */
char srcline[LINELEN];                  /* Current source line               */
char * srcptr;                          /* Pointer to line being parsed      */
 
char unknown;          /* flag to indicate value unknown */
char certain;          /* flag to indicate value is certain at pass 1*/
long error;            /* flags indicating errors in current line. */
long errors;           /* number of errors in current pass */
long warning;          /* flags indicating warnings in current line */
long warnings;         /* number of warnings in current pass */
long nTotErrors;                        /* total # of errors                 */
long nTotWarnings;                      /* total # warnings                  */
char exprcat;          /* category of expression being parsed, eg.
                          label or constant, this is important when
                          generating relocatable object code. */
 
int maxidlen = MAXIDLEN;                /* maximum ID length                 */
 
char modulename[MAXIDLEN + 1] = "";     /* module name buffer                */
char namebuf[MAXIDLEN + 1];             /* name buffer for parsing           */
char unamebuf[MAXIDLEN + 1];            /* name buffer in uppercase          */
 
char isFar,isFarkw;
int vercount;
char mode;
char isX32;
char isPostIndexed;
 
/* adressing mode:                   */
#define ADRMODE_IMM  0                  /* 0 = immediate                     */
#define ADRMODE_DIR  1                  /* 1 = direct                        */
#define ADRMODE_EXT  2                  /* 2 = extended                      */
#define ADRMODE_IDX  3                  /* 3 = indexed                       */
#define ADRMODE_POST 4                  /* 4 = postbyte                      */
#define ADRMODE_PCR  5                  /* 5 = PC relative (with postbyte)   */
#define ADRMODE_IND  6                  /* 6 = indirect                      */
#define ADRMODE_PIN  7                  /* 7 = PC relative & indirect        */
#define ADRMODE_DBL_IND 8
 
char opsize;                            /* desired operand size :            */
                                        /* 0=dunno,1=5, 2=8, 3=16, 4=32      */
long operand;
unsigned short postbyte;
 
long dpsetting = 0;                     /* Direct Page Default = 0           */
 
unsigned short codebuf[256];
int codeptr;                            /* byte offset within instruction    */
int suppress;                           /* 0=no suppress                     */
                                        /* 1=until ENDIF                     */
                                        /* 2=until ELSE                      */
                                        /* 3=until ENDM                      */
char condline = 0;                      /* flag whether on conditional line  */
int ifcount;                            /* count of nested IFs within        */
                                        /* suppressed text                   */
 
#define OUT_NONE  -1                    /* no output                         */
#define OUT_BIN   0                     /* binary output                     */
#define OUT_SREC  1                     /* Motorola S-Records                */
#define OUT_IHEX  2                     /* Intel Hex Records                 */
#define OUT_FLEX  3                     /* Flex9 ASMB-compatible output      */
#define OUT_GAS   4                     /* GNU relocation output             */
#define OUT_REL   5                     /* Flex9 RELASMB output              */
#define OUT_VER   6
int outmode = OUT_BIN;                  /* default to binary output          */
 
unsigned hexaddr;
int hexcount;
unsigned short hexbuffer[256];
unsigned int chksum;
unsigned vslide;
 
int nRepNext = 0;                       /* # repetitions for REP pseudo-op   */
int nSkipCount = 0;                     /* # lines to skip                   */
 
unsigned tfradr = 0;
int tfradrset = 0;
 
int nCurLine = 0;                       /* current output line on page       */
int nCurCol = 0;                        /* current output column on line     */
int nCurPage = 0;                       /* current page #                    */
int nLinesPerPage = 66;                 /* # lines on a page                 */
int nColsPerLine = 200;                  /* # columns per line                */
char szTitle[128] = "";                 /* title for listings                */
char szSubtitle[128] = "";              /* subtitle for listings             */
 
char szBuf1[LINELEN];                   /* general-purpose buffers for parse */
char szBuf2[LINELEN];
 
struct linebuf *macros[MAXMACROS];      /* pointers to the macros            */
int nMacros = 0;                        /* # parsed macros                   */
int inMacro = 0;                        /* flag whether in macro definition  */
 
char *texts[MAXTEXTS];                  /* pointers to the texts             */
int nPredefinedTexts = 0;               /* # predefined texts                */
int nTexts = 0;                         /* # currently defined texts         */
 
//unsigned char bUsedBytes[8192] = {0};   /* 1 bit per byte of the address spc */
 
/*****************************************************************************/
/* Necessary forward declarations                                            */
/*****************************************************************************/
 
void processline();
struct linebuf *readfile(char *name, unsigned char lvl, struct linebuf *after);
struct linebuf *readbinary(char *name, unsigned char lvl, struct linebuf *after, struct symrecord *lp);
 
/*****************************************************************************/
/* allocline : allocates a line of text                                      */
/*****************************************************************************/
 
struct linebuf * allocline
    (
    struct linebuf *prev,
    char *fn,
    int line,
    unsigned char lvl,
    char *text
    )
{
struct linebuf *pNew = malloc(sizeof(struct linebuf) + strlen(text));
if (!pNew)
  return NULL;
pNew->next = (prev) ? prev->next : NULL;
pNew->prev = prev;
if (prev)
  prev->next = pNew;
if (pNew->next)
  pNew->next->prev = pNew;
pNew->lvl = lvl;
pNew->fn = fn;
pNew->ln = line;
pNew->rel = ' ';
strcpy(pNew->txt, text);
return pNew;
}
 
/*****************************************************************************/
/* expandfn : eventually expands a file name to full-blown path              */
/*****************************************************************************/
 
char const *expandfn(char const *fn)
{
#ifdef WIN32
static char szBuf[_MAX_PATH];           /* allocate big buffer               */
 
if (dwOptions & OPTION_LFN)             /* if long file names wanted         */
  return _fullpath(szBuf, fn, sizeof(szBuf));
#endif
 
return fn;                              /* can't do that yet                 */
}
 
/*****************************************************************************/
/* PageFeed : advances the list file                                         */
/*****************************************************************************/
 
void PageFeed()
{
time_t tim;
struct tm *ltm;
 
time(&tim);
ltm = localtime(&tim);
 
fputc('\x0c', listfile);                /* print header                      */
nCurPage++;                             /* advance to next page              */
fprintf(listfile, "\n\n%-32.32s ", szTitle);
if (dwOptions & OPTION_DAT)
  fprintf(listfile,
          "%04d-%02d-%02d ",
          ltm->tm_year + 1900,
          ltm->tm_mon + 1,
          ltm->tm_mday);
fprintf(listfile,
        "A09 %d Assembler V" VERSION " Page %d\n",
        (dwOptions & OPTION_H63) ? 6309 :
            (dwOptions & OPTION_M00) ? 6800 :
            6809,
        nCurPage);
fprintf(listfile, "%-.79s\n\n", szSubtitle);
 
nCurLine = 5;                           /* remember current line             */
nCurCol = 0;                            /* and reset current column          */
}
 
/*****************************************************************************/
/* putlist : puts something to the list file                                 */
/*****************************************************************************/
 
void putlist(char *szFmt, ...)
{
char szList[1024];                      /* buffer for 1k list output         */
char *p;
 
va_list al;
va_start(al, szFmt);
vsprintf(szList, szFmt, al);            /* generate formatted output buffer  */
va_end(al);
 
for (p = szList; *p; p++)               /* then walk through the buffer      */
  {
  fputc(*p, listfile);                  /* print out each character          */
  if (*p == '\n')                       /* if newline sent                   */
    {
    nCurLine++;
    nCurCol = 0;
    if ((nCurLine >= nLinesPerPage) &&  /* if beyond # lines per page        */
        (dwOptions & OPTION_PAG))       /* if pagination activated           */
      PageFeed();                       /* do a page feed                    */
    }
  else                                  /* if another character              */
    {
    nCurCol++;                          /* advance to next column            */
    if (dwOptions & OPTION_CLL)         /* if line length checked            */
      {
                                        /* check if word would go too far    */
      if ((nCurCol >= nColsPerLine * 3 / 4) &&
          (*p == ' '))
        {
        int i;                          /* look whether more delimiters      */
        char c;
        for (i = nCurCol + 1; i < nColsPerLine; i++)
          {
          c = p[i - nCurCol];
          if ((c == '\t') || (c == ' ') || (!c))
            break;
          }
        if (i >= nColsPerLine)          /* if no more delimiters,            */
          nCurCol = nColsPerLine;       /* make sure to advance to new line  */
        }
 
      if (nCurCol >= nColsPerLine)      /* if it IS too far                  */
        {
        putlist("\n");                  /* recurse with a newline            */
        nCurCol = 0;
        }
      }
    }
  }
}
 
/*****************************************************************************/
/* findop : finds a mnemonic in table using binary search                    */
/*****************************************************************************/
 
struct oprecord * findop(char * nm)
{
int lo,hi,i,s;
 
lo = 0;
hi = optablesize - 1;
do
  {
  i = (lo + hi) / 2;
  s = strcmp(optable[i].name, nm);
  if (s < 0)
    lo = i + 1;
  else if (s > 0)
    hi = i - 1;
  else
    break;
  } while (hi >= lo);
if (s)
  return NULL;
return optable + i;
}
 
/*****************************************************************************/
/* findlocal : finds a local symbol table record                             */
/*****************************************************************************/
 
struct symrecord * findlocal(struct symrecord *sym, char forward, int insert)
{
static struct symrecord empty = {"", SYMCAT_EMPTYLOCAL, 0, {0}};
int lo,hi,i,j,s;
 
if ((!sym) ||                           /* if no main symbol for that        */
    ((!insert) &&                       /* or not inserting, but             */
     (sym->cat == SYMCAT_EMPTYLOCAL)))  /*    yet undefined label            */
  return sym;                           /* pass back main symbol             */
 
lo = 0;                                 /* do binary search for the thing    */
hi = lclcounter - 1;
s = 1;
i = 0;
while (hi >= lo)
  {
  i = (lo + hi) / 2;
  s = lcltable[i].value - loccounter;   /* binary search for current address */
  if (s < 0)
    lo = i + 1;
  else if (s > 0)
    hi = i - 1;
  else                                  /* if found,                         */
    {                                   /* go to 1st of this value           */
    while ((i) && (lcltable[i - 1].value == loccounter))
      i--;
    while ((i < lclcounter) &&          /* search for the NAME now           */
           (lcltable[i].value == loccounter))
      {
      s = strcmp(sym->name, lcltable[i].name);
      if (s <= 0)
        {
        if (s)
          i--;
        break;
        }
      i++;
      }
    if (s)                              /* if not found, re-set              */
      {
      if (i >= lclcounter)
        s = 1;
      else
        s = lcltable[i].value - loccounter;
      }
    break;
    }
  }
 
if (insert)                             /* if inserting,                     */
  {
  if (!s)                               /* if address is already in use      */
    {                                   /* but not the correct label         */
    if (strcmp(sym->name, lcltable[i].name))
      error |= ERR_LABEL_MULT;          /* set error                         */
    return lcltable + i;                /* return the local symbol           */
    }
  i = (s < 0 ? i + 1 : i);
  if (lclcounter == MAXLABELS)
    {
    printf("%s(%ld): error 25: out of local symbol storage\n",
           expandfn(curline->fn), curline->ln);
    if (((dwOptions & OPTION_LP1) || pass ==  MAX_PASSNO) && (listing & LIST_ON))
      putlist( "*** Error 25: out of local symbol storage\n");
    exit(4);
    }
  sym->cat = SYMCAT_LOCALLABEL;
  for (j = lclcounter; j > i; j--)
    lcltable[j] = lcltable[j - 1];
  lclcounter++;
  strcpy(lcltable[i].name, sym->name);
  lcltable[i].cat = SYMCAT_LOCALLABEL;
  lcltable[i].value = loccounter;
  lcltable[i].u.parent = NULL;
  return lcltable + i;                  /* pass back this symbol             */
  }
 
if (forward)                            /* if forward search                 */
  {
  i = (s < 0 ? i - 1 : i);
  for (; i < lclcounter; i++)
    {
    if ((!strcmp(lcltable[i].name, sym->name)) &&
        (lcltable[i].value > loccounter))
      return lcltable + i;
    }
  }
else                                    /* if backward search                */
  {
  i = (s > 0 ? i + 1 : i);
  for (; i >= 0; i--)
    {
    if ((!strcmp(lcltable[i].name, sym->name)) &&
        (lcltable[i].value <= loccounter))
      return lcltable + i;
    }
  }
 
return &empty;                          /* if not found, return empty label  */
}
 
/*****************************************************************************/
/* findsym : finds symbol table record; inserts if not found                 */
/*           uses binary search, maintains sorted table                      */
/*****************************************************************************/
 
struct symrecord * findsym (char * nm, int insert)
{
int lo,hi,i,j,s;
char islocal = 0, forward = 0;
char name[MAXIDLEN + 1] = "";
                                        /* copy name to internal buffer      */
strncpy(name, (nm) ? nm : "", sizeof(name) - 1);
for (i = 0; name[i]; i++)               /* determine whether local label     */
  if ((name[i] < '0') || (name[i] > '9'))
    break;
if (i)                                  /* if starting with number           */
  {
  if (!name[i])                         /* if ONLY numeric                   */
    islocal = 1;                        /* this is a local label             */
  else                                  /* otherwise check direction         */
    {
    switch(toupper(name[i]))
      {
      case 'B' :                        /* backward reference ?              */
        islocal = 2;                    /* this is a local label reference   */
        forward = 0;
        break;
      case 'F' :                        /* forward reference ?               */
        islocal = 2;                    /* this is a local label reference   */
        forward = 1;
        break;
      }
    if (islocal && name[i + 1])         /* if followed by anything else      */
      islocal = 0;                      /* reset flag for local label        */
    else                                /* otherwise                         */
      name[i] = 0;                      /* remove the direction              */
    }
  }
 
lo = 0;                                 /* do binary search for the thing    */
hi = symcounter - 1;
s = 1;
i = 0;
while (hi >= lo)
  {
  i = (lo + hi) / 2;
  s = strcmp(symtable[i].name, name);
  if (s < 0)
    lo = i + 1;
  else if (s > 0)
    hi = i - 1;
  else
    break;
  }
 
if (s)                                  /* if symbol not found               */
  {
  if (!insert)                          /* if inserting prohibited,          */
    return NULL;                        /* return without pointer            */
 
  i = (s < 0 ? i + 1 : i);
  if (symcounter == MAXLABELS)
    {
    printf("%s(%ld): error 23: out of symbol storage\n",
           expandfn(curline->fn), curline->ln);
    if (((dwOptions & OPTION_LP1) || pass == MAX_PASSNO) && (listing & LIST_ON))
      putlist( "*** Error 23: out of symbol storage\n");
    exit(4);
    }
  if (commonsym >= symtable + i)
    commonsym++;
  for (j = 0; j < symcounter; j++)
    if (symtable[j].u.parent >= symtable + i)
      symtable[j].u.parent++;
  for (j = symcounter; j > i; j--)
    symtable[j] = symtable[j-1];
  symcounter++;
  strcpy(symtable[i].name, name);
  symtable[i].cat = (islocal) ? SYMCAT_EMPTYLOCAL : SYMCAT_EMPTY;
  symtable[i].value = 0;
  symtable[i].u.flags = 0;
  }
 
if (islocal)                            /* if searching for a local label    */
  return findlocal(symtable + i,        /* search for the local label        */
                   forward, (islocal < 2));
 
return symtable + i;                    /* return the found or inserted sym  */
}
 
/*****************************************************************************/
/* findsymat : finds 1st symbol fo a given address                           */
/*****************************************************************************/
 
char *findsymat(unsigned addr)
{
/* since the symbol table is sorted by name, this needs a sequential search  */
int i;
for (i = 0; i < symcounter; i++)
  if (symtable[i].cat != SYMCAT_EMPTY)
    {
    if (symtable[i].cat == SYMCAT_TEXT)
      continue;
    if (symtable[i].value == addr)
      return symtable[i].name;
    }
return NULL;
}
 
/*****************************************************************************/
/* settext : sets a text symbol                                              */
/*****************************************************************************/
 
int settext(char *namebuf, char *text)
{
struct symrecord *lp = findsym(namebuf, 1);
int len;
int special = 0;
 
if (!lp)
  {
  error |= ERR_LABEL_UNDEF;
  return -1;
  }
if (lp->cat != SYMCAT_EMPTY &&
    lp->cat != SYMCAT_TEXT)
  {
  error |= ERR_LABEL_MULT;
  return -1;
  }
 
if (lp->cat != SYMCAT_EMPTY)
  free(texts[lp->value]);
else if (nTexts >= MAXTEXTS)
  {
  error |= ERR_MALLOC;
  return -1;
  }
else
  {
  lp->cat = SYMCAT_TEXT;
  lp->value = nTexts++;
  }
 
if (!text)                              /* if NULL input                     */
  text = "";                            /* assume empty string               */
 
for (len = 0; text[len]; len++)
  if ((isspace(text[len])) ||
      (text[len] == ','))
    special = 1;
if (!len)                               /* empty string?                     */
  special = 1;                          /* that's special anyway.            */
if (special && len &&                   /* if delimited special string       */
    (text[0] == '\'' || text[0] == '\"') &&
    (text[len - 1] == text[0]))
  special = 0;                          /* forget that "special" flag        */
 
len += (special) ? 3 : 1;
texts[lp->value] = malloc(len);
if (texts[lp->value])
  {
  if (special)
    texts[lp->value][0] = '\"';
  strcpy(texts[lp->value] + special, text);
  if (special)
    strcat(texts[lp->value], "\"");
  }
 
return lp->value;
}
 
/*****************************************************************************/
/* outsymtable : prints the symbol table                                     */
/*****************************************************************************/
 
void outsymtable()
{
int i,j = 0;
 
if (dwOptions & OPTION_PAG)             /* if pagination active,             */
  {
  if (nCurLine > 5)                     /* if not on 1st line,               */
    PageFeed();                         /* shift to next page                */
  }
else
  putlist("\n");
 
putlist("SYMBOL TABLE");
for (i = 0; i < symcounter; i++)
  if (symtable[i].cat != SYMCAT_EMPTY)
    {
                                        /* suppress listing of predef texts  */
    if ((symtable[i].cat == SYMCAT_TEXT) &&
        (symtable[i].value < nPredefinedTexts))
      continue;
                                        /* if local label                    */
    if (symtable[i].cat == SYMCAT_LOCALLABEL)
      {
      int k;                            /* walk local label list             */
      for (k = 0; k < lclcounter; k++)
        if (!strcmp(lcltable[k].name, symtable[i].name))
          {
          if (j % 4 == 0)
            putlist("\n");
          putlist( " %9s %02d %08X", lcltable[k].name, lcltable[k].cat,
                                     lcltable[k].value);
          j++;
          }
      }
    else                                /* if normal label                   */
      {
      if (j % 4 == 0)
        putlist("\n");
      putlist( " %9s %02d %08X", symtable[i].name,symtable[i].cat,
                                 symtable[i].value);
      j++;
      }
    }
putlist("\n%d SYMBOLS\n", j);
}
 
/*****************************************************************************/
/* outreltable : prints the relocation table                                 */
/*****************************************************************************/
 
void outreltable()
{
int i,j = 0;
 
if (dwOptions & OPTION_PAG)             /* if pagination active,             */
  {
  if (nCurLine > 5)                     /* if not on 1st line,               */
    PageFeed();                         /* shift to next page                */
  }
else
  putlist("\n");
 
putlist("RELOCATION TABLE");
for (i = 0; i < relcounter; i++)
  {
  char name[10];
  sprintf(name, "%c%-.8s",
          (reltable[i].exprcat & EXPRCAT_NEGATIVE) ? '-' : ' ',
          reltable[i].sym->name);
  if (j % 4 == 0)
    putlist("\n");
  putlist( " %9s %02d %04X",
           name,
           reltable[i].sym->cat,
           reltable[i].addr);
  j++;
  }
putlist("\n%d RELOCATIONS\n", j);
}
 
/*****************************************************************************/
/* outtexttable : prints the text table                                      */
/*****************************************************************************/
 
void outtexttable()
{
int i,j = 0;
 
if (dwOptions & OPTION_PAG)             /* if pagination active,             */
  {
  if (nCurLine > 5)                     /* if not on 1st line,               */
    PageFeed();                         /* shift to next page                */
  }
else
  putlist("\n");
 
putlist("TEXT TABLE");
for (i = 0; i < symcounter; i++)
  if (symtable[i].cat == SYMCAT_TEXT)
    {
                                        /* suppress listing of predef texts  */
    if (symtable[i].value < nPredefinedTexts)
      continue;
    putlist("\n %9s %s", symtable[i].name, texts[symtable[i].value]);
    j++;
    }
putlist("\n%d TEXTS\n", j);
}
 
/*****************************************************************************/
/* findreg : finds a register per name                                       */
/*****************************************************************************/
 
struct regrecord * findreg(char *nm)
{
int i;
for (i = 0; regtable[i].name != NULL; i++)
  {
  if (strcmp(regtable[i].name,nm) == 0)
    return regtable + i;
  }
return 0;
}
 
/*****************************************************************************/
/* findreg63 : finds a register per name for HD63 operations                 */
/*****************************************************************************/
 
struct regrecord * findreg63(char *nm)
{
int i;
for (i = 0; i < (sizeof(regtable63) / sizeof(regtable63[0])); i++)
  {
  if (strcmp(regtable63[i].name,nm) == 0)
    return regtable63 + i;
  }
return 0;
}
 
/*****************************************************************************/
/* findbitreg : finds a bit transfer register per name (6309 only)           */
/*****************************************************************************/
 
struct regrecord * findbitreg(char *nm)
{
int i;
for (i = 0; i < (sizeof(bitregtable) / sizeof(bitregtable[0])); i++)
  {
  if (strcmp(bitregtable[i].name,nm) == 0)
    return bitregtable + i;
  }
return 0;
}
 
/*****************************************************************************/
/* strupr : converts a string to uppercase (crude)                           */
/*****************************************************************************/
 
char *strupr(char *name)
{
int i;
if (!name)
  return name;
for (i = 0; name[i]; i++)
  if ((name[i] >= 'a') && (name[i] <= 'z'))
    name[i] -= ('a' - 'A');
return name;
}
 
/*****************************************************************************/
/* addreloc : adds a relocation record to the list                           */
/*****************************************************************************/
 
void addreloc(struct relocrecord *p)
{
struct relocrecord rel = {0};           /* internal copy                     */
 
if (p)                                  /* if there's a record,              */
  rel = *p;                             /* copy to internal                  */
 
if ((!relocatable) ||                   /* if generating unrelocatable binary*/
    (!rel.sym) ||                       /* or no symbol                      */
    (pass == 1))                        /* or in pass 1                      */
  return;                               /* do nothing here                   */
 
switch (rel.sym->cat)                   /* check symbol category             */
  {
  case SYMCAT_PUBLIC :                  /* public label ?                    */
  case SYMCAT_LABEL :                   /* normal label ?                    */
  case SYMCAT_EXTERN :                  /* external symbol ?                 */
    break;                              /* these are allowed                 */
  case SYMCAT_COMMONDATA :              /* Common data ?                     */
    rel.sym = rel.sym->u.parent;        /* switch to COMMON block            */
    break;                              /* and allow it.                     */
  default :                             /* anything else                     */
    return;                             /* isn't                             */
  }
 
if (relcounter >= MAXRELOCS)            /* if no more space                  */
  {                                     /* should NEVER happen... but then...*/
  error |= ERR_MALLOC;                  /* set mem alloc err                 */
  return;                               /* and get out of here               */
  }
 
reltable[relcounter++] = rel;           /* add relocation record             */
 
switch (p->sym->cat)                    /* do specials...                    */
  {
  case SYMCAT_PUBLIC :                  /* public label ?                    */
  case SYMCAT_LABEL :                   /* normal label ?                    */
  case SYMCAT_COMMONDATA :              /* common data ?                     */
    curline->rel =                      /* remember there's a relocation     */
      (p->exprcat & EXPRCAT_NEGATIVE) ? '-' : '+';
    break;
  case SYMCAT_EXTERN :                  /* external symbol ?                 */
    curline->rel =
      (p->exprcat & EXPRCAT_NEGATIVE) ? 'x' : 'X';
    break;
  }
 
}
 
/*****************************************************************************/
/* scanname : scans a name from the input buffer                             */
/*****************************************************************************/
 
void scanname()
{
int i = 0;
char c;
char cValid;
 
while (1)
  {
  c = *srcptr++;
  if ((!(dwOptions & OPTION_TSC)) &&    /* TSC Assembler is case-sensitive   */
      (!(dwOptions & OPTION_GAS)) &&    /* GNU Assembler is case-sensitive   */
      (c >= 'a' && c <= 'z'))
    c -= 32;
  cValid = 0;                           /* check for validity                */
  if ((c >= '0' && c <= '9') ||         /* normally, labels may consist of   */
      (c >= 'A' && c <= 'Z') ||         /* the characters A..Z,a..z,_        */
      (c >= 'a' && c <= 'z') ||
      (c == '_'))
    cValid = 1;
  if (dwOptions & OPTION_GAS)           /* for GNU AS compatibility,         */
    {                                   /* the following rules apply:        */
    if ((c == '.') ||                   /* .$ are valid symbol characters    */
        (c == '$'))
     cValid = 1;
    }
  if (!cValid)                          /* if invalid character encountered  */
    break;                              /* stop here                         */
 
  if (i < maxidlen)
    {
    namebuf[i] = c;
    unamebuf[i] = toupper(c);
    i++;
    }
  }
namebuf[i] = '\0';
unamebuf[i] = '\0';
srcptr--;
}
 
/*****************************************************************************/
/* skipspace : skips whitespace characters                                   */
/*****************************************************************************/
 
void skipspace()
{
char c;
do
  {
  c = *srcptr++;
  } while (c == ' ' || c == '\t');
srcptr--;
}
 
long scanexpr(int, struct relocrecord *);
 
/*****************************************************************************/
/* scandecimal : scans a decimal number                                      */
/*****************************************************************************/
 
long scandecimal()
{
char c;
long t = 0;
c = *srcptr++;
while (isdigit(c))
  {
  t = t * 10 + c - '0';
  c = *srcptr++;
  }
srcptr--;
return t;
}
 
/*****************************************************************************/
/* scanhex : scans hex number                                                */
/*****************************************************************************/
 
long scanhex()
{
long t = 0, i = 0;
 
srcptr++;
scanname();
while (unamebuf[i] >= '0' && unamebuf[i] <= 'F')
  {
  t = t * 16 + unamebuf[i] - '0';
  if (unamebuf[i] > '9')
    t -= 7;
  i++;
  }
if (i==0)
  error |= ERR_EXPR;
return t;
}
 
/*****************************************************************************/
/* scanchar : scan a character                                               */
/*****************************************************************************/
 
long scanchar()
{
long  t;
 
srcptr++;
t = *srcptr;
if (t)
  srcptr++;
if (*srcptr == '\'')
  srcptr++;
return t;
}
 
/*****************************************************************************/
/* scanbin : scans a binary value                                            */
/*****************************************************************************/
 
long scanbin()
{
char c;
short t = 0;
 
srcptr++;
c = *srcptr++;
while (c == '0' || c == '1')
  {
  t = t * 2 + c - '0';
  c = *srcptr++;
  }
srcptr--;
return t;
}
 
/*****************************************************************************/
/* scanoct : scans an octal value                                            */
/*****************************************************************************/
 
long scanoct()
{
char c;
long t = 0;
 
srcptr++;
c = *srcptr++;
while (c >= '0' && c <= '7')
  {
  t = t * 8 + c - '0';
  c = *srcptr++;
  }
srcptr--;
return t;
}
 
/*****************************************************************************/
/* scanstring : scans a string into a buffer                                 */
/*****************************************************************************/
 
char * scanstring(char *dest, int nlen)
{
char *s = srcptr;
char *d = dest;
int nInString = 0;
char c;
 
if (*srcptr == '\'' || *srcptr == '\"')
  {
  nInString = 1;
  srcptr++;
  }
 
while (*srcptr)
  {
  if (!nInString &&
      (*srcptr == ' ' || *srcptr == ','))
    break;
  else if (nInString && *s == *srcptr)
    {
    srcptr++;
    break;
    }
  c = *srcptr++;
  if (!nInString && c >= 'a' && c <= 'z')
    c -= 32;
  *d++ = c;
  }
*d = '\0';
 
return dest;
}
 
 
/*****************************************************************************/
/* scanlabel : scans a label                                                 */
/*****************************************************************************/
 
unsigned scanlabel(struct relocrecord *pp)
{
struct symrecord * p;
 
scanname();
p = findsym(namebuf, 1);
if (p->cat == SYMCAT_EMPTY)
  {
  p->cat = SYMCAT_UNRESOLVED;
  p->value = 0;
  p->u.flags |= SYMFLAG_FORWARD;
  }
 
if (p->cat == SYMCAT_MACRO ||
    p->cat == SYMCAT_PARMNAME ||
    p->cat == SYMCAT_TEXT)
  error |= ERR_EXPR;
exprcat = p->cat & (EXPRCAT_PUBLIC | EXPRCAT_EXTADDR | EXPRCAT_INTADDR);
if (exprcat == (EXPRCAT_EXTADDR | EXPRCAT_INTADDR) ||
    exprcat == (EXPRCAT_PUBLIC | EXPRCAT_INTADDR))
  unknown = 1;
 
#if 1
/* anything that's not yet defined is uncertain in pass 2! */
if ((p->u.flags & (SYMFLAG_FORWARD | SYMFLAG_PASSED)) == SYMFLAG_FORWARD)
  certain = 0;
#else
if (((exprcat == EXPRCAT_INTADDR ||
      exprcat == EXPRCAT_PUBLIC) &&
//    (unsigned short)(p->value) > (unsigned short)loccounter) ||
//    (p->u.flags & SYMFLAG_FORWARD)) ||
    ((p->u.flags & (SYMFLAG_FORWARD | SYMFLAG_PASSED)) == SYMFLAG_FORWARD)) ||
    exprcat == EXPRCAT_EXTADDR)
  certain = 0;
#endif
if ((!absmode) &&                       /* if in relocating mode             */
    (exprcat))                          /* and this is not a constant        */
  certain = 0;                          /* this is NOT certain               */
if (exprcat == EXPRCAT_PUBLIC ||
    exprcat == (EXPRCAT_EXTADDR | EXPRCAT_INTADDR) ||
    exprcat == (EXPRCAT_PUBLIC | EXPRCAT_INTADDR))
  exprcat = EXPRCAT_INTADDR;
if (pp)
  {
  pp->exprcat = exprcat;
  pp->sym = p;
  }
  if (p->isFar)
          isFar = 1;
  if (p->isFarkw)
          isFarkw = 1;
return p->value;
}
 
/*****************************************************************************/
/* isfactorstart : returns whether passed character possibly starts a factor */
/*****************************************************************************/
 
int isfactorstart(char c)
{
if (isalpha(c))
  return 1;
else if (isdigit(c))
  return 1;
else switch (c)
  {
  case '*' :
  case '$' :
  case '%' :
  case '@' :
  case '\'' :
  case '(' :
  case '-' :
  case '+' :
  case '!' :
  case '~' :
    return 1;
  }
return 0;
}
 
/*****************************************************************************/
/* scanfactor : scans an expression factor                                   */
/*****************************************************************************/
 
long scanfactor(struct relocrecord *p)
{
char c;
long t;
 
if (!(dwOptions & OPTION_TSC))
  skipspace();
c = *srcptr;
if (isalpha(c))
  return (unsigned)scanlabel(p);
else if (isdigit(c))
  {
  char *locptr = srcptr;                /* watch out for local labels        */
  char caft;
  while ((*locptr >= '0') &&            /* advance to next nonnumeric        */
         (*locptr <= '9'))
    locptr++;
  caft = toupper(*locptr);              /* get next character in uppercase   */
  if ((caft == 'B') || (caft == 'F'))   /* if this might be a local reference*/
    return scanlabel(p);         /* look it up.                       */
  switch (c)
    {
    case '0' :                          /* GNU AS bin/oct/hex?               */
      if (dwOptions & OPTION_GAS)       /* if GNU AS extensions,             */
        {
        if (srcptr[1] == 'b')           /* if binary value,                  */
          {
          srcptr++;                     /* advance behind 0                  */
          return scanbin();             /* and treat rest as binary value    */
          }
        else if (srcptr[1] == 'x')      /* if hex value,                     */
          {
          srcptr++;                     /* advance behind 0                  */
          return scanhex();             /* and treat rest as hex value       */
          }
        return scanoct();               /* otherwise treat as octal          */
        }
      /* else fall thru on purpose */
    default :                           /* decimal in any case ?             */
      return scandecimal();
    }
  }
else switch (c)
  {
  case '*' :
    srcptr++;
    exprcat |= EXPRCAT_INTADDR;
    return loccounter;
  case '$' :
    return scanhex();
  case '%' :
    return scanbin();
  case '@' :
    return scanoct();
  case '\'' :
    return scanchar();
  case '(' :
    srcptr++;
    t = scanexpr(0, p);
    if (!(dwOptions & OPTION_TSC))
      skipspace();
    if (*srcptr == ')')
      srcptr++;
    else
      error |= ERR_EXPR;
    return t;
  case '-' :
    srcptr++;
    t = scanfactor(p);
    exprcat ^= EXPRCAT_NEGATIVE;
    if (p)
      p->exprcat ^= EXPRCAT_NEGATIVE;
    return -t;
  case '+' :
    srcptr++;
    return scanfactor(p);
  case '!' :
    srcptr++;
    exprcat |= EXPRCAT_FIXED;
    return !scanfactor(p);
  case '~' :
    srcptr++;
    exprcat |= EXPRCAT_FIXED;
    return ~scanfactor(p);
  }
error |= ERR_EXPR;
return 0;
}
 
/*****************************************************************************/
/* some nice macros                                                          */
/*****************************************************************************/
 
/*define EXITEVAL { srcptr--; return t; } */
#define EXITEVAL { srcptr--; parsing = 0; break; }
 
#define RESOLVECAT if((oldcat & 15) == 0) oldcat = 0;               \
           if ((exprcat & 15) == 0)exprcat = 0;                     \
           if ((exprcat == EXPRCAT_INTADDR &&                       \
                oldcat == (EXPRCAT_INTADDR | EXPRCAT_NEGATIVE)) ||  \
               (exprcat == (EXPRCAT_INTADDR | EXPRCAT_NEGATIVE)&&   \
               oldcat == EXPRCAT_INTADDR))                          \
             {                                                      \
             exprcat = 0;                                           \
             oldcat = 0;                                            \
             }                                                      \
           exprcat |= oldcat;
/* resolve such cases as constant added to address or difference between
   two addresses in same module */
 
/*****************************************************************************/
/* scanexpr : scan expression                                                */
/*****************************************************************************/
 
long scanexpr(int level, struct relocrecord *pp) /* This is what you call _recursive_ descent!!!*/
{
long t, u;
char oldcat,c,parsing=1;
struct relocrecord ip = {0}, p = {0};
 
exprcat = 0;
if (level == 10)
  return scanfactor(pp);
t = scanexpr(level + 1, &ip);
/* ip.exprcat = exprcat; */
while (parsing)
  {
  p.sym = NULL;
  if (!(dwOptions & OPTION_TSC))
    skipspace();
  c = *srcptr++;
  switch(c)
    {
    case '*':
      oldcat = exprcat;
      t *= scanexpr(10, &p);
      exprcat |= oldcat | EXPRCAT_FIXED;
      break;
    case '/':
      oldcat = exprcat;
      u = scanexpr(10, &p);
      if (u)
        t /= u;
      else
        error |= ERR_EXPR;
      exprcat |= oldcat | EXPRCAT_FIXED;
      break;
    case '%':
      oldcat = exprcat;
      u = scanexpr(10, &p);
      if (u)
        t %= u;
      else
        error |= ERR_EXPR;
      exprcat |= oldcat | EXPRCAT_FIXED;
      break;
    case '+':
      if (level == 9)
        EXITEVAL
      oldcat = exprcat;
      t += scanexpr(9, &p);
      RESOLVECAT
      break;
    case '-':
      if (level == 9)
        EXITEVAL
      oldcat = exprcat;
      t -= scanexpr(9, &p);
      exprcat ^= EXPRCAT_NEGATIVE;
      RESOLVECAT
      break;
    case '<':
      if (*(srcptr) == '<')
        {
        if (level >= 8)
          EXITEVAL
        srcptr++;
        oldcat = exprcat;
        t <<= scanexpr(8, &p);
        exprcat |= oldcat | EXPRCAT_FIXED;
        }
      else if (*(srcptr) == '=')
        {
        if (level >= 7)
          EXITEVAL
        srcptr++;
        oldcat = exprcat;
        t = t <= scanexpr(7, &p);
        exprcat |= oldcat | EXPRCAT_FIXED;
        }
      else
        {
        if (level >= 7)
          EXITEVAL
        oldcat = exprcat;
        t = t < scanexpr(7, &p);
        exprcat |= oldcat | EXPRCAT_FIXED;
        }
      break;
    case '>':
      if (*(srcptr) == '>')
        {
        if (level >= 8)
          EXITEVAL
        srcptr++;
        oldcat = exprcat;
        t >>= scanexpr(8, &p);
        exprcat |= oldcat | EXPRCAT_FIXED;
        }
      else if (*(srcptr) == '=')
        {
        if (level>=7)
          EXITEVAL
        srcptr++;
        oldcat = exprcat;
        t = t >= scanexpr(7, &p);
        exprcat |= oldcat | EXPRCAT_FIXED;
        }
      else
        {
        if (level >= 7)
          EXITEVAL
        oldcat = exprcat;
        t = t > scanexpr(7, &p);
        exprcat |= oldcat | EXPRCAT_FIXED;
        }
      break;
    case '!':
      if (level >= 6 || *srcptr != '=')
        EXITEVAL
      srcptr++;
      oldcat = exprcat;
      t = t != scanexpr(6, &p);
      exprcat |= oldcat | EXPRCAT_FIXED;
      break;
    case '=':
      if (level >= 6)
        EXITEVAL
      if (*srcptr == '=')
        srcptr++;
      oldcat = exprcat;
      t = (t == scanexpr(6, &p));
      exprcat |= oldcat | EXPRCAT_FIXED;
      break;
    case '&':
      if (level >= 5)
        EXITEVAL
      oldcat = exprcat;
      t &= scanexpr(5, &p);
      exprcat |= oldcat | EXPRCAT_FIXED;
      break;
    case '^':
      if (level >= 4)
        EXITEVAL
      oldcat = exprcat;
      t ^= scanexpr(4, &p);
      exprcat |= oldcat | EXPRCAT_FIXED;
      break;
    case '|':
      if (level >= 3)
        EXITEVAL
      oldcat = exprcat;
      t |= scanexpr(3, &p);
      exprcat |= oldcat | EXPRCAT_FIXED;
      break;
    default:
      EXITEVAL
    }
  p.exprcat = exprcat;
  if (p.sym)
    {
    if (ip.sym)                         /* if 2 symbols, cancel 'em          */
      {
      /* a simple safeguard against cancelling local vs. external symbols
         or operations between 2 external symbols.
         This means that an external symbol has to be the last one in an
         expression, or the others have to be paired so that they cancel
         each other's effect AND their subexpression has to be parenthesized.*/
      if ((ip.sym->cat == SYMCAT_EXTERN) || (p.sym->cat == SYMCAT_EXTERN))
        error |= ERR_EXPR;
      else
        ip.sym = NULL;                  /* this might be TOO crude...        */
      }
    else                                /* if new symbol                     */
      ip = p;                           /* use this one                      */
    }
  }
 
*pp = ip;
return t;
}
 
/*****************************************************************************/
/* scanindexreg : scans an index register                                    */
/*****************************************************************************/
 
int scanindexreg()
{
switch (toupper(*srcptr))
  {
  case 'X':
    return 1;
  case 'Y':
    postbyte |= 0x200;
    return 1;
  case 'U':
    postbyte |= 0x400;
    return 1;
  case 'S':
    postbyte |= 0x600;
    return 1;
  }
return 0;
}
 
/*****************************************************************************/
/* set3 : sets mode to at least ADRMODE_POST                                 */
/*****************************************************************************/
 
void set3()
{
if (mode < ADRMODE_POST)
  mode = ADRMODE_POST;
}
 
/*****************************************************************************/
/* scanspecial : scans for increments                                        */
/*****************************************************************************/
 
void scanspecial()
{
set3();
if (!(dwOptions & OPTION_TSC))
  skipspace();
if (*srcptr == '-')
  {
  srcptr++;
  if (*srcptr == '-')
    {
    srcptr++;
    postbyte = 0x803;
    }
  else
    postbyte = 0x802;
 
  if ((dwOptions & OPTION_H63) &&       /* special for ,--W and [,--W]       */
      (postbyte == 0x803) &&
      (toupper(*srcptr) == 'W'))
    {
    postbyte = (mode == ADRMODE_IND) ? 0x900 : 0x80f;
    srcptr++;
    }
  else if (!scanindexreg())
    error |= ERR_ILLEGAL_ADDR;
  else
    srcptr++;
  }
else
  {
  postbyte = 0x800;
  if ((dwOptions & OPTION_H63) &&       /* special for ,W, [,W], ,W++, [,W++]*/
      (toupper(*srcptr) == 'W'))
    {
    srcptr++;                           /* advance behind W                  */
    if (*srcptr == '+')
      {
      srcptr++;
      if (*srcptr == '+')               /* ,W++ and [,W++]                   */
        {
        postbyte = (mode == ADRMODE_IND) ? 0xB00 : 0xA0F;
        srcptr++;
        
Browse

Tools

Subversion Repositories rf6809

[/] [rf6809/] [trunk/] [software/] [a09/] [a09.c] - Blame information for rev 16

Line No.	Rev	Author	Line
1	4	robfinch	`/* A09, 6809 Assembler.`
2
3			`(C) Copyright 1993,1994 L.C. Benschop.`
4			`Parts (C) Copyright 2001-2010 H. Seib.`
5			`Mods for 12-bit FPGA core 6809 by R. Finch`
6
7			`This version of the program is distributed under the terms and conditions`
8			`of the GNU General Public License version 2. See file the COPYING for details.`
9			`THERE IS NO WARRANTY ON THIS PROGRAM.`
10
11			`Generates binary image file from the lowest to`
12			`the highest address with actually assembled data.`
13
14			`Machine dependencies:`
15			`char is 8 bits.`
16			`short is 16 bits.`
17			`integer arithmetic is twos complement.`
18
19			`syntax:`
20			`a09 [-{b\|r\|s\|x\|f}filename]\|[-c] [-lfilename] [-ooption] [-dsym=value]* sourcefile.`
21
22			`Options`
23			`-Vfilename Verilog rommem declaration output`
24			`-c suppresses code output`
25			`-bfilename binary output file name (default name minus a09 suffix plus .bin)`
26			`-rfilename Flex9 RELASMB-compatible output file name (relocatable)`
27			`-sfilename s-record output file name (default its a binary file)`
28			`-xfilename intel hex output file name (-"-)`
29			`-ffilename Flex9 output file name (-"-)`
30			`-lfilename list file name (default no listing)`
31			`-dsym[=value] define a symbol`
32			`-oopt defines an option`
33
34			`recognized pseudoops:`
35			`ext defines an external symbol (relocating mode only)`
36			`extern -"-`
37			`public defines a public symbol (effective in relocating mode only)`
38			`macro defines a macro`
39			`exitm terminates a macro expansion`
40			`endm ends a macro definition`