[simh.git] / AltairZ80 / nasm.h

/* nasm.h   main header file for the Netwide Assembler: inter-module interface\r
 *\r
 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and\r
 * Julian Hall. All rights reserved. The software is\r
 * redistributable under the licence given in the file "Licence"\r
 * distributed in the NASM archive.\r
 *\r
 * initial version: 27/iii/95 by Simon Tatham\r
 */\r
\r
#ifndef NASM_NASM_H\r
#define NASM_NASM_H\r
\r
#include <stdio.h>\r
#define NASM_VERSION_H\r
#define NASM_MAJOR_VER      0\r
#define NASM_MINOR_VER      98\r
#define NASM_SUBMINOR_VER   38\r
#define NASM_PATCHLEVEL_VER 0\r
#define NASM_VERSION_ID     0x00622600\r
#define NASM_VER            "0.98.38"\r
\r
#ifndef NULL\r
#define NULL 0\r
#endif\r
\r
#ifndef FALSE\r
#define FALSE 0                /* comes in handy */\r
#endif\r
#ifndef TRUE\r
#define TRUE 1\r
#endif\r
\r
#define NO_SEG -1L             /* null segment value */\r
#define SEG_ABS 0x40000000L        /* mask for far-absolute segments */\r
\r
#ifndef FILENAME_MAX\r
#define FILENAME_MAX 256\r
#endif\r
\r
#ifndef PREFIX_MAX\r
#define PREFIX_MAX 10\r
#endif\r
\r
#ifndef POSTFIX_MAX\r
#define POSTFIX_MAX 10\r
#endif\r
\r
#define IDLEN_MAX 4096\r
\r
/*\r
 * Name pollution problems: <time.h> on Digital UNIX pulls in some\r
 * strange hardware header file which sees fit to define R_SP. We\r
 * undefine it here so as not to break the enum below.\r
 */\r
#ifdef R_SP\r
#undef R_SP\r
#endif\r
\r
/*\r
 * We must declare the existence of this structure type up here,\r
 * since we have to reference it before we define it...\r
 */\r
struct ofmt;\r
\r
/*\r
 * -------------------------\r
 * Error reporting functions\r
 * -------------------------\r
 */\r
\r
/*\r
 * An error reporting function should look like this.\r
 */\r
typedef void (*efunc) (int severity, const char *fmt, ...);\r
\r
/*\r
 * These are the error severity codes which get passed as the first\r
 * argument to an efunc.\r
 */\r
\r
#define ERR_DEBUG   0x00000008  /* put out debugging message */\r
#define ERR_WARNING 0x00000000  /* warn only: no further action */\r
#define ERR_NONFATAL    0x00000001  /* terminate assembly after phase */\r
#define ERR_FATAL   0x00000002  /* instantly fatal: exit with error */\r
#define ERR_PANIC   0x00000003  /* internal error: panic instantly\r
                    * and dump core for reference */\r
#define ERR_MASK    0x0000000F  /* mask off the above codes */\r
#define ERR_NOFILE  0x00000010  /* don't give source file name/line */\r
#define ERR_USAGE   0x00000020  /* print a usage message */\r
#define ERR_PASS1   0x00000040  /* only print this error on pass one */\r
\r
/*\r
 * These codes define specific types of suppressible warning.\r
 */\r
\r
#define ERR_WARN_MASK   0x0000FF00  /* the mask for this feature */\r
#define ERR_WARN_SHR  8            /* how far to shift right */\r
\r
#define ERR_WARN_MNP    0x00000100  /* macro-num-parameters warning */\r
#define ERR_WARN_MSR    0x00000200  /* macro self-reference */\r
#define ERR_WARN_OL 0x00000300  /* orphan label (no colon, and\r
                    * alone on line) */\r
#define ERR_WARN_NOV    0x00000400  /* numeric overflow */\r
#define ERR_WARN_GNUELF 0x00000500      /* using GNU ELF extensions */\r
#define ERR_WARN_MAX    5       /* the highest numbered one */\r
\r
/*\r
 * -----------------------\r
 * Other function typedefs\r
 * -----------------------\r
 */\r
\r
/*\r
 * A label-lookup function should look like this.\r
 */\r
typedef int (*lfunc) (char *label, long *segment, long *offset);\r
\r
/*\r
 * And a label-definition function like this. The boolean parameter\r
 * `is_norm' states whether the label is a `normal' label (which\r
 * should affect the local-label system), or something odder like\r
 * an EQU or a segment-base symbol, which shouldn't.\r
 */\r
