UNIT IV

MACROPROCESSORS

A Macro represents a commonly used group of statements in the source programming

language.

 A macro instruction (macro) is a notational convenience for the programmer

o It allows the programmer to write shorthand version of a program
(module programming)
 The macro processor replaces each macro instruction with the corresponding
group of source language statements (expanding)
o Normally, it performs no analysis of the text it handles.
o It does not concern the meaning of the involved statements during macro
expansion.
 The design of a macro processor generally is machine independent!
 Two new assembler directives are used in macro definition
o MACRO: identify the beginning of a macro definition
o MEND: identify the end of a macro definition
 Prototype for the macro
o Each parameter begins with ‘&’

 name MACRO parameters

:

body

MEND

o Body: the statements that will be generated as the expansion of the macro.

4.1 Basic Macro Processor Functions:

 Macro Definition and Expansion

 Macro Processor Algorithms and Data structures

4.1.1 Macro Definition and Expansion:

The figure shows the MACRO expansion. The left block shows the MACRO
definition and the right block shows the expanded macro replacing the MACRO call
with its block of executable instruction.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 1

 M1 is a macro with two parameters D1 and D2. The MACRO stores the
contents of register A in D1 and the contents of register B in D2. Later M1 is invoked
with the parameters DATA1 and DATA2, Second time with DATA4 and DATA3.
Every call of MACRO is expended with the executable statements.

Fig 4.1

The statement M1 DATA1, DATA2 is a macro invocation statements that gives the
name of the macro instruction being invoked and the arguments (M1 and M2) to be
used in expanding. A macro invocation is referred as a Macro Call or Invocation.

Macro Expansion:

The program with macros is supplied to the macro processor. Each macro
invocation statement will be expanded into the statements that form the body of the
macro, with the arguments from the macro invocation substituted for the parameters in
the macro prototype. During the expansion, the macro definition statements are
deleted since they are no longer needed.

The arguments and the parameters are associated with one another according to
their positions. The first argument in the macro matches with the first parameter in the
macro prototype and so on.

After macro processing the expanded file can become the input for the
Assembler. The Macro Invocation statement is considered as comments and the
statement generated from expansion is treated exactly as though they had been written
directly by the programmer.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 2

 The difference between Macros and Subroutines is that the statement s from the
body of the Macro is expanded the number of times the macro invocation is
encountered, whereas the statement of the subroutine appears only once no matter how
many times the subroutine is called. Macro instructions will be written so that the body
of the macro contains no labels.

 Problem of the label in the body of macro:

o If the same macro is expanded multiple times at different places in the
program …
o There will be duplicate labels, which will be treated as errors by the
assembler.
 Solutions:
o Do not use labels in the body of macro.
o Explicitly use PC-relative addressing instead.
 Ex, in RDBUFF and WRBUFF macros,
o JEQ *+11
o JLT *-14
 It is inconvenient and error-prone.

The following program shows the concept of Macro Invocation and Macro
Expansion.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 3

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 4
4.1.2 Macro Processor Algorithm and Data Structure:

Design can be done as two-pass or a one-pass macro. In case of two-pass

assembler.

Two-pass macro processor

 You may design a two-pass macro processor

o Pass 1:
 Process all macro definitions
o Pass 2:
 Expand all macro invocation statements

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 5

  However, one-pass may be enough
o Because all macros would have to be defined during the first pass before
any macro invocations were expanded.
 The definition of a macro must appear before any statements that
invoke that macro.
 Moreover, the body of one macro can contain definitions of the other macro
 Consider the example of a Macro defining another Macro.
 In the example below, the body of the first Macro (MACROS) contains
statement that define RDBUFF, WRBUFF and other macro instructions for SIC
machine.
 The body of the second Macro (MACROX) defines the same macros for
SIC/XE machine.
 A proper invocation would make the same program to perform macro invocation
to run on either SIC or SIC/XE machine.
MACROS for SIC machine

Fig 4.3(a)

MACROX for SIC/XE Machine

Fig 4.3(b)
SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 6
  A program that is to be run on SIC system could invoke MACROS whereas a
program to be run on SIC/XE can invoke MACROX.
 However, defining MACROS or MACROX does not define RDBUFF and
WRBUFF.
 These definitions are processed only when an invocation of MACROS or
MACROX is expanded.

One-Pass Macro Processor:

 A one-pass macro processor that alternate between macro definition and macro
expansion in a recursive way is able to handle recursive macro definition.

 Restriction
o The definition of a macro must appear in the source program before any
statements that invoke that macro.
o This restriction does not create any real inconvenience.

The design considered is for one-pass assembler. The data structures required are:

 DEFTAB (Definition Table)

