CHAPTER 14   DESCRIPTIONS OF A86 ERROR MESSAGES


~01 Unknown Mnemonic~

   Most assembly-language lines start with a built-in instruction
   mnemonic such as MOV or ADD.  The only circumstances in which
   a line can start with non-built-in symbol are if the symbol is
   a macro name or INT equate, or if the symbol is now being
   defined, as indicated by a limited set of following symbols: a
   colon, EQU, DB, DW, etc.  This line started with a
   non-built-in symbol which did not fall into any of the above
   categories.  You might have misspelled an instruction
   mnemonic, or misspelled the following word.

~02 Jump > 128~

   The destination operand of a conditional jump must be a label
   within 128 bytes of the end of the instruction.  (Precisely,
   from -128 to +127 from the next instruction, which is from
   -126 to +129 from the start of the conditional jump.)   This
   error is reported in three possible places:

    1. At the conditional jump.  The operand is more than 126
       bytes before the jump, or the operand is not a label (e.g.
       you tried an indirect conditional jump through a variable,
       which isn't allowed)

    2. At a label definition.  In this case, you use your editor
       to search backwards for references to the label.  One or
       more of the earliest conditional jumps found are too far
       away.

    3. At a RET, RETF, or IRET instruction.  You use your editor
       to search backwards for that flavor of RET used as the
       operand to a conditional jump (the A86 conditional return
       feature). The earliest such jumps not satisfied by a
       previous RET are too far away.

   You usually correct this error by rearranging your code, or
   (better) by breaking intervening code off into subroutines. If
   desperate, you can replace "Jcond" with "IF cond JMP".

~03 [BX+BP] And [SI+DI] Not Allowed~

   The 86 instruction set does not support the combinations of
   indexing registers indicated in the error message.  In
   previous versions of A86, this error was reported in other
   illegal operand combinations; I've attempted to change other
   cases to error 14.  If you ever find otherwise, let me know.

~04 Bad Character In Number~

   All numbers, and only numbers, start with a decimal digit.
   (It's illegal to have a symbol begin with a digit; e.g.
   01MYVAR .)   You have coded something that starts with a
   decimal digit but does not have the correct format for a
   numeric constant.  See Chapter 8 for detailed descriptions of
   the formats of both integer and floating constants.
                                                             14-2

~05 Operands Not Allowed~

   When this error is reported it usually means that you have
   provided something more than just the mnemonic for an
   instruction that does not have any operands: e.g., PUSHF,
   STOSB, STC, FLDPI, CLTS.  It's also called in other contexts
   when the assembler expects nothing more on the line; e.g.,
   NAME with more than just a single name following, or something
   following the word ENDS.

~06 Symbol Required~

   This is reported in numerous situations where A86 requires
   some sort of symbol: either a built-in assembler mnemonic, or
   a symbol you define.  (It's possible that a number or some
   punctuation marks are legal in the context, and that they have
   already been checked for.)  Instead of a symbol, a punctuation
   mark or out-of-context number was seen.  The contexts in which
   this error can occur include:

    * the start of a line (characters hex 3C or greater)

    * after the following at the start of a line: a symbol you
       define, #, #IF, IF, CODE, or DATA

    * where operands to the following directives are expected:
       NAME, PUBLIC, EXTRN, GROUP, SEGMENT

    * after ">" denoting a local-label forward reference

~07 Local Symbol Required~

   This is reported when something other than a generic local
   label (letter followed by one or more digits) follows a ">"
   mark, which denotes a local-label forward reference.  If you
   meant "greater than" you use the GT operator instead.

~08 Too Many Operands~

   This is reported for instructions and directives requiring a
   limited number of operands, for which the limit is exceeded.
   Since operands are separated by commas, you have too many
   commas-- possibly an extra comma between the mnemonic and
   first operand, or at the end of the operands.

~09 Constant Required~

   This is reported for instructions and directives (ENTER, RET,
   RADIX, etc.) requiring operands that are an immediate constant
   number; and for expression operators (*, /, SHL, OR, NOT, BY,
   etc.) whose operands must be constant.  In some cases a
   limited number of forms other than constants are acceptable,
   but the assembler has already checked for and not found those
   possibilities.

~10 More Operands Required~
                                                             14-3

   This is reported for instructions requiring two operands, for
   which you have provided no operands or only one operand.  You
   might have left out the comma separating the operands.

~11 Constant/Label Not Allowed~

   This is reported when you have given a constant number in a
   place where it isn't allowed-- usually as a destination
   operand to an instruction, such as the first operand to a MOV
   or ADD.  If you meant the operand to be the memory location
   with the constant offset, you must convert the type by
   enclosing the operand in brackets [ ] or appending a
   size-specifier (B, W, D, Q, or T) to the number.

~12 Segment Register Not Allowed~

   This is reported when you have used a segment register in an
   instruction where it isn't allowed.  The only instructions
   allowing segment registers as operands are MOV, PUSH, and POP.
   You can't, for example, ADD into a segment register.  If you
   want to do anything with a segment register value, you have to
   MOV it into a general register, perform the operation, then
   MOV the result back to the segment register.

~13 Byte/Word Combination Not Allowed~

   This is reported in a two-byte instruction in which one
   operand is byte-sized and the other word-sized; or in an
   instruction with a byte-sized destination and an immediate
   source whose value is not byte-sized (high byte not 0 or 0FF).
   If one of the operands is a memory variable of the wrong size,
   you either change the declaration of the variable (DB to DW or
   vice versa) or override the size of the variable in this
   instruction only, by appending a " B" or " W" to the memory
   operand.

~14 Bad Operand Combination~

   This is reported when you attempt to add or combine terms in
   an operand expression that do not allow combination.  An
   example of this would be DT 3.7+BX.  Only constants can be
   added to floating point numbers.

   This is also reported when you have two operands that are
   mismatched in size, and the mismatch is something other than
   Byte vs. Word. Example: MOV AL,D[0100].

~15 Bad Subtraction Operands~
                                                             14-4

   This is reported when you attempt to subtract terms in an
   operand expression that do not allow subtraction, or if the
   right-hand side to a subtraction is missing.  If the
   right-hand side to a subtraction is a non-forward-referenced
   constant, then the left side can be almost anything.
   Otherwise, the operands must match; e.g., labels from
   relocatable segments must be in the same segment (in which
   case the answer is an absolute constant; namely, the size of
   the block of memory between the two labels).

~16 Definition Conflicts With Forward Reference~

   This error occurs when the assembler has previously guessed
   the type of a forward-referenced symbol in order to determine
   what kind of instruction to generate, and the guess turned out
   to be wrong.  The error is reported at the time the symbol is
   defined.  For example, when A86 sees MOV AX,FOO, it will
   assume FOO is an immediate value.  This error is reported if
   FOO turns out to be a word variable: FOO DW 0.  You need to
   search backwards from the error message, to references of FOO,
   and specify the type you intend to be used: MOV AX,FOO W.  If
   you really did intend to load the offset of FOO and not the
   memory contents, you can code MOV AX,OFFSET FOO to make the
   error message go away.

~17 Divide Overflow~

   This is reported when the right-hand side to a division or MOD
   operation is zero, or when the result of a division by a large
   (>64K) number is still large.

~18 Same Type Required~

   This is reported when the two operands to a relational
   operator (EQ, NE, GT, GE, LT, or LE) are of different types.
   The operands to a relational operator ought to be both
   absolute integer constants, or labels in the same segment.

~19 CS Destination Not Allowed~

   This is reported if you attempt to specify CS as the
   destination (first) operand to MOV, or as an operand to POP.
   The only acceptable way to load CS on the 8086 is via a far
   JMP, CALL, RETF, or IRET instruction.  The MOV and POP forms
   don't make much sense, so they were outlawed by Intel.

~20 Left Operand Not Allowed~

   This is reported if you have a left-hand side to an expression
   operator that expects only a single operand to its right.
   Those operators are BIT, NOT, OFFSET, TYPE, LOW, HIGH, SHORT,
   LONG, and INT.  (The mnemonic INT is considered an operator
   e.g., in MSDOS EQU INT 33.)  For example, you would get this
   error for the expression 1 NOT 2.

~21 Bad Single Operand~
                                                             14-5

   This is reported if the operand is inappropriate for an
   instruction INC, DEC, PUSH, POP, NOT, NEG, MUL, IMUL, DIV, or
   IDIV, that takes a single operand.  You should look up the
   instruction in the chart in Chapter 6, to determine the proper
   operand forms allowed.

~22 Bad DUP Usage~

   This is reported when a DUP construct occurs out of context
   (e.g. in an instruction operand instead of a data
   initialization); when the total number of bytes generated
   would push the output pointer beyond 64K; or when there is
   improper syntax for a DUP.  See Chapter 9 for the description
   of correct DUP usage.

~23 Number Too Large~

   This is reported when a numeric constant is too large for the
   assembler to store in its operand buffers-- the limit for
   integers is 2**80-1 = 1208925819614629174706175 decimal. The
   error is also given when the exponent part of a floating point
   constant is greater than 65535 in magnitude.

~24 SEGMENT or ENDS Required~

   This is reported if a line beginning with one of the two A86
   keywords CODE or DATA does not continue with one of the
   keywords SEGMENT or ENDS.  If you meant CODE or DATA to be a
   symbol you define, you have to change the name to something
   else, like _CODE or _DATA.

~25 Bad CALL/JMP Operand~

   This is reported if the operand to a call or jump instruction
   cannot be taken as a jump destination.  This occurs if the
   operand is missing, or if it has a size inappropriate for
   address pointers: byte, quadword, or ten-byte.  The error also
   occurs if the operand is a constant number, and you are
   assembling to an OBJ format.  In OBJ format anything jumped to
   within a segment must be specified as a label within some
   segment.

~26 Memory Doubleword Required~

   This is reported if the second operand to an LDS, LES, or
   BOUND instruction is of the wrong type.  The operand should be
   a doubleword memory quantity; but A86 will accept a word
   memory variable or a memory variable of unspecified size.

~27 Bad IN/OUT Operand~

   This is reported when the operands to IN or OUT do not have
   the correct form.  See Chapter 6 for the limited set of forms
   for these instructions.  One of the operands must be AL or AX;
   the other must be DX or a constant between 0 and 255.

~28 type Required~
                                                             14-6

   This is reported when a symbol given in an EXTRN list is not
   followed one of the type names B, W, D, Q, T, F, NEAR, or ABS.
   The more verbose synonyms BYTE, WORD, DWORD, QWORD, and TBYTE
   are also acceptable.

~29 Bad Rotate/Shift Operand~

   This is reported when the count (second) operand to a rotate
   or shift instruction is not appropriate: it should be either
   the name CL or a constant less than 32.  The instructions
   requiring this are ROL, ROR, RCL, RCR, SHL, SHR, SAL, SAR, and
   the NEC-specific instructions SETBIT, TESTBIT, CLRBIT, and
   NOTBIT.

~30 Byte-Sized Constant Required~

   This is reported in contexts where only a byte-sized absolute
   constant is acceptable.  Those contexts are: the operand to a
   BIT or INT operator in an expression; the required operand to
   an INT or CALL80 instruction; the optional operand to an AAM
   or AAD instruction.

~31 Instruction In Data Segment Not Allowed~

   There are only a limited number of directives allowed with a
   STRUC or a DATA segment.  This error is reported when any
   instructions or disallowed directives are seen in one of these
   restricted environments.  You have possibly neglected to
   provide an ENDS directive, returning you to normal assembly.
   In a STRUC, the only directives allowed are DB, DW, DD, DQ,
   DT, another STRUC, ENDS, EQU, SEGMENT, GROUP, MACRO, LABEL,
   EVEN, and ORG.  The DATA segment allows the same directives,
   plus PROC, ENDP, DATA, and CODE.

~32 Bad String~

   This is reported when you start a quoted string, and do not
   provide the closing quote in the same line.  You might have
   left it out; or you might not have intended to code a string
   at all, and accidentally inserted a single- or double-quote
   mark in your line.  Or you might have intended a string
   containing an end-of-line, which isn't allowed.  You must
   instead close the string and code hex bytes 0D,0A to represent
   an end-of-line.

~33 Bad Data Operand~

   This is reported if an inappropriate operand is seen in a data
   initialization (DB, DW, DD, DQ, or DT) directive.  Examples of
   this are indexed quantities such as [BX], non-byte quantities
   in a DB, or floating point constants in a DB or DW.

~34 Index Brackets Required~
                                                             14-7

   This is reported if the name of a register is given in an
   addition/combination operation, but the register is not
   enclosed in square brackets.  The only registers that may be
   added are those presented as indexing registers.  For example,
   don't code BX+2, code [BX+2].

~35 Bad Character~

   This is reported when a punctuation mark or other non-standard
   character is seen where it is not expected.  The characters
   causing this error at the beginning of a line are digits, and
   the marks  / - , + * ( ) & " !   --  other illegal marks at
   the start of a line cause error 6, Symbol Required.  The
   characters causing this error elsewhere (i.e. within operands)
   are all characters except letters, digits, and the marks [ ] +
   - ' " > ( ) * . / :

~36 String > 2 Not Allowed~

   This is reported when a string with 3 or more characters is
   seen outside of the places where such a string is allowed (in
   a DB directive, macro operand, or relocatable SEGMENT
   directive).  One- and two-character strings are treated as
   simple numeric constants; but longer strings require special
   handling and are allowed only in the places mentioned.

~37 Misplaced Built-In Symbol~

   The symbol just before this error message is an A86 built-in
   symbol, that is in a place where it doesn't belong.  Examples
   of this are: mnemonics such as MOV occurring in operands; and
   symbols that aren't mnemonics such as LT occurring at the
   start of the line.  If you thought you could define the symbol
   to the left of this message for your own use, you were wrong.
   You need to change the symbol to something else: TEST to
   _TEST, for example.  If you'd like to know the built-in
   meaning of the symbol, you can look it up in Chapter 16.

~38 Segment Combination Not Allowed~

   This is reported when you attempt to add or combine a segment
   or group name with another quantity.  A86 currently doesn't
   allow this.

~39 Bad Index Register~

   This is reported when you attempt to use a register other than
   SI, DI, BX, or BP for indexing.  Those are the only registers
   that the 86 architecture allows you to place inside brackets,
   to address memory.

~40 Conflicting Multiple Definition Not Allowed~
                                                             14-8

   This is reported when you define a symbol in two places in
   your program, and the definitions aren't the same.  Most often
   you have simply forgotten you already had a symbol somewhere
   of the same name, and you need to change the name of one of
   the two symbols you've defined.  A86 allows the re-use of a
   symbol if it is a generic local label (a letter followed by
   one or more digits), or if is defined with = instead of EQU.
   A86 also allows the redefinition of a symbol if it has exactly
   the same value (e.g. ESC EQU 01B in two places in your
   program).  See the section "Duplicate Definitions" in Chapter
   9 for a detailed discussion of this feature.

~41 ENDS Has No Segment~

   This error occurs when A86 is assembling to an OBJ file, and
   it sees an ENDS at the outermost level of segments-- the ENDS
   has not been preceded by a matching SEGMENT directive.  You
   need to look over your SEGMENT and ENDS directives, to get
   them to match up properly.

~42 Bad IF Operand~

   This is reported when an IF is not followed by one of the
   flag-mnemonics (e.g., E, Z, NC, AE, etc.) that follow "J" in a
   conditional jump instruction.  Most likely the line is a
   conditional assembly line intended for another assembler.  In
   A86, conditional assembly lines begin with a hash sign #.  So
   you change IF, ELSE, ENDIF to #IF, #ELSE, #ENDIF.  You may
   also need to change the condition following IF: IF FOO EQU 0
   becomes #IF !FOO; IFDEF FOO becomes simply #IF FOO. IF
   (expression) must be replaced by the two lines C1 EQU
   (expression) followed by #IF C1 .  See Chapter 11 for the
   details of A86's syntax for conditional assembly.  See Chapter
   5 for the way A86 uses IF when it doesn't have a hash sign #.

~43 Parenthesis/Bracket Mismatch~

   This is reported when there is a lack of balance of
   parentheses ( ) or brackets [ ] in an operand expression--
   there are too many left-sides, too many right-sides, or the
   brackets are interleaved illegally: ( [ ) ].  Most likely you
   have left out an opening or closing parenthesis/bracket in a
   complicated expression; or a spurious extra ( ) [ or ] has
   crept into your code.

~44 Bad Forward Reference Combination~

   This is reported when you try to use forward references in
   expressions that are too complicated for A86 to handle.  You
   can add or subtract constants from forward-referenced symbols;
   but you can't subtract a forward-referenced symbol from
   anything, and you can't add two forward references together.
   You can typically get around restrictions in forward reference
   expressions by moving the expression down to an EQU directive
   after the point that the symbols are defined, and making a
   forward reference to the EQUated symbol that represents the
   evaluated expression.
                                                             14-9

   This error is also reported in some situations involving
   relocatable symbols in OBJ mode -- these symbols are forward
   references in the sense that they are resolved only at link
   time.

~45 Is It Byte Or Word?~

   This is reported when you have a memory operand of unspecified
   size, and A86 needs to know whether the operand is byte-sized
   or word-sized, in order to generate the correct instruction
   form.  All you need to do is to append a B or a W to the
   operand, to specify the size you want.  For example, if you've
   coded INC [BX], you need to decide between INC B[BX] and INC
   W[BX].  If you've coded ADD FOO,4 where FOO is a forward
   reference, you need to specify ADD FOO B,4 or ADD FOO W,4 .

~46 Bad #-Construct~

   This is reported if, within a macro definition, a # is seen
   that is not followed by one of the allowed macro parameter
   constructs described in Chapter 11.  Even in quoted strings,
   the hash sign # must be literalized via ## if it is to be
   taken as-is.

   If you mistakenly provide a macro-loop variable (#W, #X, #Y,
   or #Z) outside of any loop defining that variable, this error
   is detected when the macro is expanded, even though the error
   is in the macro definition.

   The error is also reported if # occurs at the beginning of a
   line, and is not followed by IF, ELSEIF, ELSE, or ENDIF; or if
   a conditional assembly parameter is a built-in mnemonic e.g.
   #IF MOV .  See Chapter 11 for the correct usage of the hash
   sign in both macros and conditional assembly.

~47 #ENDIF Required~

   This is reported if you have an #IF without a corresponding
   #ENDIF before the end of the file (or the end of the macro
   expansion if the #IF was assembled during a macro expansion).
   When this message appears at the end of a file, you need to
   search backwards for #IFs, to find the unclosed block.

~48 #EM Required To End Macro~

   This is reported if you have a MACRO without an end.  In A86,
   the end of a macro is given by #EM.  Most likely your file was
   written for another assembler, and you need to convert macro
   definitions.  You need to change all ENDM directives to #EM.
   You also need to eliminate the named parameters from the MACRO
   line, and replace occurrences of the named parameters with #1,
   #2, #3, etc.  The & concatenation operator can be dropped. See
   Chapter 11 for a full description of A86's macro syntax.

~49 End Delimiter to COMMENT Required~
                                                            14-10

   This is reported when the portion of code skipped in a COMMENT
   directive has run to the end of the file, without the closing
   delimiter being found.  You need to search backwards from the
   end of the file to find the COMMENT directive, figure out
   where you intend the directive to end, and duplicate the
   delimiter (the first non-blank following COMMENT) at that
   end-point.  See Chapter 4 for a full description of the
   COMMENT directive.

~50 Reg,Mem Required~

   This is reported when you have an improper combination of
   operands for a MOV, XCHG, or general arithmetic instruction
   such as ADD, SUB, CMP, XOR, etc.  Most often you have
   attempted to provide two memory operands: MOV VAR1,VAR2 or ADD
   VAR1,VAR2.  One of the operands must be a register.  You can
   effect the memory-to-memory operation by using a register in a
   two-instruction sequence; for example, MOV AX,VAR2 followed by
   ADD VAR1,AX .  For convenience, A86 lets you code the sequence
   with the single line ADD VAR1,AX,VAR2.

   If you don't wish to clobber the contents of any registers,
   and the operands are word-sized, you may PUSH the source
   operand and then POP to the destination operand: PUSH VAR2
   followed by POP VAR1.

~51 Segment Override Not Allowed Here~

   For compatibility with other assemblers, A86 allows segment
   override operators CS:, DS:, ES:, or SS: within expressions in
   instruction operands.  The override informs the assembler that
   the named segment register is to be used for the memory
   reference, so that the assembler might generate a segment
   override opcode byte.  This error is reported when a segment
   override operator occurs out of context: in A86's special
   three-operand form for MOV or arithmetic instructions; within
   a DATA segment or STRUC, or in an EQU directive.  You might
   encounter the last case if you're porting a program written
   for another assembler.  If so, you might have to provide
   explicit overrides wherever the EQUated symbol is used.  It's
   possible, though, that the override is provided only to
   satisfy the other assembler's segment checking mechanism, and
   no overrides are generated at all.  In that case, you can just
   eliminate the override operator.

~52 Byte Operand Required~

   This is reported when an operand to one of the NEC-specific
   instructions STOBITS, LODBITS, ROL4, ROR4 is of the wrong
   type.  STOBITS and LODBITS require the first operand to be a
   byte-sized register and the second operand to be either a
   byte-sized register or an immediate constant.  ROL4 and ROR4
   require the only operand to be a byte-sized register.

~53 Word Register Required~
                                                            14-11

   This is reported when the first operand to any of the
   instructions LDS, LES, LEA, BOUND, IMUL, LAR, or LSL is not a
   word-sized general register (AX,BX,CX,DX,SI,DI,BP, or SP).

~54 Floating-Point Chip Required~

   This is reported when you attempt to assemble a program with
   floating point constants or floating point expressions, and
   you do not have a floating point chip (8087 or 287) in your
   computer system.  A86 uses the 87 to assemble constants and do
   arithmetic.  It's time for you to buy a chip and install it in
   that empty socket!

~55 Bad Floating-Point Operand~

   This is reported when an operand to a floating point
   instruction is not of the correct type.  See Chapter 7 for the
   correct forms for the instruction you're coding.  Some
   possibilities for the error are:

   * a memory operand has unspecified size, or a size not
     compatible with the instruction.  Integer instructions
     (FIxxx) require a W or D operand; floating arithmetic
     instructions require a D or Q operand.

   * you've tried to specify an 86 register instead of a memory
     operand.

   * you've tried A86's special FLD (constant) form in OBJ mode.
     Sorry, I support this only for COM mode (mainly for D86).

   * you've specified two register numbers (0 through 7), but
     neither is 0.

   * you've tried one of the disallowed forms FCOM i,0 or FCOMP
     i,0

~56 Constant 0--7 Required~

   This is reported if a constant number operand to an 87
   instruction, which is supposed to represent an 87 stack number
   (0 through 7), does not have the right value; i.e., it's not
   an integer, or it's not in the range 0 through 7.

~57 Memory Operand Required~

   This is reported when an operand to a floating-point or a 286
   protected-mode instruction must be a memory operand, and the
   operand you've provided isn't one.  See Chapters 7 (for
   floating) or 6 (for protected) for the correct syntax of the
   instruction you're coding.

~58 Segment Or Struc Name Not Allowed~
                                                            14-12

   This error occurs most often when you are attempting to
   assemble as a COM program a file intended to be an EXE
   program.  The COM format does not allow you to refer to the
   value of a named segment, or to make a FAR pointer out of a
   label within the program.  You should either use the +O option
   to produce an OBJ file, or simply eliminate the statements
   intended to set the segment registers-- COM programs are
   started with all segment registers already pointing to the
   same value.

   This error is also reported when you provide the name of a
   structure, or the name of an INT equate, in a place where a
   register or memory operand is expected.

~59 Word Operand Required~

   This is reported when something other than a word-sized
   operand is provided for one of the 286 instructions ARPL,
   SLDT, LLDT, STR, LTR, VERR, VERW, SMSW, or LMSW.

~60 Circular Definition Not Allowed~

   This is reported when a chain of macro calls or references to
   undefined symbols reaches a depth of 1024.  A86 assumes that
   it is in an infinite loop: for example, FOO EQU FOO; or BAZ
   MACRO containing an uncontrolled call to BAZ within itself.


~61 Overlapping Local Not Allowed~

   Recall from Chapter 5 that when you use a local label symbol
   twice, you must distinguish a reference to that symbol by
   prepending a > before the symbol's name if the reference is a
   forward reference.  You get this error if you have followed
   such a forward reference with another reference, without the
   >, before the next incaration of the symbol is defined.
   There's a danger that you intended the reference to be to the
   previous incarnation, which A86 doesn't allow. Example:

   L1:         ; first incarnation of L1
     JNZ >L1   ; reference to second incarnation
     JMP L1    ; ERROR-- which incarnation are we referring to?
   L1:         ; second incarnation of L1

   If you intended the JMP to be to the second L1, you should
   prepend a > to the L1, just like the JNZ.  If you intended the
   JMP to be to the first L1, you must change one of the two
   label names so that their ranges don't overlap.

~62 ORG Required in first DATA SEGMENT~
                                                            14-13

   Previous versions of A86 allowed a default starting offset of
   0 for the DATA SEGMENT.  I hope in the future to change this
   default to the offset immediately following the program (if it
   is a COM file).  As a transition, I am outlawing ORGless DATA
   segments, so if it was your intention to start at offset 0,
   you must now state so explicitly with an ORG 0 following the
   first DATA SEGMENT directive in your program.

~97 Object Overflow~

   This is reported when the assembler runs out of room in its
   output object-code segment (which also holds records used to
   resolve forward references).  This will happen only if your
   object output nears the object capacity, which is 64K if a
   full amount of memory (about 200K) is available to the
   assembler.  If you have a limited amount of memory, you should
   increase the memory available to A86, by buying another board,
   or by having fewer memory-resident programs installed when you
   run A86.  If you are assembling OBJ files, you can break the
   program into smaller assembled modules.

   It's conceivable that this error could result in a D86
   session, when you are using patch-memory mode to type in an
   extremely complicated program.  In that case, you should type
   the program into a text file instead, and use A86 to assemble
   the text file.

~98 Undefined Symbol Not Allowed~

   This error should occur only during a D86 debugging session,
   when you type an immediate-execution assembly language line
   containing a symbol not in the table (typically a mistyping on
   your part).  D86 allows you to add symbols to the table only
   when you are in patch-memory mode (reached by pressing the F7
   key).

~99 Symbol Table Overflow~

   This is reported when the symbol table runs out of space. It's
   unlikely that you'll ever run into this error, since A86's
   capacity is thousands of symbols.  If you do, you'll need to
   reduce the number of symbols in your program.  One way to do
   so is to replace all place-marker symbols with local labels in
   a limited range (like L0--L9).  See Chapter 5 for a
   description of A86's local label facility.