typedef void (*ldfunc) (char *label, long segment, long offset, char *special,\r
            int is_norm, int isextrn, struct ofmt *ofmt,\r
            efunc error);\r
\r
/*\r
 * List-file generators should look like this:\r
 */\r
typedef struct {\r
    /*\r
     * Called to initialise the listing file generator. Before this\r
     * is called, the other routines will silently do nothing when\r
     * called. The `char *' parameter is the file name to write the\r
     * listing to.\r
     */\r
    void (*init) (char *, efunc);\r
\r
    /*\r
     * Called to clear stuff up and close the listing file.\r
     */\r
    void (*cleanup) (void);\r
\r
    /*\r
     * Called to output binary data. Parameters are: the offset;\r
     * the data; the data type. Data types are similar to the\r
     * output-format interface, only OUT_ADDRESS will _always_ be\r
     * displayed as if it's relocatable, so ensure that any non-\r
     * relocatable address has been converted to OUT_RAWDATA by\r
     * then. Note that OUT_RAWDATA+0 is a valid data type, and is a\r
     * dummy call used to give the listing generator an offset to\r
     * work with when doing things like uplevel(LIST_TIMES) or\r
     * uplevel(LIST_INCBIN).\r
     */\r
    void (*output) (long, const void *, unsigned long);\r
\r
    /*\r
     * Called to send a text line to the listing generator. The\r
     * `int' parameter is LIST_READ or LIST_MACRO depending on\r
     * whether the line came directly from an input file or is the\r
     * result of a multi-line macro expansion.\r
     */\r
    void (*line) (int, char *);\r
\r
    /*\r
     * Called to change one of the various levelled mechanisms in\r
     * the listing generator. LIST_INCLUDE and LIST_MACRO can be\r
     * used to increase the nesting level of include files and\r
     * macro expansions; LIST_TIMES and LIST_INCBIN switch on the\r
     * two binary-output-suppression mechanisms for large-scale\r
     * pseudo-instructions.\r
     *\r
     * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that\r
     * it indicates the beginning of the expansion of a `nolist'\r
     * macro, so anything under that level won't be expanded unless\r
     * it includes another file.\r
     */\r
    void (*uplevel) (int);\r
\r
    /*\r
     * Reverse the effects of uplevel.\r
     */\r
    void (*downlevel) (int);\r
} ListGen;\r
\r
/*\r
 * The expression evaluator must be passed a scanner function; a\r
 * standard scanner is provided as part of nasmlib.c. The\r
 * preprocessor will use a different one. Scanners, and the\r
 * token-value structures they return, look like this.\r
 *\r
 * The return value from the scanner is always a copy of the\r
 * `t_type' field in the structure.\r
 */\r
struct tokenval {\r
    int t_type;\r
    long t_integer, t_inttwo;\r
    char *t_charptr;\r
};\r
typedef int (*scanner) (void *private_data, struct tokenval *tv);\r
\r
/*\r
 * Token types returned by the scanner, in addition to ordinary\r
 * ASCII character values, and zero for end-of-string.\r
 */\r
enum {                     /* token types, other than chars */\r
    TOKEN_INVALID = -1,            /* a placeholder value */\r
    TOKEN_EOS = 0,             /* end of string */\r
    TOKEN_EQ = '=', TOKEN_GT = '>', TOKEN_LT = '<',   /* aliases */\r
    TOKEN_ID = 256, TOKEN_NUM, TOKEN_REG, TOKEN_INSN,  /* major token types */\r
    TOKEN_ERRNUM,              /* numeric constant with error in */\r
    TOKEN_HERE, TOKEN_BASE,        /* $ and $$ */\r
    TOKEN_SPECIAL,             /* BYTE, WORD, DWORD, FAR, NEAR, etc */\r
    TOKEN_PREFIX,              /* A32, O16, LOCK, REPNZ, TIMES, etc */\r
    TOKEN_SHL, TOKEN_SHR,          /* << and >> */\r
    TOKEN_SDIV, TOKEN_SMOD,        /* // and %% */\r
    TOKEN_GE, TOKEN_LE, TOKEN_NE,      /* >=, <= and <> (!= is same as <>) */\r
    TOKEN_DBL_AND, TOKEN_DBL_OR, TOKEN_DBL_XOR,   /* &&, || and ^^ */\r
    TOKEN_SEG, TOKEN_WRT,          /* SEG and WRT */\r
    TOKEN_FLOAT                /* floating-point constant */\r
};\r
\r
typedef struct {\r
    long segment;\r
    long offset;\r
    int  known;\r
} loc_t;\r
\r
/*\r
 * Expression-evaluator datatype. Expressions, within the\r
 * evaluator, are stored as an array of these beasts, terminated by\r
 * a record with type==0. Mostly, it's a vector type: each type\r
 * denotes some kind of a component, and the value denotes the\r
 * multiple of that component present in the expression. The\r
 * exception is the WRT type, whose `value' field denotes the\r
 * segment to which the expression is relative. These segments will\r
 * be segment-base types, i.e. either odd segment values or SEG_ABS\r
 * types. So it is still valid to assume that anything with a\r
 * `value' field of zero is insignificant.\r
 */\r
