## The Macro Processor Description

### ... The Macro Processor

####

       ... Defining Macros
            .macro
            .endm
            .mexit
       ... Calling Macros
       ... Arguments in Macro Definitions and Macro Calls
               Macro Nesting
               Special Characters in Macro Arguments
               Passing Numerical Arguments as Symbols
               Number of Arguments in Macro Calls
               Creating Local Symbols Automatically
               Concatenation of Macro Arguments
       ... Macro Attributes Directives
            .narg
            .nchr
            .ntyp
            .nval
       ... Indefinite Repeat Block Directives
            .irp
            .irpc
       ... Repeat Block Directive
            .rept
       ... Macro Deletion Directive
            .mdelete
       ... Macro Invocation Details
       ... Building a Macro Library
               .mlib  Macro Directive
               .mcall Macro Directive
       ... Example Macro Cross Assemblers

       ... Go to Documentation Index

### Defining Macros

####

       By  using macros a programmer can use a single line to insert
    a sequence of lines into a source program.

       A  macro  definition is headed by a .macro directive followed
    by the source lines.  The source lines  may  optionally  contain
    dummy arguments.  If such arguments are used, each one is listed
    in the .macro directive.

       A  macro call is the statement used by the programmer to call
    the macro source program.  It consists of the  macro  name  fol-
    lowed  by  the  real arguments needed to replace the dummy argu-
    ments used in the macro.

       Macro  expansion  is  the insertion of the macro source lines
    into the main  program.   Included  in  this  insertion  is  the
    replacement of the dummy arguments by the real arguments.

       Macro  directives provide a means to manipulate the macro ex-
    pansions.  Only one directive is allowed per source line.   Each
    directive  may  have  a  blank  operand  field  or  one  or more
    operands.  Legal  operands  differ  with  each  directive.   The
    macros  and  their  associated  directives  are detailed in this
    chapter.

       Macro  directives  can replace any machine dependent mnemonic
    associated with a specific assembler.  However, the basic assem-
    bler directives cannot be replaced with a macro.

##### => Section Index

####

    .macro Directive

    Format:

    [label:]        .macro  name, dummy argument list

    where:  label   represents an optional statement label.

            name    represents the user-assigned symbolic
                    name of the macro.  This name  may be
                    any legal symbol and may be used as a
                    label elsewhere in the program.  The
                    macro name is not case sensitive,
                    name, NAME, or nAmE all refer to the
                    same macro.

            ,       represents a legal macro separator
                    (comma, space, and/or tab).

            dummy   represents a number of legal symbols
           argument that may appear anywhere in the body of
            list    the macro definition,  even as a label.
                    These dummy symbols can be used elsewhere
                    in the program with no conflict of
                    definition.  Multiple dummy arguments
                    specified in this directive may be
                    separated by any legal separator.  The
                    detection of a duplicate or an illegal
                    symbol in a dummy argument list
                    terminates the scan and causes a 'q'
                    error to be generated.

    A  comment may follow the dummy argument list in a .macro direc-
    tive, as shown below:

            .macro  abs     a,b     ;Defines macro abs

    The  first  statement  of  a  macro  definition must be a .macro
    directive.  Defining a macro with the same name as  an  existing
    macro will generate an 'm' error.  The .mdelete directive should
    be used to delete the previous macro definition before  redefin-
    ing a macro.

##### => Section Index

####

    .endm Directive

    Format:

            .endm

    The .endm directive should not have a label.  Because the direc-
    tives .irp, .irpc, and .rept may repeat more than once the label
    will  be  defined multiple times resulting in 'm' and/or 'p' er-
    rors.

       The  .endm  directive  may be followed by a comment field, as
    shown below:

            .endm           ;end of macro

       A  comment  may  follow  the  dummy argument list in a .macro
    directive, as shown below:

            .macro  typemsg message ;Type a message.
            jsr     typemsg
            .word   message
            .endm                   ;End of typemsg

    The  final  statement  of every macro definition must be a .endm
    directive.  The .endm directive is also used to terminate  inde-
    finite  repeat  blocks and repeat blocks.  A .endm directive en-
    countered outside a macro definition  is  flagged  with  an  'n'
    error.

