read.me

CBASE v1.01 采用Borland公司TC++编写的数据库管理源程序库

 -L       Generate an assembly listing on the standard output file.  If 
          you do not want the listing to go to the screen, then provide 
          a redirection specification (e.g., >prn or >abc.lst) to send 
          it whereever you wish.  

 -NM      No macro processing.  This speeds up the assembler somewhat.  
          Macro processing is NOT needed for Small-C output files.  

 -P       Pause on errors waiting for an ENTER keystroke.

 -S#      Set symbol table size to accept # symbols.  Default is 1000.

If an illegal switch is given, the assembler aborts with the message

        Usage: ASM source [object] [-C] [-L] [-NM] [-P] [-S#]

The null switch (- or /) can be used to force this message.

If the assembler aborts with an exit code of 1, there is insufficient 
memory to run it.  Pressing control-S makes the assembler pause until 
another key is pressed, and control-C aborts the run with an exit code 
of 2.  Press ENTER to resume execution after a pause because of an 
error.  

Symbols (names of labels, etc.) may be up to 31 characters long.  Every 
character has significance.  Symbols may contain the following 
characters: 

        1. alphabetic
        2. numeric
        3. the special characters _, $, ?, and @.

Labels must be terminated by a colon.  All other names which begin a 
line must not have a colon.  

Comments begin with a semicolon (;) and continue to the end of the line.  

ASCII strings are must be delimited by quotes (") or apostrophies (').  
The backslash (\) may be used to escape the delimiter when it appears 
within the string.  

Only integer numbers are recognized by the assembler.  Numeric constants 
must begin with a numeric (decimal) digit.  The default base (radix) for 
numeric constants is decimal.  Bases may be specified explicitely by 
attaching a letter to the right end of the number as follows: 

             b or B    binary
             o or O    octal
             q or Q    octal
             d or D    decimal
             h or H    hexadecimal 

Expressions may produce the Boolean values 1 for "true" or 0 for 
"false".  This differs from Microsoft which yields FFFFh for "true".  

Expression evaluation is done with 32-bit precision.  The low order bits 
are then used according to the needs of the instruciton being generated.  
Expressions may contain the following operators: 

        (highest precedence)
        -------------------------------------  unary operators
        BYTE  PTR      take following operand as a byte
        WORD  PTR      take following operand as a word (2 bytes)
        DWORD PTR      take following operand as a double word (4 bytes)
        FWORD PTR      take following operand as a far word (6 bytes)
        QWORD PTR      take following operand as a quad word (8 bytes)
        NEAR  PTR      consider the following label near
        FAR   PTR      consider the following label far
        OFFSET         the offset to the follownig operand
        SEG            the segment address of the following operand
        xS:            segment register override (e.g. ES:)
        [  ]           indirect memory reference
        !              Logical not
        -              minus
        ~              one's complement
        NOT            one's complement
        ------------------------------------- 
        *              multiplication
        /              division
        %              modulo
        MOD            modulo
        ------------------------------------- 
        .              addition of indirect reference displacement
        +              addition
        -              subtraction
        ------------------------------------- 
        <<             shift left
        >>             shift right
        ------------------------------------- 
        !=             not equal
        NE             not equal
        <=             less than or equal
        LE             less than or equal
        <              less than
        LT             less than
        >=             greater than or equal
        GE             greater than or equal
        >              greater than
        GT             greater than
        ==             equal
        EQ             equal
        ------------------------------------- 
        &              bitwise AND
        AND            bitwise AND
        ------------------------------------- 
        ^              bitwise exclusive OR
        XOR            bitwise exclusive OR
        ------------------------------------- 
        |              bitwise inclusive OR
        OR             bitwise inclusive OR
        ------------------------------------- 
        (lowest precedence)

Notice that these precedence levels agree with the C language and 
disagree with the Microsoft assembler.  This should only rarely be a 
problem, however, since most expressions are very simple.  Nevertheless, 
parentheses may be used to override the default precedences.  

The dollar sign ($) represents the value of the location counter at the 
beginning of the current instruction.  

This version of the assembler knows only the instruction set of the 8086 
processor.  It does not know the 8087 instructions.  Future editions 
will know all of the 80x86 processors and their coprocessors.  

The following directives are recognized by this verson of the assembler.  
Only the parameter values shown are supported, however.  

     -------------------------------------------------
            .CASE          (see the -C switch above)
     -------------------------------------------------
     name   EQU constantexpression
     alias  EQU symbol
     -------------------------------------------------
     name   =  constantexpression
     -------------------------------------------------
     name   MACRO
            ...
            ENDM
     -------------------------------------------------
     name   SEGMENT  [align]  [combine]  [class]
                      BYTE     PUBLIC     'name'
                      WORD     STACK
                      PARA     COMMON
                      PAGE
            ...
            ENDS
     -------------------------------------------------
     name   GROUP segmentname,,,
     -------------------------------------------------
     name   PROC [distance]
                  NEAR
                  FAR
            ...
            ENDP
     -------------------------------------------------
            ASSUME NOTHING
            ASSUME register:name,,,
                   CS       segmentname
                   SS       groupname
                   DS       NOTHING
                   ES
                   FS
                   GS
     -------------------------------------------------
            PUBLIC name,,,
     -------------------------------------------------
            EXTRN name:type,,,
                       BYTE
                       WORD
                       DWORD
                       FWORD
                       QWORD
                       NEAR
                       FAR
     -------------------------------------------------
     [name] DB expression,,,
     [name] DW expression,,,
     [name] DD expression,,,
     [name] DF expression,,,
     [name] DQ expression,,,
     -------------------------------------------------
            ORG expression
     -------------------------------------------------
            END [start]
     -------------------------------------------------
     name   MACRO
     -------------------------------------------------
            ENDM
     -------------------------------------------------

Macro definitions begin with the MACRO directive and end with the ENDM 
directive as shown above.  Macro definitions cannot be nested; however, 
macro expansions (or calls) can.  Since macro arguments are not named, 
none appear with the MACRO directive.  Within the body of the macro, the 
symbol ?1 indicates places where the first argument of the macro call is to 
go.  Likewise, ?2 designates locations where the second argument goes, 
and so forth through ?0 for the 10th argument.  Macro argument 
substitution is done without regard to context, so you are not limited 
to replacing whole symbols with an argument.  For instance, you might 
write J?0 for the mnemonic of a conditional jump.  The first argument of 
the call might be LE, resulting in a mnemonic of JLE.  

To avoid "Redundant Definition" errors when a macro containing labels is 
called more than once, you may write labels within the body of a macro 
as @n, where n is a decimal digit.  This allows ten such labels per 
macro.  The assembler maintains a running count of such labels as 
assembly progresses.  Whenever such a label is found in a macro 
expansion, it is replaced by a label of the form @x, where x is the 
running count.  

Small Assembler makes no distinction between warnings and hard errors.  
If it issues any error messages in a run, then it finishes the run with 
an exit code of 10 which can be tested by means of an IF statement in a 
batch file.  In that case, it also deletes the OBJ file so that you 
cannot attempt to link and execute an erroneous program.  The following 
error messages may be issued by the assembler: 

   Per Run

   - No Source File        no input file is specified or it doesn't exist
   - Error in Object File  an error occurred wirting the OBJ file
   - Missing ENDM          the program ended within a macro definition
   - Missing END           the program ended without an END directive
   - Deleted Object File   the OBJ file was deleted because of errors

   Per Segment

   - CS Not Assumed for    
     this Segment          there is no ASSUME for CS and this segment

   Per Line

   - Phase Error           the address of a label differs between passes
   - Bad Expression        an expression is written improperly
   - Invalid Instruction   this mnemonic/operand combination is not defined
   - Redundant Definition  the same symbol is defined more than once
   - Bad Symbol            a symbol is improperly formed
   - Relocation Error      an relocatable address is written as absolute
   - Undefined Symbol      an undefined symbol is referenced
   - Bad Parameter         a macro call does not give a required parameter
   - Range Error           a self-relative reference is too distant
   - Syntax Error          an instruction or directive is improperly formed
   - Not Addressable       "END xxx" has something other than an address
   - Segment Error         a segment is not defined or referenced properly
   - Procedure Error       a procedure is not defined properly


USING THE ARCHIVE MAINTAINER

Comments in the front of AR.C describe the operation of the archive 
maintainer AR.EXE.  To extract all of the modules out of the library 
archive, enter the command: 

                          AR -X CLIB.ARC