typedef struct {\r
    long type;                 /* a register, or EXPR_xxx */\r
    long value;                /* must be >= 32 bits */\r
} expr;\r
\r
/*\r
 * The evaluator can also return hints about which of two registers\r
 * used in an expression should be the base register. See also the\r
 * `operand' structure.\r
 */\r
struct eval_hints {\r
    int base;\r
    int type;\r
};\r
\r
/*\r
 * The actual expression evaluator function looks like this. When\r
 * called, it expects the first token of its expression to already\r
 * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and\r
 * it will start by calling the scanner.\r
 *\r
 * If a forward reference happens during evaluation, the evaluator\r
 * must set `*fwref' to TRUE if `fwref' is non-NULL.\r
 *\r
 * `critical' is non-zero if the expression may not contain forward\r
 * references. The evaluator will report its own error if this\r
 * occurs; if `critical' is 1, the error will be "symbol not\r
 * defined before use", whereas if `critical' is 2, the error will\r
 * be "symbol undefined".\r
 *\r
 * If `critical' has bit 8 set (in addition to its main value: 0x101\r
 * and 0x102 correspond to 1 and 2) then an extended expression\r
 * syntax is recognised, in which relational operators such as =, <\r
 * and >= are accepted, as well as low-precedence logical operators\r
 * &&, ^^ and ||.\r
 *\r
 * If `hints' is non-NULL, it gets filled in with some hints as to\r
 * the base register in complex effective addresses.\r
 */\r
#define CRITICAL 0x100\r
typedef expr *(*evalfunc) (scanner sc, void *scprivate, struct tokenval *tv,\r
               int *fwref, int critical, efunc error,\r
               struct eval_hints *hints);\r
\r
/*\r
 * Special values for expr->type. ASSUMPTION MADE HERE: the number\r
 * of distinct register names (i.e. possible "type" fields for an\r
 * expr structure) does not exceed 124 (EXPR_REG_START through\r
 * EXPR_REG_END).\r
 */\r
#define EXPR_REG_START 1\r
#define EXPR_REG_END 124\r
#define EXPR_UNKNOWN 125L          /* for forward references */\r
#define EXPR_SIMPLE 126L\r
#define EXPR_WRT 127L\r
#define EXPR_SEGBASE 128L\r
\r
/*\r
 * Preprocessors ought to look like this:\r
 */\r
typedef struct {\r
    /*\r
     * Called at the start of a pass; given a file name, the number\r
     * of the pass, an error reporting function, an evaluator\r
     * function, and a listing generator to talk to.\r
     */\r
    void (*reset) (char *, int, efunc, evalfunc, ListGen *);\r
\r
    /*\r
     * Called to fetch a line of preprocessed source. The line\r
     * returned has been malloc'ed, and so should be freed after\r
     * use.\r
     */\r
    char *(*getline) (void);\r
\r
    /*\r
     * Called at the end of a pass.\r
     */\r
    void (*cleanup) (int);\r
} Preproc;\r
\r
/*\r
 * ----------------------------------------------------------------\r
 * Some lexical properties of the NASM source language, included\r
 * here because they are shared between the parser and preprocessor\r
 * ----------------------------------------------------------------\r
 */\r
\r
/*\r
 * isidstart matches any character that may start an identifier, and isidchar\r
 * matches any character that may appear at places other than the start of an\r
 * identifier. E.g. a period may only appear at the start of an identifier\r
 * (for local labels), whereas a number may appear anywhere *but* at the\r
 * start.\r
 */\r
\r
#define isidstart(c) ( isalpha(c) || (c)=='_' || (c)=='.' || (c)=='?' \\r
                                  || (c)=='@' )\r
#define isidchar(c)  ( isidstart(c) || isdigit(c) || (c)=='$' || (c)=='#' \\r
                                                  || (c)=='~' )\r
\r
/* Ditto for numeric constants. */\r
\r
#define isnumstart(c)  ( isdigit(c) || (c)=='$' )\r
#define isnumchar(c)   ( isalnum(c) )\r
\r
/* This returns the numeric value of a given 'digit'. */\r
\r
#define numvalue(c)  ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')\r
\r
/*\r
 * Data-type flags that get passed to listing-file routines.\r
 */\r