##### => Section Index

####

    .mexit Directive

    Format:

            .mexit

    The  .mexit directive may be used to terminate a macro expansion
    before the end of the macro is encountered.  This  directive  is
    also  legal  within  repeat blocks.  It is most useful in nested
    macros.  The .mexit directive terminates the  current  macro  as
    though a .endm directive had been encountered.  Using the .mexit
    directive bypasses the complexities of nested conditional direc-
    tives  and  alternate  assembly paths, as shown in the following
    example:

            .macro  altr    N,A,B
              .
              .
              .
            .if eq,N        ;Start conditional Block
              .
              .
              .
            .mexit          ;Terminate macro expansion
            .endif          ;End of conditional block
              .
              .
              .
            .endm           ;Normal end of macro

    In  an  assembly  where  the  symbol  N is replaced by zero, the
    .mexit directive would assemble the conditional block  and  ter-
    minate  the  macro  expansion.   When macros ar nested, a .mexit
    directive causes an exit to the next higher level of  macro  ex-
    pansion.  A .mexit directive encountered outside a macro defini-
    tion is flagged with an 'n' error.

##### => Section Index

### Calling Macros

####

    Format:

            [label:]  name  real arguments

    where:  label   represents an optional statement label.

            name    represents the name of the macro, as
                    specified in the macro definition.

            real    represent symbolic arguments which
         arguments  replace the dummy arguments listed
                    in the .macro definition.  When
                    multiple arguments occur, they are
                    separated by any legal separator.
                    Arguments to the macro call are
                    treated as character strings, their
                    usage is determined by the macro
                    definition.

    A  macro  definition  must be established by means of the .macro
    directive before the macro can be called and expanded within the
    source program.

       When a macro name is the same as a user label, the appearance
    of the symbol in the operator field designates the symbol  as  a
    macro  call;   the appearance of the symbol in the operand field
    designates it as a label, as shown below:

    LESS:   mov     @r0,r1          ;LESS is a label
             .
             .
             .
            bra     LESS            ;LESS is considered a label
             .
             .
             .
            LESS    sym1,sym2       ;LESS is a macro call

##### => Section Index

### Arguments In Macro Definitions and Macro Calls