o Stores the macro definition including macro prototype
and macro body
o Comment lines are omitted.
o References to the macro instruction parameters are converted to a
positional notation for efficiency in substituting arguments.
 NAMTAB (Name Table)
o Stores macro names
o Serves as an index to DEFTAB
 Pointers to the beginning and the end of the macro definition
(DEFTAB)

ARGTAB (Argument Table)

o Stores the arguments according to their positions in the argument list.

o As the macro is expanded the arguments from the Argument table are
substituted for the corresponding parameters in the macro body.
o The figure below shows the different data structures described and their
relationship.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 7

 Fig 4.4

The above figure shows the portion of the contents of the table during the processing
of the program in page no. 3. In fig 4.4(a) definition of RDBUFF is stored in
DEFTAB, with an entry in NAMTAB having the pointers to the beginning and the end
of the definition. The arguments referred by the instructions are denoted by their
positional notations. For example,

TD =X’?1’

The above instruction is to test the availability of the device whose number is given by
the parameter &INDEV. In the instruction this is replaced by its positional value? 1.

Figure 4.4(b) shows the ARTAB as it would appear during expansion of the RDBUFF
statement as given below:

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 8

 CLOOP RDBUFF F1, BUFFER, LENGTH

For the invocation of the macro RDBUFF, the first parameter is F1 (input device
code), second is BUFFER (indicating the address where the characters read are stored),
and the third is LENGTH (which indicates total length of the record to be read). When
the ?n notation is encountered in a line fro DEFTAB, a simple indexing operation
supplies the proper argument from ARGTAB.

The algorithm of the Macro processor is given below. This has the procedure DEFINE
to make the entry of macro name in the NAMTAB, Macro Prototype in DEFTAB.
EXPAND is called to set up the argument values in ARGTAB and expand a Macro
Invocation statement. Procedure GETLINE is called to get the next line to be
processed either from the DEFTAB or from the file itself.

When a macro definition is encountered it is entered in the DEFTAB. The

normal approach is to continue entering till MEND is encountered. If there is a
program having a Macro defined within another Macro. While defining in the
DEFTAB the very first MEND is taken as the end of the Macro definition. This does
not complete the definition as there is another outer Macro which completes the
difintion of Macro as a whole. Therefore the DEFINE procedure keeps a counter
variable LEVEL. Every time a Macro directive is encountered this counter is
incremented by 1. The moment the innermost Macro ends indicated by the directive
MEND it starts decreasing the value of the counter variable by one. The last MEND
should make the counter value set to zero. So when LEVEL becomes zero, the MEND
corresponds to the original MACRO directive.

Most macro processors allow thr definitions of the commonly used instructions
to appear in a standard system library, rather than in the source program. This makes
the use of macros convenient; definitions are retrieved from the library as they are
needed during macro processing.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 9

Algorithms

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 10

4.1.3 Comparison of Macro Processor Design

 One-pass algorithm
o Every macro must be defined before it is called
o One-pass processor can alternate between macro definition and macro
expansion
o Nested macro definitions are allowed but nested calls are not allowed.
 Two-pass algorithm
o Pass1: Recognize macro definitions
o Pass2: Recognize macro calls
o Nested macro definitions are not allowed

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 11

4.2 Machine-independent Macro-Processor Features.

The design of macro processor doesn’t depend on the architecture of the

machine. We will be studying some extended feature for this macro processor. These
features are:

 Concatenation of Macro Parameters

 Generation of unique labels
 Conditional Macro Expansion
 Keyword Macro Parameters

4.2.1 Concatenation of Macro Parameters:

Most macro processor allows parameters to be concatenated with other character

strings. Suppose that a program contains a series of variables named by the symbols
XA1, XA2, XA3,…, another series of variables named XB1, XB2, XB3,…, etc. If
similar processing is to be performed on each series of labels, the programmer might
put this as a macro instruction. The parameter to such a macro instruction could
specify the series of variables to be operated on (A, B, etc.). The macro processor
would use this parameter to construct the symbols required in the macro expansion
(XA1, Xb1, etc.).

Suppose that the parameter to such a macro instruction is named &ID. The body
of the macro definition might contain a statement like

LDA X&ID1

Fig 4.7

& is the starting character of the macro instruction; but the end of the parameter is not
marked. So in the case of &ID1, the macro processor could deduce the meaning that

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 12

was intended. If the macro definition contains contain &ID and &ID1 as parameters,
the situation would be unavoidably ambiguous.

Most of the macro processors deal with this problem by providing a special
concatenation operator. In the SIC macro language, this operator is the character .
Thus the statement LDA X&ID1 can be written as