enum {\r
    LIST_READ, LIST_MACRO, LIST_MACRO_NOLIST, LIST_INCLUDE,\r
    LIST_INCBIN, LIST_TIMES\r
};\r
\r
/*\r
 * -----------------------------------------------------------\r
 * Format of the `insn' structure returned from `parser.c' and\r
 * passed into `assemble.c'\r
 * -----------------------------------------------------------\r
 */\r
\r
/*\r
 * Here we define the operand types. These are implemented as bit\r
 * masks, since some are subsets of others; e.g. AX in a MOV\r
 * instruction is a special operand type, whereas AX in other\r
 * contexts is just another 16-bit register. (Also, consider CL in\r
 * shift instructions, DX in OUT, etc.)\r
 */\r
\r
/* size, and other attributes, of the operand */\r
#define BITS8     0x00000001L\r
#define BITS16    0x00000002L\r
#define BITS32    0x00000004L\r
#define BITS64    0x00000008L          /* FPU only */\r
#define BITS80    0x00000010L          /* FPU only */\r
#define FAR       0x00000020L          /* grotty: this means 16:16 or */\r
                       /* 16:32, like in CALL/JMP */\r
#define NEAR      0x00000040L\r
#define SHORT     0x00000080L          /* and this means what it says :) */\r
\r
#define SIZE_MASK 0x000000FFL          /* all the size attributes */\r
#define NON_SIZE  (~SIZE_MASK)\r
\r
#define TO        0x00000100L          /* reverse effect in FADD, FSUB &c */\r
#define COLON     0x00000200L          /* operand is followed by a colon */\r
#define STRICT    0x00000400L          /* do not optimize this operand */\r
\r
/* type of operand: memory reference, register, etc. */\r
#define MEMORY    0x00204000L\r
#define REGISTER  0x00001000L          /* register number in 'basereg' */\r
#define IMMEDIATE 0x00002000L\r
\r
#define REGMEM    0x00200000L          /* for r/m, ie EA, operands */\r
#define REGNORM   0x00201000L          /* 'normal' reg, qualifies as EA */\r
#define REG8      0x00201001L\r
#define REG16     0x00201002L\r
#define REG32     0x00201004L\r
#define MMXREG    0x00201008L          /* MMX registers */\r
#define XMMREG    0x00201010L          /* XMM Katmai reg */\r
#define FPUREG    0x01000000L          /* floating point stack registers */\r
#define FPU0      0x01000800L          /* FPU stack register zero */\r
\r
/* special register operands: these may be treated differently */\r
#define REG_SMASK 0x00070000L          /* a mask for the following */\r
#define REG_ACCUM 0x00211000L          /* accumulator: AL, AX or EAX */\r
#define REG_AL    0x00211001L          /* REG_ACCUM | BITSxx */\r
#define REG_AX    0x00211002L          /* ditto */\r
#define REG_EAX   0x00211004L          /* and again */\r
#define REG_COUNT 0x00221000L          /* counter: CL, CX or ECX */\r
#define REG_CL    0x00221001L          /* REG_COUNT | BITSxx */\r
#define REG_CX    0x00221002L          /* ditto */\r
#define REG_ECX   0x00221004L          /* another one */\r
#define REG_DL    0x00241001L\r
#define REG_DX    0x00241002L\r
#define REG_EDX   0x00241004L\r
#define REG_SREG  0x00081002L          /* any segment register */\r
#define REG_CS    0x01081002L          /* CS */\r
#define REG_DESS  0x02081002L          /* DS, ES, SS (non-CS 86 registers) */\r
#define REG_FSGS  0x04081002L          /* FS, GS (386 extended registers) */\r
#define REG_SEG67 0x08081002L          /* Non-implemented segment registers */\r
#define REG_CDT   0x00101004L          /* CRn, DRn and TRn */\r
#define REG_CREG  0x08101004L          /* CRn */\r
#define REG_DREG  0x10101004L          /* DRn */\r
#define REG_TREG  0x20101004L          /* TRn */\r
\r
/* special type of EA */\r
#define MEM_OFFS  0x00604000L          /* simple [address] offset */\r
\r
/* special type of immediate operand */\r
#define ONENESS   0x00800000L          /* so UNITY == IMMEDIATE | ONENESS */\r
#define UNITY     0x00802000L          /* for shift/rotate instructions */\r
#define BYTENESS  0x40000000L          /* so SBYTE == IMMEDIATE | BYTENESS */\r
#define SBYTE     0x40002000L          /* for op r16/32,immediate instrs. */\r
\r
/* Register names automatically generated from regs.dat */\r
/* automatically generated from ./regs.dat - do not edit */\r
enum reg_enum {\r
    R_AH = EXPR_REG_START,\r
    R_AL,\r
    R_AX,\r
    R_BH,\r
    R_BL,\r
    R_BP,\r
    R_BX,\r
    R_CH,\r
    R_CL,\r
    R_CR0,\r
    R_CR1,\r
    R_CR2,\r
    R_CR3,\r
    R_CR4,\r
    R_CR5,\r
    R_CR6,\r
    R_CR7,\r
    R_CS,\r
    R_CX,\r
    R_DH,\r
    R_DI,\r
    R_DL,\r
    R_DR0,\r
    R_DR1,\r
    R_DR2,\r
    R_DR3,\r
    R_DR4,\r
    R_DR5,\r
    R_DR6,\r
    R_DR7,\r
    R_DS,\r
    R_DX,\r
    R_EAX,\r
    R_EBP,\r
    R_EBX,\r
    R_ECX,\r
    R_EDI,\r
    R_EDX,\r
    R_ES,\r
    R_ESI,\r
    R_ESP,\r
    R_FS,\r
    R_GS,\r
    R_MM0,\r
    R_MM1,\r
    R_MM2,\r
    R_MM3,\r
    R_MM4,\r
    R_MM5,\r
    R_MM6,\r
    R_MM7,\r
    R_SEGR6,\r
    R_SEGR7,\r
    R_SI,\r
    R_SP,\r
    R_SS,\r
    R_ST0,\r
    R_ST1,\r
    R_ST2,\r
    R_ST3,\r
    R_ST4,\r
    R_ST5,\r
    R_ST6,\r
    R_ST7,\r
    R_TR0,\r
    R_TR1,\r
    R_TR2,\r
    R_TR3,\r
    R_TR4,\r
    R_TR5,\r
    R_TR6,\r
    R_TR7,\r
    R_XMM0,\r
    R_XMM1,\r
    R_XMM2,\r
    R_XMM3,\r
    R_XMM4,\r
    R_XMM5,\r
    R_XMM6,\r
    R_XMM7,\r
    REG_ENUM_LIMIT\r
};\r
\r
enum {                     /* condition code names */\r
    C_A, C_AE, C_B, C_BE, C_C, C_E, C_G, C_GE, C_L, C_LE, C_NA, C_NAE,\r
    C_NB, C_NBE, C_NC, C_NE, C_NG, C_NGE, C_NL, C_NLE, C_NO, C_NP,\r
    C_NS, C_NZ, C_O, C_P, C_PE, C_PO, C_S, C_Z\r
};\r
\r
/*\r
 * Note that because segment registers may be used as instruction\r
 * prefixes, we must ensure the enumerations for prefixes and\r
 * register names do not overlap.\r
 */\r