####

       Multiple arguments within a macro must be separated by one of
    the legal separating characters (comma, space, and/or tab).

       Macro  definition  arguments (dummy) and macro call arguments
    (real) maintain a strict positional relationship.  That is,  the
    first  real  argument in a macro call corresponds with the first
    dummy argument in the macro definition.

       For  example,  the  following  macro definition and its asso-
    ciated macro call contain multiple arguments:

            .macro  new     a,b,c
              .
              .
              .

            new     phi,sig,^/C1,C2/

    Arguments which themselves contain separating characters must be
    enclosed  within  the  delimiter  construct  ^/   /  where   the
    character  '/'  may be any character not in the argument string.
    For example, the macro call:

            new     ^/exg    x,y/,#44,ij

    causes the entire expression

            exg    x,y

    to  replace all occurrances of the symbol a in the macro defini-
    tion.  Real arguments with a macro call  are  considered  to  be
    character  strings  and  are  treated  as a single entity during
    macro expansion.

       The  up-arrow  (^)  construction also allows another up-arrow
    costruction to be passed as part of  the  argument.   This  con-
    struction,  for example, could have been used in the above macro
    call, as follows:

            new     ^!^/exg    x,y/!,#44,ij

    causing the entire string ^/exg    x,y/ to be passed as an argu-
    ment.

    Macro Nesting

       Macro  nesting  occurs  where  the expansion of one macro in-
    cludes a call to another macro.  The depth of nesting  is  arbi-
    trarily limited to 20.

       To  pass  an argument containing legal argument delimiters to
    nested macros, enclose the  argument  in  the  macro  definition
    within  an up-arrow construction, as shown in the coding example
    below.  This extra set of delimiters for each level  of  nesting
    is required in the macro definition, not the in the macro call.

            .macro  level1  dum1,dum2
            level2  ^/dum1/
            level2  ^/dum2/
            .endm

            .macro  level2  dum3
            dum3
            add     #10,z
            push    z
            .endm

    A call to the level1 macro, as shown below, for example:

            level1  ^/leaz    0,x/,^/tfr     x,z/

    causes the following macro expansion to occur:

            leaz    0,x
            add     #10,z
            push    z
            tfr     x,z
            add     #10,z
            push    z

    When  macro  definitions are nested, the inner definition cannot
    be called until the outer macro has been  called  and  expanded.
    For example, in the following code:

            .macro  lv1     a,b
              .
              .
              .
            .macro  lv2     c
              .
              .
              .
            .endm
            .endm

    the  lv2 macro cannot be called and expanded until the lv1 macro
    has been expanded.  Likewise, any macro defined within  the  lv2
    macro  definition  cannot  be  called and expanded until lv2 has
    also been expanded.

    Special Characters in Macro Arguments

       If  an  argument  does not contain spaces, tabs, or commas it
    may include special  characters  without  enclosing  them  in  a
    delimited construction.  For example:

            .macro  push    arg
            mov     arg,-(sp)
            .endm

            push    x+3(%2)

    causes the following code to be generated:

            mov     x+3(%2),-(sp)

    Passing Numerical Arguments as Symbols

       If the unary operator backslash (\) precedes an argument, the
    macro treats the argument as a numeric value in the current pro-
    gram  radix.   The  ascii characters representing this value are
    inserted in the macro expansion, and their function  is  defined
    in  the context of the resulting code, as shown in the following
    example:

            .macro  inc     a,b
            con     a,\b
            b = b + 1
            .endm

            .macro  con     a,b
    a'b:    .word   4
            .endm

            ...

            c = 0           ;Initialize

            inc     x,c

    The above macro call (inc) would thus expand to:

            x0:     .word   4

    In  this  expanded  code,  the  lable x0:  results from the con-
    catenation  of  two  real  arguments.   The  single  quote   (')
    character  in  the  label a'b:  concatenates the real argument x
    and 0 as they are passed during  the  expansion  of  the  macro.
    This type of argument construction is descibed in more detail in
    a following section.

       A  subsequent  call to the same macro would generate the fol-
    lowing code:

            x1:     .word   4

    and  so  on,  for  later  calls.   The two macro definitions are
    necessary because the symbol associated with the dummy  argument
    b (that is, symbol c) cannot be updated in the con macro defini-
    tion, because the character 0 has replaced  c  in  the  argument
    string  (inc  x,c).   In  the  con  macro definition, the number
    passed is treated as a string argument.  (Where the value of the
    real  argument  is 0, only a single 0 character is passed to the
    macro expansion.

    Number of Arguments in Macro Calls

       A  macro  can  be defined with or without arguments.  If more
    arguments appear in the macro call than in the macro definition,
    a  'q'  error  is  generated.   If fewer arguments appear in the
    macro call than in the macro definition, missing  arguments  are
    assumed to be null values.  The conditional directives .if b and
    .if nb can be used within the macro to detect missing arguments.
    The number of arguments can be determined using the .narg direc-
    tive.

    Creating Local Symbols Automatically

       A  label is often required in an expanded macro.  In the con-
    ventional macro facilituies thus far described, a label must  be
    explicitly  specified  as an argument with each macro call.  The
    user must be careful in issuing subsequent  calls  to  the  same
    macro  in  order  avoid duplicating labels.  This concern can be
    eliminated through a feature of the ASxxxx macro  facility  that
    creates a unique symbol where a label is required in an expanded
    macro.

       ASxxxx  allows temporary symbols of the form n$, where n is a
    decimal integer.  Automatically created symbols are  created  in
    numerical order beginning at 10000$.

       The  automatic generation of local symbols is invoked on each
    call of a macro whose definition contains a dummy argument  pre-
    ceded  by the question mark (?) character, as shown in the macro
    definition below:

            .macro  beta    a,?b    ;dummy argument b with ?
            tst     a
            beq     b
            add     #5,a
    b:
            .endm

       A  local symbol is created automatically only when a real ar-
    gument of the macro call is either null or missing, as shown  in
    Example 1 below.  If the real argument is specified in the macro
    call, however, generation of the local symbol is  inhibited  and
    normal argument replacement occurs, as shown in Example 2 below.
    (Examples 1 and 2 are both expansions of the beta macro  defined
    above.)

    Example 1:  Create a Local Symbol for the Missing Argument

            beta    flag    ;Second argument is missing.
            tst     flag
            beq     10000$  ;Local symbol is created.
            add     #5,flag
    10000$:

    Example 2:  Do Not Create a Local Symbol

            beta    r3,xyz
            tst     r3
            beq     xyz
            add     #5,r3
    xyz:

       Automatically created local symbols resulting from the expan-
    sion of a macro, as described above, do not  establish  a  local
    symbol block in their own right.

       When  a  macro  has several arguments earmarked for automatic
    local symbol generation, substituting a specific label  for  one
    such  argument  risks  assembly errors because the arguments are
    constructed at the point of macro invocation.  Therefor, the ap-
    pearance of a label in the macro expansion will create a new lo-
    cal symbol block.  The new local symbol block could leave  local
    symbol references in the previous block and their symbol defini-
    tions in the new one, causing error codes in the assembly  list-
    ing.   Furthermore  a  later  macro expansion that creates local
    symbols in the new block may duplicate one  of  the  symbols  in
    question,  causing  an additional error code 'p' in the assembly
    listing.

    Concatenation of Macro Arguments

       The  apostrophe  or  single quote character (') operates as a
    legal delimiting character in macro definitions.  A single quote
    that precedes and/or follows a dummy argument in a macro defini-
    tion is removed, and the substitution of the real  argument  oc-
    curs at that point.  For example, in the following statements:

            .macro  def     A,B,C
    A'B:    asciz   "C"
            .byte   ''A,''B
            .endm

    when the macro def is called through the statement:

            def     x,y,^/V05.00/

    it is expanded, as follows:

    xy:     asciz   "V05.00"
            .byte   'x,'y

    In  expanding  the  first  line, the scan for the first argument
    terminates upon finding  the  first  apostrophe  (')  character.
    Since  A is a dummy argument, the apostrphe (') is removed.  The
    scan then resumes with B;  B is also noted as another dummy  ar-
    gument.   The  two  real  arguments x and y are then concated to
    form the label xy:.  The third dummy argument is  noted  in  the
    operand field of the .asciz directive, causing the real argument
    V05.00 to be substituted in this field.

       When  evaluating  the arguments of the .byte directive during
    expansion of the second line, the scan  begins  with  the  first
    apostrophe (') character.  Since it is neither preceded nor fol-
    lowed by a dummy argument, this apostrophe remains in the  macro
    expansion.   The  scan  then  encounters  the second apostrophe,
    which is followed by a dummy argument and is therefor discarded.
    The scan of argument A is terminated upon encountering the comma
    (,).  The third apostrophe is neither preceded nor followed by a
    dummy  argument  and  again remains in the macro expansion.  The
    fourth (and last) apostrophe is followed by another dummy  argu-
    ment and is likewise discarded.  (Four apostrophe (') characters
    were necessary in the macro definition  to  generate  two  apos-
    trophe (') characters in the macro expansion.)

##### => Section Index

### Macro Attribute Directives

####

       The  ASxxxx  assemblers  have  four directives that allow the
    user to determine certain attributes of macro arguments:  .narg,
    .nchr,  .ntyp,  and  .nval.  The use of these directives permits
    selective modifications of a macro expansion, depending  on  the
    nature  of  the  arguments  being  passed.  These directives are
    described below.

####

    .narg Directive

    Format:

    [label:]        .narg   symbol

    where:  label   represents an optional statement label.

            symbol  represents any legal symbol. This symbol
                    is equated to the number of arguments in
                    the macro call currently being expanded.
                    If a symbol is not specified, the .narg
                    directive is flagged with a 'q' error.

    The .narg directive is used to determine the number of arguments
    in the macro call currently being expanded.   Hence,  the  .narg
    directive  can appear only within a macro definition;  if it ap-
    pears elsewhere, an 'n' error is generated.

       The  argument  count  includes null arguments as shown in the
    following:

            .macro  pack    A,B,C
            .narg   cnt
              .
              .
              .
            .endm

            pack    arg1,,arg3
            pack    arg1

    When  the  first macro pack is invoked .narg will assign a value
    of three (3) to the number of arguments cnt, which includes  the
    empty  argument.  The second invocation of macro pack has only a
    single argument specified and .narg will assign a value  of  one
    (1) to cnt.

##### => Section Index

####

    .nchr Directive

    Format:

    [label:]        .nchr   symbol,string

    where:  label   represents an optional statement label.

            symbol  represents any legal symbol. This symbol
                    is equated to the number of characters in
                    the string of the macro call currently
                    being expanded.  If a symbol is not
                    specified, the .nchr  directive is
                    flagged with a 'q' error.

            ,       represents any legal separator (comma,
                    space, and/or tab).

            string  represents a string of printable 7-bit
                    ascii characters.  If the character
                    string contains a legal separator
                    (comma, space and/or tab) the whole
                    string must be delimited using the
                    up-arrow (^) construct ^/    /.
                    If the delimiting characters do not
                    match or if the ending delimiter
                    cannot be detected because of a
                    syntactical error in the character
                    string, the .nchr directive reports
                    a 'q' error.

    The .nchr directive, which can appear anywhere in an ASxxxx pro-
    gram, is used to determine the number of characters in a  speci-
    fied  character string.  This directive is useful in calculating
    the length of macro arguments.

##### => Section Index

####

    .ntyp Directive

    Format:

    [label:]        .ntyp   symbol,arg

    where:  label   represents an optional statement label.

            symbol  represents any legal symbol. The symbol
                    is made absolute and equated to 0 if
                    arg is an absolute value or a non
                    relocatable symbol.  The symbol is made
                    absolute and equated to 1 if arg is a
                    relocatable symbol.  If a symbol is not
                    specified then the .ntyp directive is
                    flagged with a 'q' error.

            ,       represents any legal separator (comma,
                    space, and/or tab).

            arg     represents any legal expression or
                    symbol. If arg is not specified
                    then the .ntyp directive is flagged
                    with a 'q' error.

    The .ntyp directive, which can appear anywhere in an ASxxxx pro-
    gram, is used to determine the symbol or expression type as  ab-
    solute (0) or relocatable (1).

##### => Section Index

####

    .nval Directive

    Format:

    [label:]        .nval   symbol,arg

    where:  label   represents an optional statement label.

            symbol  represents any legal symbol. The symbol
                    is equated to the value of arg and made
                    absolute.  If a symbol is not specified
                    then the .nval directive is flagged
                    with a 'q' error.

            ,       represents any legal separator (comma,
                    space, and/or tab).

            arg     represents any legal expression or
                    symbol. If arg is not specified
                    then the .nval directive is flagged
                    with a 'q' error.

    The .nval directive, which can appear anywhere in an ASxxxx pro-
    gram, is used to determine the value of arg and make the  result
    an absolute value.

##### => Section Index

### Indefinite Repeat Block Directives

####

       An  indefinite  repeat block is similar to a macro definition
    with only one dummy argument.  At each expansion  of  the  inde-
    finite  repeat  range, this dummy argument is replaced with suc-
    cessive elements of a real  argument  list.   Since  the  repeat
    directive  and its associated range are coded in-line within the
    source program, this type of macro definition and expansion does
    not require calling the macro by name, as required in the expan-
    sion of the conventional macros previously described.

       An  indefinite  repeat  block  can  appear  within or outside
    another macro definition, indefinite  repeat  block,  or  repeat
    block.   The  rules specifying indefinite repeat block arguments
    are the same as for specifying macro arguments.

    .irp Directive

    Format:

        [label:]    .irp    sym,argument_list
                    .
                    .
                (range of indefinite repeat block)
                    .
                    .
                    .endm

    where:  label   represents an optional statement label.

            sym     represents a dummy argument that is
                    replaced with successive real arguments
                    from the argument list.  If the dummy
                    argument is not specified, the .irp
                    directive is flagged with a 'q' error.

            ,       represents any legal separator (comma,
                    space, and/or tab).

      argument_list represents a list of real arguments
                    that are to be used in the expansion
                    of the indefinite repeat range. A real
                    argument may consist of one or more
                    7-bit ascii characters; multiple
                    arguments must be separated by any
                    legal separator (comma, space, and/or
                    tab).  If an argument must contain
                    a legal separator then the up-arrow
                    (_^) construct is require for that
                    argument.  If no real arguments are
                    specified, no action is taken.

            range   represents the block of code to be
                    repeated once for each occurrence of
                    a real argument in the list.  The
                    range may contain other macro
                    definitions, repeat ranges and/or
                    the .mexit directive.

            .endm   indicates the end of the indefinite
                    repeat block range.

    The .irp directive is used to replace a dummy argument with suc-
    cessive real arguments specified  in  an  argument  list.   This
    replacement  process  occurrs  during  the expansion of an inde-
    finite repeat block range.

##### => Section Index

####

    .irpc Directive

    Format:

        [label:]    .irpc   sym,string
                    .
                    .
                (range of indefinite repeat block)
                    .
                    .
                    .endm

    where:  label   represents an optional statement label.

            sym     represents a dummy argument that is
                    replaced with successive real characters
                    from the argument string.  If the dummy
                    argument is not specified, the .irpc
                    directive is flagged with a 'q' error.

            ,       represents any legal separator (comma,
                    space, and/or tab).

            string  represents a list of 7-bit ascii
                    characters.  If the string contains
                    legal separator characters (comma,
                    space, and/or tab) then the up-arrow
                    (_^) construct must delimit the string.

            range   represents the block of code to be
                    repeated once for each occurrence of
                    a real argument in the list.  The
                    range may contain other macro
                    definitions, repeat ranges and/or
                    the .mexit directive.

            .endm   indicates the end of the indefinite
                    repeat block range.

    The .irpc directive is available to permit single character sub-
    stition.  On each iteration of the indefinite repeat range,  the
    dummy  argument  is  replaced  with successive characters in the
    specified string.

##### => Section Index

### Repeat Block Directive

####

       A repeat block is similar to a macro definition with only one
    argument.  The argument specifies the number of times the repeat
    block  is  inserted  into the assembly stream.  Since the repeat
    directive and its associated range are coded in-line within  the
    source program, this type of macro definition and expansion does
    not require calling the macro by name, as required in the expan-
    sion of the conventional macros previously described.

       A repeat block can appear within or outside another macro de-
    finition, indefinite repeat block, or repeat block.

    .rept Directive

    Format:

        [label:]    .rept   exp
                    .
                    .
                (range of repeat block)
                    .
                    .
                    .endm

    where:  label   represents an optional statement label.

            exp     represents any legal expression.
                    This value controls the number of
                    times the block of code is to be assembled
                    within the program.  When the expression
                    value is less than or equal to zero (0),
                    the repeat block is not assembled.  If
                    this value is not an absolute value, the
                    .rept directive is flagged with an 'r'
                    error.

            range   represents the block of code to be
                    repeated. The range may contain other
                    macro definitions, repeat ranges and/or
                    the .mexit directive.

            .endm   indicates the end of the repeat block
                    range.

    The .rept directive is used to duplicate a block of code, a cer-
    tain number of times, in line with other source code.

##### => Section Index

### Macro Deletion Directive

####

       The  .mdelete  directive  deletes  the definitions of the the
    specified macro(s).

    .mdelete Directive

    Format:

            .mdelete        name1,name2,...,namen

    where:  name1,  represent legal macro names. When multiple
            name2,  names are specified, they are separated
            ...,    by any legal separator (comma, space, and/or
            namen   tab).

##### => Section Index

### Macro Invocation Details

####

       The invocation of a macro, indefinite repeat block, or repeat
    block has specific implications for .if-.else-.endif  constructs
    and for .list-.nlist directives.

       At  the  point  a  macro,  indefinite repeat block, or repeat
    block is called the following occurs:

            1)      The initial .if-.else-.endif
                    state is saved.

            2)      The initial .list-.nlist
                    state is saved.

            3)      The macro, indefinite repeat block,
                    or repeat block is inserted into the
                    assembler source code stream.  All
                    argument substitution is performed
                    at this point.

    When  the  macro  completes and after each pass through an inde-
    finite repeat block or repeat  block  the  .if-.else-.endif  and
    .list-.nlist state is reset to the initial state.

       The  reset of the .if-.else-.endif state means that the invo-
    cation of a macro, indefinite repeat block, or repeat block can-
    not  change the .if-.else-.endif state of the calling code.  For
    example the following code does not change the  .if-.else-.endif
    condition at macro completion:

            .macro  fnc     A
              .if nb,^!A!
                ...
                .list (meb)
                .mexit
              .else
                ...
                .nlist
                .mexit
              .endif
            .endm

    code:   fnc

       Within the macro the .if condition becomes false but the con-
    dition is not propagated outside the macro.

       Similarly,  when  the  .list-.nlist state is changed within a
    macro the change is not propogated outside the macro.

       The  normal  .if-.else-.endif  processing verifies that every
    .if has a corresponding .endif.  When a macro, indefinite repeat
    block,  or repeat block terminates by using the .mexit directive
    the .if-.endif checking is bypassed  because  all  source  lines
    between the .mexit and .endm directives are skipped.

##### => Section Index

### Building a Macro Library

####

       Using  the macro facilities of the ASxxxx assemblers a simple
    macro library can be built.  The macro library is built by  com-
    bining individual macros, sets of macros, or include file direc-
    tives into a single file.  Each macro entity is enclosed  within
    a .if/.endif block that selects the desired macro definitions.

       The  selection of specific macros to be imported in a program
    is performed by three macros, .mlib, .mcall,  and  .mload,  con-
    tained in the file mlib.def.

    .mlib Macro Directive

    Format:

            .mlib   file

    where:  file    represents the macro library file name.
                    If the file name does not include a path
                    then the path of the current assembly
                    file is used.  If the file name (and/or
                    path) contains white space then the
                    path/name must be delimited with the
                    up-arrow (^) construct ^/    /.

    The .mlib directive defines two macros, .mcall and .mload, which
    when invoked will read a file, importing specific macro  defini-
    tions.   Any  previous  .mcall  and/or .mload directives will be
    deleted before the new .mcall and .mload directives are defined.

       The  .mload  directive  is an internal directive which simply
    includes the macro library file with the listing disabled.

       The  following  is the mlib.def file which defines the macros
    .mlib, .mcall, and .mload.

    ;************************************************
    ;*                                              *
    ;*    A simple Macro Library Implementation     *
    ;*                                              *
    ;*              December 2008                   *
    ;*                                              *
    ;************************************************

    .macro .mlib    FileName
      .if b,^!FileName!
        .error 1    ; File Name Required
        .mexit
      .endif
      .mdelete      .mcall
      .macro        .mcall  a,b,c,d,e,f,g,h
        .irp sym    ^!a!,^!b!,^!c!,^!d!,^!e!,^!f!,^!g!,^!h!
          .iif nb,^!sym!    .define    .$$.'sym
        .endm
        .mload
        .irp sym    ^!a!,^!b!,^!c!,^!d!,^!e!,^!f!,^!g!,^!h!
          .if nb,^!sym!
            .iif ndef,sym'.$$.    .error  1  ; macro not found
            .undefine       .$$.'sym
            .undefine       sym'.$$.
          .endif
        .endm
      .endm ;.mcall
      .mdelete      .mload
      .macro        .mload
        .nlist
        .include ^!FileName!
        .list
      .endm ;.mload
    .endm   ;.mlib

    .mcall Macro Directive

    Format:

            .mcall  macro1,macro2,...,macro8

    where:

            macro1, represents from 1 to 8 macro library
            macro2, references to a macro definition or
            ...,    set of macro definitions included in
            macro8  the file specified with the .mlib macro.

    As  can  be  seen  from the macro definition of .mlib and .mcall
    shown above,  when  .mcall  is  invoked  temporary  symbols  are
    defined for each macro or macro set that is to be imported.  The
    macro .mload is then invoked to  load  the  macro  library  file
    specified in the call to .mlib.

       For example, when the following macros are invoked:

            .mlib   crossasm.sml    ; Cross Assembler Macros
            .mcall  M6809           ; M6809 Macro Group

    The  .mlib  macro  defines the .mload macro to access the system
    macro file crossasm.sml.  Invoking the .mcall  macro  creates  a
    temporary symbol, '.$$.M6809', and then invokes the macro .mload
    to import the system macro file crossasm.sml.   The  file  cros-
    sasm.sml  contains  conditional  statements  that define the re-
    quired macros and creates  a  temporary  symbol  'M6809.$$.'  to
    indicate  the  macro group was found.  If the macro is not found
    an error message is generated.

       The  following  is a small portion of the crossasm.sml system
    macro file which shows the M6809 macro group:

            .title  Cross Assembler Macro Library

            ; This MACRO Library is Case Insensitive.
            ;

            ...

    ; Macro Based 6809 Cross Assembler

    .$.SML.$. =: 0
    .if     idn     a,A
      .iif  def,.$$.m6809   .$.SML.$. = -1
    .else
      .iif  def,.$$.m6809   .$.SML.$. = -1
      .iif  def,.$$.M6809   .$.SML.$. =  1
    .endif
    .iif    lt,.$.SML.$.    .define         m6809.$$.
    .iif    gt,.$.SML.$.    .define         M6809.$$.
    .iif    ne,.$.SML.$.    .include        "m6809.mac"

            ...

##### => Section Index

### Example Macro Cross Assemblers

####

       The  'ascheck'  subdirectory 'macroasm' contains 7 assemblers
    written using only the general macro processing facility of  the
    ASxxxx assemblers:

            i8085.mac       -  8085 Microprocessor
            m6800.mac       -  6800 Microprocessor
            m6801.mac       -  6801 Microprocessor
            m6804.mac       -  6804 Microprocessor
            m6805.mac       -  6805 Microprocessor
            m6809.mac       -  6809 Microprocessor
            s2650.mac       -  2650 Microprocessor

       These  absolute  macro  cross  assemblers are included to il-
    lustrate the  functionality  of  the  general  macro  processing
    facility  of  the ASxxxx assemblers.  In general they are useful
    examples of actual macro implementations.

##### => Section Index

####

... Exit the ASxxxx Documentation

... Home Page

######

Last Updated: April 2009