LDA X&ID1

Fig 4.8

The above figure shows a macro definition that uses the concatenation operator
as previously described. The statement SUM A and SUM BETA shows the
invocation statements and the corresponding macro expansion.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 13

4.2.2 Generation of Unique Labels

As discussed it is not possible to use labels for the instructions in the macro
definition, since every expansion of macro would include the label repeatedly which is
not allowed by the assembler. This in turn forces us to use relative addressing in the
jump instructions. Instead we can use the technique of generating unique labels for
every macro invocation and expansion. During macro expansion each $ will be
replaced with $XX, where xx is a two-character alphanumeric counter of the number
of macro instructions expansion.

For example,

XX = AA, AB, AC…

This allows 1296 macro expansions in a single program.

The following program shows the macro definition with labels to the instruction.

The following figure shows the macro invocation and expansion first time.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 14

 If the macro is invoked second time the labels may be expanded as $ABLOOP
$ABEXIT.

4.2.3 Conditional Macro Expansion

There are applications of macro processors that are not related to assemblers or
assembler programming.

Conditional assembly depends on parameters provides

MACRO &COND

……..

IF (&COND NE ‘’)

part I

ELSE

part II

ENDIF

………

ENDM

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 15

Part I is expanded if condition part is true, otherwise part II is expanded. Compare
operators: NE, EQ, LE, GT.

Macro-Time Variables:

Macro-time variables (often called as SET Symbol) can be used to store

working values during the macro expansion. Any symbol that begins with symbol &
and not a macro instruction parameter is considered as macro-time variable. All such
variables are initialized to zero.

Fig 4.9(a)

Figure 4.5(a) gives the definition of the macro RDBUFF with the parameters
&INDEV, &BUFADR, &RECLTH, &EOR, &MAXLTH. According to the above
program if &EOR has any value, then &EORCK is set to 1 by using the directive SET,
otherwise it retains its default value 0.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 16

???
If the value of this expression TRUE,

 The macro processor continues to process lines from the DEFTAB until it
encounters the ELSE or ENDIF statement.
 If an ELSE is found, macro processor skips lines in DEFTAB until the next
ENDIF.
 Once it reaches ENDIF, it resumes expanding the macro in the usual way.
If the value of the expression is FALSE,

 The macro processor skips ahead in DEFTAB until it encounters next ELSE or
ENDIF statement.
 The macro processor then resumes normal macro expansion.

The macro-time IF-ELSE-ENDIF structure provides a mechanism for either

generating(once) or skipping selected statements in the macro body. There is another
construct WHILE statement which specifies that the following line until the next
ENDW statement, are to be generated repeatedly as long as a particular condition is
true. The testing of this condition, and the looping are done during the macro is under
expansion. The example shown below shows the usage of Macro-Time Looping
statement.

WHILE-ENDW structure

 When a WHILE statement is encountered during the expansion of a macro, the

specified Boolean expression is evaluated.
 TRUE
o The macro processor continues to process lines from DEFTAB until it
encounters the next ENDW statement.
o When ENDW is encountered, the macro processor returns to the
preceding WHILE, re-evaluates the Boolean expression, and takes action
based on the new value.
 FALSE
o The macro processor skips ahead in DEFTAB until it finds the next
ENDW statement and then resumes normal macro expansion.

Keyword Macro Parameters

All the macro instruction definitions used positional parameters. Parameters and
arguments are matched according to their positions in the macro prototype and the
macro invocation statement.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 17

The programmer needs to be careful while specifying the arguments. If an argument is
to be omitted the macro invocation statement must contain a null argument mentioned
with two commas.

Positional parameters are suitable for the macro invocation. But if the macro
invocation has large number of parameters, and if only few of the values need to be
used in a typical invocation, a different type of parameter specification is required (for
example, in many cases most of the parameters may have default values, and the
invocation may mention only the changes from the default values).

Ex:

 GENER has 10 possible parameters, but in a particular invocation of the macro,

only the third and the ninth parameters are to be specified.

 If positional parameters were used, the macro invocation statement might look
like

GENER , , DIRECT, , , , , 3 ,

 Using a different form of parameter specification, called keyword parameters,

each argument value is written with a keyword that names the corresponding
parameter.

 If the third parameter is named as &TYPE and the ninth parameter is named
&CHANNEL, then the macro invocation statement would be

GENER TYPE=DIRECT, CHANNEL=3

 This statement is much easier to read and less error prone than the positional
version.
 Arguments any appear in any order.

SYSTEM PROGRAMMING, CHAPTER - 4, MACROPROCESSORS Page 18