enum {                     /* instruction prefixes */\r
    PREFIX_ENUM_START = REG_ENUM_LIMIT,\r
    P_A16 = PREFIX_ENUM_START, P_A32, P_LOCK, P_O16, P_O32, P_REP, P_REPE,\r
    P_REPNE, P_REPNZ, P_REPZ, P_TIMES\r
};\r
\r
enum {                     /* extended operand types */\r
    EOT_NOTHING, EOT_DB_STRING, EOT_DB_NUMBER\r
};\r
\r
enum {                     /* special EA flags */\r
    EAF_BYTEOFFS = 1,              /* force offset part to byte size */\r
    EAF_WORDOFFS = 2,              /* force offset part to [d]word size */\r
    EAF_TIMESTWO = 4               /* really do EAX*2 not EAX+EAX */\r
};\r
\r
enum {                     /* values for `hinttype' */\r
    EAH_NOHINT = 0,            /* no hint at all - our discretion */\r
    EAH_MAKEBASE = 1,              /* try to make given reg the base */\r
    EAH_NOTBASE = 2            /* try _not_ to make reg the base */\r
};\r
\r
typedef struct {               /* operand to an instruction */\r
    long type;                 /* type of operand */\r
    int addr_size;             /* 0 means default; 16; 32 */\r
    int basereg, indexreg, scale;      /* registers and scale involved */\r
    int hintbase, hinttype;        /* hint as to real base register */\r
    long segment;              /* immediate segment, if needed */\r
    long offset;               /* any immediate number */\r
    long wrt;                  /* segment base it's relative to */\r
    int eaflags;               /* special EA flags */\r
    int opflags;               /* see OPFLAG_* defines below */\r
} operand;\r
\r
#define OPFLAG_FORWARD      1      /* operand is a forward reference */\r
#define OPFLAG_EXTERN       2      /* operand is an external reference */\r
\r
typedef struct extop {             /* extended operand */\r
    struct extop *next;            /* linked list */\r
    long type;                 /* defined above */\r
    char *stringval;               /* if it's a string, then here it is */\r
    int stringlen;             /* ... and here's how long it is */\r
    long segment;              /* if it's a number/address, then... */\r
    long offset;               /* ... it's given here ... */\r
    long wrt;                  /* ... and here */\r
} extop;\r
\r
#define MAXPREFIX 4\r
\r
typedef struct {               /* an instruction itself */\r
    char *label;               /* the label defined, or NULL */\r
    int prefixes[MAXPREFIX];           /* instruction prefixes, if any */\r
    int nprefix;               /* number of entries in above */\r
    int opcode;                /* the opcode - not just the string */\r
    int condition;             /* the condition code, if Jcc/SETcc */\r
    int operands;              /* how many operands? 0-3\r
                                        * (more if db et al) */\r
    operand oprs[3];               /* the operands, defined as above */\r
    extop *eops;               /* extended operands */\r
    int eops_float;                    /* true if DD and floating */\r
    long times;                /* repeat count (TIMES prefix) */\r
    int forw_ref;              /* is there a forward reference? */\r
} insn;\r
\r
enum geninfo { GI_SWITCH };\r
/*\r
 * ------------------------------------------------------------\r
 * The data structure defining an output format driver, and the\r
 * interfaces to the functions therein.\r
 * ------------------------------------------------------------\r
 */\r
\r
struct ofmt {\r
    /*\r
     * This is a short (one-liner) description of the type of\r
     * output generated by the driver.\r
     */\r
    const char *fullname;\r
\r
    /*\r
     * This is a single keyword used to select the driver.\r
     */\r
    const char *shortname;\r
\r
    /*\r
     * this is reserved for out module specific help.\r
     * It is set to NULL in all the out modules but is not implemented\r
     * in the main program\r
     */\r
    const char *helpstring;\r
\r
    /*\r
     * this is a pointer to the first element of the debug information\r
     */\r
    struct dfmt **debug_formats;\r
\r
    /*\r
     * and a pointer to the element that is being used\r
     * note: this is set to the default at compile time and changed if the\r
     * -F option is selected.  If developing a set of new debug formats for\r
     * an output format, be sure to set this to whatever default you want\r
     *\r
     */\r
    struct dfmt *current_dfmt;\r
\r
    /*\r
     * This, if non-NULL, is a NULL-terminated list of `char *'s\r
     * pointing to extra standard macros supplied by the object\r
     * format (e.g. a sensible initial default value of __SECT__,\r
     * and user-level equivalents for any format-specific\r
     * directives).\r
     */\r
    const char **stdmac;\r
\r
    /*\r
     * This procedure is called at the start of an output session.\r
     * It tells the output format what file it will be writing to,\r
     * what routine to report errors through, and how to interface\r
     * to the label manager and expression evaluator if necessary.\r
     * It also gives it a chance to do other initialisation.\r
     */\r
    void (*init) (FILE *fp, efunc error, ldfunc ldef, evalfunc eval);\r
\r
    /*\r
     * This procedure is called to pass generic information to the\r
     * object file.  The first parameter gives the information type\r
     * (currently only command line switches)\r
     * and the second parameter gives the value.  This function returns\r
     * 1 if recognized, 0 if unrecognized\r
     */\r
    int (*setinfo)(enum geninfo type, char **string);\r
\r
    /*\r
     * This procedure is called by assemble() to write actual\r
     * generated code or data to the object file. Typically it\r
     * doesn't have to actually _write_ it, just store it for\r
     * later.\r
     *\r
     * The `type' argument specifies the type of output data, and\r
     * usually the size as well: its contents are described below.\r
     */\r
    void (*output) (long segto, const void *data, unsigned long type,\r
            long segment, long wrt);\r
\r
    /*\r
     * This procedure is called once for every symbol defined in\r
     * the module being assembled. It gives the name and value of\r
     * the symbol, in NASM's terms, and indicates whether it has\r
     * been declared to be global. Note that the parameter "name",\r
     * when passed, will point to a piece of static storage\r
     * allocated inside the label manager - it's safe to keep using\r
     * that pointer, because the label manager doesn't clean up\r
     * until after the output driver has.\r
     *\r
     * Values of `is_global' are: 0 means the symbol is local; 1\r
     * means the symbol is global; 2 means the symbol is common (in\r
     * which case `offset' holds the _size_ of the variable).\r
     * Anything else is available for the output driver to use\r
     * internally.\r
     *\r
     * This routine explicitly _is_ allowed to call the label\r
     * manager to define further symbols, if it wants to, even\r
     * though it's been called _from_ the label manager. That much\r
     * re-entrancy is guaranteed in the label manager. However, the\r
     * label manager will in turn call this routine, so it should\r
     * be prepared to be re-entrant itself.\r
     *\r
     * The `special' parameter contains special information passed\r
     * through from the command that defined the label: it may have\r
     * been an EXTERN, a COMMON or a GLOBAL. The distinction should\r
     * be obvious to the output format from the other parameters.\r
     */\r
    void (*symdef) (char *name, long segment, long offset, int is_global,\r
            char *special);\r
\r
    /*\r
     * This procedure is called when the source code requests a\r
     * segment change. It should return the corresponding segment\r
     * _number_ for the name, or NO_SEG if the name is not a valid\r
     * segment name.\r
     *\r
     * It may also be called with NULL, in which case it is to\r
     * return the _default_ section number for starting assembly in.\r
     *\r
     * It is allowed to modify the string it is given a pointer to.\r
     *\r
     * It is also allowed to specify a default instruction size for\r
     * the segment, by setting `*bits' to 16 or 32. Or, if it\r
     * doesn't wish to define a default, it can leave `bits' alone.\r
     */\r
    long (*section) (char *name, int pass, int *bits);\r
\r
    /*\r
     * This procedure is called to modify the segment base values\r
     * returned from the SEG operator. It is given a segment base\r
     * value (i.e. a segment value with the low bit set), and is\r
     * required to produce in return a segment value which may be\r
     * different. It can map segment bases to absolute numbers by\r
     * means of returning SEG_ABS types.\r
     *\r
     * It should return NO_SEG if the segment base cannot be\r
     * determined; the evaluator (which calls this routine) is\r
     * responsible for throwing an error condition if that occurs\r
     * in pass two or in a critical expression.\r
     */\r
    long (*segbase) (long segment);\r
\r
    /*\r
     * This procedure is called to allow the output driver to\r
     * process its own specific directives. When called, it has the\r
     * directive word in `directive' and the parameter string in\r
     * `value'. It is called in both assembly passes, and `pass'\r
     * will be either 1 or 2.\r
     *\r
     * This procedure should return zero if it does not _recognise_\r
     * the directive, so that the main program can report an error.\r
     * If it recognises the directive but then has its own errors,\r
     * it should report them itself and then return non-zero. It\r
     * should also return non-zero if it correctly processes the\r
     * directive.\r
     */\r
    int (*directive) (char *directive, char *value, int pass);\r
\r
    /*\r
     * This procedure is called before anything else - even before\r
     * the "init" routine - and is passed the name of the input\r
     * file from which this output file is being generated. It\r
     * should return its preferred name for the output file in\r
     * `outname', if outname[0] is not '\0', and do nothing to\r
     * `outname' otherwise. Since it is called before the driver is\r
     * properly initialised, it has to be passed its error handler\r
     * separately.\r
     *\r
     * This procedure may also take its own copy of the input file\r
     * name for use in writing the output file: it is _guaranteed_\r
     * that it will be called before the "init" routine.\r
     *\r
     * The parameter `outname' points to an area of storage\r
     * guaranteed to be at least FILENAME_MAX in size.\r
     */\r
    void (*filename) (char *inname, char *outname, efunc error);\r
\r
    /*\r
     * This procedure is called after assembly finishes, to allow\r
     * the output driver to clean itself up and free its memory.\r
     * Typically, it will also be the point at which the object\r
     * file actually gets _written_.\r
     *\r
     * One thing the cleanup routine should always do is to close\r
     * the output file pointer.\r
     */\r
    void (*cleanup) (int debuginfo);\r
};\r
\r
/*\r
 * values for the `type' parameter to an output function. Each one\r
 * must have the actual number of _bytes_ added to it.\r
 *\r
 * Exceptions are OUT_RELxADR, which denote an x-byte relocation\r
 * which will be a relative jump. For this we need to know the\r
 * distance in bytes from the start of the relocated record until\r
 * the end of the containing instruction. _This_ is what is stored\r
 * in the size part of the parameter, in this case.\r
 *\r
 * Also OUT_RESERVE denotes reservation of N bytes of BSS space,\r
 * and the contents of the "data" parameter is irrelevant.\r
 *\r
 * The "data" parameter for the output function points to a "long",\r
 * containing the address in question, unless the type is\r
 * OUT_RAWDATA, in which case it points to an "unsigned char"\r
 * array.\r
 */\r
#define OUT_RAWDATA 0x00000000UL\r
#define OUT_ADDRESS 0x10000000UL\r
#define OUT_REL2ADR 0x20000000UL\r
#define OUT_REL4ADR 0x30000000UL\r
#define OUT_RESERVE 0x40000000UL\r
#define OUT_TYPMASK 0xF0000000UL\r
#define OUT_SIZMASK 0x0FFFFFFFUL\r
\r
/*\r
 * ------------------------------------------------------------\r
 * The data structure defining a debug format driver, and the\r
 * interfaces to the functions therein.\r
 * ------------------------------------------------------------\r
 */\r
\r
struct dfmt {\r
\r
    /*\r
     * This is a short (one-liner) description of the type of\r
     * output generated by the driver.\r
     */\r
    const char *fullname;\r
\r
    /*\r
     * This is a single keyword used to select the driver.\r
     */\r
    const char *shortname;\r
\r
\r
    /*\r
     * init - called initially to set up local pointer to object format,\r
     * void pointer to implementation defined data, file pointer (which\r
     * probably won't be used, but who knows?), and error function.\r
     */\r
    void (*init) (struct ofmt * of, void * id, FILE * fp, efunc error);\r
\r
    /*\r
     * linenum - called any time there is output with a change of\r
     * line number or file.\r
     */\r
    void (*linenum) (const char * filename, long linenumber, long segto);\r
\r
    /*\r
     * debug_deflabel - called whenever a label is defined. Parameters\r
     * are the same as to 'symdef()' in the output format. This function\r
     * would be called before the output format version.\r
     */\r
\r
    void (*debug_deflabel) (char * name, long segment, long offset,\r
                            int is_global, char * special);\r
    /*\r
     * debug_directive - called whenever a DEBUG directive other than 'LINE'\r
     * is encountered. 'directive' contains the first parameter to the\r
     * DEBUG directive, and params contains the rest. For example,\r
     * 'DEBUG VAR _somevar:int' would translate to a call to this\r
     * function with 'directive' equal to "VAR" and 'params' equal to\r
     * "_somevar:int".\r
     */\r
    void (*debug_directive) (const char * directive, const char * params);\r
\r
    /*\r
     * typevalue - called whenever the assembler wishes to register a type\r
     * for the last defined label.  This routine MUST detect if a type was\r
     * already registered and not re-register it.\r
     */\r
    void (*debug_typevalue) (long type);\r
\r
    /*\r
     * debug_output - called whenever output is required\r
     * 'type' is the type of info required, and this is format-specific\r
     */\r
    void (*debug_output) (int type, void *param);\r
\r
    /*\r
     * cleanup - called after processing of file is complete\r
     */\r
    void (*cleanup) (void);\r
\r
};\r
/*\r
 * The type definition macros\r
 * for debugging\r
 *\r
 * low 3 bits: reserved\r
 * next 5 bits: type\r
 * next 24 bits: number of elements for arrays (0 for labels)\r
 */\r
\r
#define TY_UNKNOWN 0x00\r
#define TY_LABEL   0x08\r
#define TY_BYTE    0x10\r
#define TY_WORD    0x18\r
#define TY_DWORD   0x20\r
#define TY_FLOAT   0x28\r
#define TY_QWORD   0x30\r
#define TY_TBYTE   0x38\r
#define TY_COMMON  0xE0\r
#define TY_SEG     0xE8\r
#define TY_EXTERN  0xF0\r
#define TY_EQU     0xF8\r
\r
#define TYM_TYPE(x) ((x) & 0xF8)\r
#define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)\r
\r
#define TYS_ELEMENTS(x)  ((x) << 8)\r
/*\r
 * -----\r
 * Other\r
 * -----\r
 */\r
\r
/*\r
 * This is a useful #define which I keep meaning to use more often:\r
 * the number of elements of a statically defined array.\r
 */\r
\r
#define elements(x)     ( sizeof(x) / sizeof(*(x)) )\r
\r
extern int tasm_compatible_mode;\r
\r
/*\r
 * This declaration passes the "pass" number to all other modules\r
 * "pass0" assumes the values: 0, 0, ..., 0, 1, 2\r
 * where 0 = optimizing pass\r
 *       1 = pass 1\r
 *       2 = pass 2\r
 */\r
\r
extern int pass0;   /* this is globally known */\r
extern int optimizing;\r
\r
#endif\r