UNIT – IV

MACRO PROCESSORS
 INTRODUCTION
⚫ A macro instruction (Macro) is a
notational convenience for the
programmer
◦ Allows the programmer to write
short hand programs (modular
programming).
⚫ The macro processor replaces each
macro instruction with its equivalent
block of instructions.
⚫ The macro processor is not concerned
with the meaning of the involved
statements during expansion.
⚫ The design of the macro processor is
generally machine independent.
BASIC MACRO PROCESSOR FUNCTIONS
⚫ Directives used during usage of Macro:
◦ Macro: Indicates begin of Macro
◦ MEND: indicates end of Macro
⚫ Prototype for Macro:
◦ Each argument starts with Name and macro

◦ Parameter list
● .
● .
● MEND

⚫ BODY: The statement will be generated as the

expansion of Macro
MACRO EXPANSION
BASIC MACRO PROCESSOR
FUNCTIONS
MACRO INVOCATION
⚫ A macro invocation statement (a macro
call) gives the name of the macro
instruction being invoked and the
arguments to be used in expanding the
macro.
◦ macro_name p1, p2, …
⚫ Difference between macro call and
procedure call
◦ Macro call: statements of the macro
body are expanded each time the macro
is invoked.
◦ Procedure call: statements of the
subroutine appear only one, regardless
 MACRO INVOCATION

⚫ Question
◦ How does a programmer decide
to use macro calls or procedure
calls?
● From the viewpoint of a
programmer
● From the viewpoint of the CPU
EXCHANGE THE VALUES OF TWO
VARIABLES
void exchange(int a, int b) {
int temp;
temp = a;
a = b;
b = temp;
}
main() {
int i=1, j=3;
printf("BEFORE - %d %d\n", i, j);
exchange(i, j);
printf("AFTER - %d %d\n", i, j);
}
What’s the result?
12 LINES OF ASSEMBLY CODE
SWAP TWO VARIABLES BY MACRO

#define swap(i,j) { int temp; temp=i; i=j;

j=temp; }

main() {
int i=1, j=3;
printf("BEFORE - %d %d\n", i, j);
swap(i,j);
printf("AFTER - %d %d\n", i, j);
}
BASIC MACRO PROCESSOR
FUNCTIONS
MAIN LDA #1
STA I
LDA #3
STA J
. Invoke a macro
LDA I
STA TEMP
LDA J
STA I
LDA TEMP
STA J
I RESW 1
J RESW 1
TEMP RESW 1
END MAIN
 MACRO EXPANSION

⚫ Each macro invocation statement

will be expanded into the
statements that form the body of
the macro.
⚫ Arguments from the macro
invocation are substituted for the
parameters in the macro prototype
(according to their positions).
◦ In the definition of macro:
parameter
MACRO EXPANSION
⚫ Comment lines within the macro
body will be deleted.
⚫ Macro invocation statement itself has
been included as a comment line.
⚫ The label on the macro invocation
statement has been retained as a
label on the first statement generated
in the macro expansion.
◦ We can use a macro instruction in
exactly the same
◦ way as an assembler language
mnemonic.
MACRO INVOCATION: A PROGRAM
MACRO EXPANSION: A PROGRAM
MACRO EXPANSION: A PROGRAM
MACRO EXPANSION: A PROGRAM
NO LABEL IN MACRO BODY

⚫ Problem of the label in the body of

macro:
◦ If the same macro is expanded
multiple times at different places in
the program …
◦ There will be duplicate labels,
which will be treated as errors by
the assembler.
⚫ Solutions:
◦ Do not use labels in the body of
macro.
◦ Explicitly use PC-relative
 TWO-PASS MACRO PROCESSOR

⚫ You may design a two-pass macro

processor
◦ Pass 1:
● Process all macro definitions
◦ Pass 2:
● Expand all macro invocation
statements
TWO-PASS MACRO PROCESSOR

⚫ However, one-pass may be enough

◦ 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 other
macros.
 EXAMPLE OF RECURSIVE MACRO
DEFINITION
⚫ MACROS (for SIC)
◦ Contains the definitions of
RDBUFF and WRBUFF written in
SIC instructions.
 RECURSIVE MACRO DEFINITION

⚫ MACROX (for SIC/XE)

◦ Contains the definitions of
RDBUFF and WRBUFF written in
SIC/XE instructions.
MACRO DEFINITION: AN EXAMPLE

⚫ 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
◦ The definition of a macro must appear
in the
◦ source program before any statements
that
◦ invoke that macro.
◦ This restriction does not create any real
◦ inconvenience.
 DATA STRUCTURE FOR ONE-PASS
MACRO PROCESSOR

⚫ DEFTAB (definition table)

◦ Stores the macro definition
including macro
◦ prototype and macro body
◦ Comment lines are omitted.
◦ References to the macro instruction
parameters are
◦ converted to a positional notation
for efficiency in
◦ substituting arguments.
 DATA STRUCTURE FOR ONE-PASS
MACRO PROCESSOR
⚫ ◦NAMTAB
Stores macro names
◦ Serves as an index to DEFTAB
◦ Pointers to the beginning and the
end of the
◦ macro definition (DEFTAB)
⚫ ARGTAB
◦ Stores the arguments of macro
invocation
◦ according to their positions in the
argument list
◦ As the macro is expanded,
arguments from
◦ ARGTAB are substituted for the
corresponding
◦ parameters in the macro body.
DATA STRUCTURE
 NEXT – AFTER A BREAK

⚫ Algorithms
⚫ Nested macros
⚫ Comparison of different macro
design
⚫ Machine-Independent macro
features
ALGORITHM
ALGORITHM
ALGORITHM
ALGORITHM
HANDLING NESTED MACRO
⚫ In DEFINE procedure
◦ When a macro definition is being
entered into
◦ DEFTAB, the normal approach is to
continue
◦ until an MEND directive is reached.
◦ This would not work for nested
macro definition because the first
MEND encountered in the inner
macro will terminate the whole
macro definition process.
HANDLING NESTED MACRO
⚫ To solve this problem, a counter
LEVEL is used to keep track of the
level of macro definitions.
◦ Increase LEVEL by 1 each time a
MACRO directive is read.
◦ Decrease LEVEL by 1 each time a
MEND directive is read.
◦ A MEND terminates the whole
macro definition process when
LEVEL reaches 0.
◦ This process is very much like
matching left and right parentheses
when scanning an arithmetic
expression.
 COMPARISON OF MACRO
PROCESSOR DESIGN
⚫ One-pass algorithm
⚫ Every macro must be defined
before it is called
⚫ One-pass processor can alternate
between macro definition and
macro expansion
⚫ Nested macro definitions are
allowed but nested calls are not
 COMPARISON OF MACRO
PROCESSOR DESIGN
⚫ Two-pass algorithm
◦ Pass1: Recognize macro
definitions
◦ Pass2: Recognize macro calls
◦ Nested macro definitions are not
allowed
MACHINE-INDEPENDENT MACRO
PROCESSOR FEATURES
 CONCATENATION OF MACRO
PARAMETERS
⚫ Concatenation parameters with
other character strings.
◦ Used when a program consists a
set of series of variables.
 COMPARISON OF MACRO
PROCESSOR DESIGN
⚫ Ambiguity problem
◦ If &ID and &ID1 are parameters

⚫ Solution to this ambiguity problem

◦ Use a special concatenation
operator “->” to specify the end of
the parameter
COMPARISON OF MACRO
PROCESSOR DESIGN
 GENERATING UNIQUE LABELS

⚫ Labels in the macro body may cause

“duplicate labels” problem if the
macro is invocated and expanded
multiple times. Ex:

• Use of relative addressing at the source statement

level is very inconvenient, error-prone, and difficult
to read.
GENERATING UNIQUE LABELS
⚫ Let the macro processor generate unique
⚫ labels for each macro invocation and
⚫ expansion.
◦ During macro expansion, the $ will be
replaced with
◦ $xx, where xx is a two-character
alphanumeric counter
◦ of the number of macro instructions
expanded.
◦ xx=AA,AB,AC,…..
● This allows 1296 macro expansions in
a single program.
GENERATION OF UNIQUE LABELS
GENERATION OF UNIQUE LABELS
 GENERATION OF UNIQUE LABELS

⚫ Conditional assembly depends on

parameters provided

⚫ Part I is expanded if condition part

is true, otherwise part II is
expanded
⚫ Compare operator: NE, EQ, LE, GT
GENERATION OF UNIQUE LABELS
⚫ Begins with “&” but is not a macro
instruction
⚫ parameter
⚫ Can be used to store working values
during
⚫ the macro expansion
◦ -Store the evaluation result of
Boolean expression
● -Control the macro-time conditional
structures
⚫ Be initialized to a value of 0
⚫ Be set by a macro processor directive, SET
● Ex: &EORCK SET 1
● &EORCTR SET &EORCTR + 1
GENERATION OF UNIQUE LABELS
GENERATION OF UNIQUE LABELS
GENERATION OF UNIQUE LABELS
GENERATION OF UNIQUE LABELS
MACRO-TIME LOOPING
WHILE ( cond )
……
ENDW

⚫ Macro processor function

◦ %NITEMS: The number of members
in an argument list

⚫ The execution of testing of IF/WHILE,

SET,
◦ - %NITEMS() occurs at macro
expansion time
USE OF MACRO-TIME LOOPING
STATEMENT
USE OF MACRO-TIME LOOPING
STATEMENT
IMPLEMENTATION-CONDITIONAL
MACRO EXPANSION
⚫ IF-ELSE-ENDIF structure
◦ The macro processor must
maintain a symbol table
● -This table contains the values of
all macro-time variables used.
● - Entries in this table are made or
modified when SET statements are
processed.
● - This table is used to look up the
current value of a macro-time
variable whenever it is required.
IMPLEMENTATION-CONDITIONAL
MACRO EXPANSION
⚫ When an IF statement is encountered
during the expansion of a macro, the
specified Boolean expression is
evaluated.
⚫ TRUE
◦ The macro processor continues to
process lines from DEFTAB until it
encounters the next ELSE or ENDIF
statement.
◦ If ELSE is encountered, then skips to
END
⚫ FALSE
◦ The macro processor skips ahead in
DEFTAB until it finds the next ELSE
or ENDIF statement.
IMPLEMENTATION-CONDITIONAL
MACRO EXPANSION
⚫ When an IF statement is encountered
during the expansion of a macro, the
specified Boolean expression is
evaluated.
● -TRUE
● The macro processor continues to
process lines from DEFTAB until it
encounters the next ENDW
statement.
● 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.
 IMPLEMENTATION-CONDITIONAL
MACRO EXPANSION
⚫ FALSE
◦ -- The macro processor skips
ahead in DEFTAB until it finds
the next ENDW statement and
then resumes normal macro
expansion.
 SUMMARY

⚫ Algorithms
⚫ Nested macros
⚫ Comparison of different macro
design
⚫ Machine-Independent macro
features
⚫ Implementation of conditional
macros
 NEXT – AFTER A BREAK

⚫ Keyword macro parameters

⚫ Recursive Macros
⚫ Line-by-Line Macros
⚫ Integrated Macros
USE OF MACRO-TIME LOOPING
STATEMENT
IMPLEMENTATION-CONDITIONAL
MACRO EXPANSION
⚫ IF-ELSE-ENDIF structure
◦ The macro processor must
maintain a symbol
◦ table
● Entries in this table are made or
modified when SET statements are
processed.
● This table is used to look up the
current value of a macro-time
variable whenever it is required.
● This table contains the values of
all macro-time variables used.
IMPLEMENTATION-CONDITIONAL
MACRO EXPANSION
⚫ When an IF statement is encountered during
the expansion of a macro, the specified
Boolean expression is evaluated.
◦ TRUE
● The macro processor continues to
process lines from DEFTAB
until it encounters the next ELSE or
ENDIF statement.
● If ELSE is encountered, then skips to
ENDIF
◦ FALSE
● The macro processor skips ahead in
DEFTAB until it finds the next
● ELSE or ENDIF statement.
 IMPLEMENTATION-CONDITIONAL
MACRO EXPANSION
⚫ WHILE-ENDW structure
◦ When an WHILE statement is encountered
during the expansion of a macro, the
specified Boolean expression is evaluated.
◦ TRUE
● -- The macro processor continues to
process lines from DEFTAB until it
encounters the next ENDW statement.

● -- 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.
IMPLEMENTATION-CONDITIONAL
MACRO EXPANSION
⚫ FALSE
◦ -- The macro processor skips
ahead in DEFTAB until it finds the
next ENDW statement and then
resumes normal macro
expansion.
KEYWORD MACRO PARAMETERS

⚫ Keyword macro parameters

◦ Positional parameters and
arguments are associated
according to their positions in the
macro prototype and invocation.
◦ If an argument is to be omitted, a
null argument should be used to
maintain the proper order in macro
invocation:
◦ Ex: XXX MACRO &P1, &P2, ….,
&P20, ….
XXX A1, A2,,,,,,,,,,…,,A20,…..
 KEYWORD MACRO PARAMETERS

⚫ It is not suitable if a macro has a

large number of parameters, and
only a few of these are given
values in a typical invocation.
 KEYWORD MACRO PARAMETERS

⚫ Keyword Parameters
◦ Each argument is written with
the keyword that names the
corresponding parameter.
◦ Argument may appear any order.
◦ Null arguments are no longer
required to be used.
◦ It is easier, less error prone and
readable form to have keyword
parameter than positional
parameter.
 KEYWORD MACRO PARAMETERS

⚫ Keyword Parameters
◦ Each argument is written with
the keyword that names the
corresponding parameter.
◦ Argument may appear any order.
◦ Null arguments are no longer
required to be used.
◦ It is easier, less error prone and
readable form to have keyword
parameter than positional
parameter.
● Ex P1=A1, P2=A2, … P20=A20
USE OF KEYWORD MACRO
PARAMETERS
USE OF KEYWORD PARAMETERS
IN MACRO
USE OF KEYWORD PARAMETERS
IN MACRO
RECURSIVE MACRO EXPANSION
RECURSIVE MACRO EXPANSION
PROBLEM OF RECURSIVE MACRO
PARAMETERS
⚫ Previous Macro Design Doesn’t take
care
⚫ of recursive macro expansion.
◦ Problems:
● When procedure EXPAND is called
recursively the invocation
argument in the ARGTAB will be
overwritten.
● The boolean variable Expand
would set to false when the inner
macro expansion is completed
without having an idea that the it
is part of another outer macro
whose expansion is still not
PROBLEM OF RECURSIVE MACRO
PARAMETERS
⚫ Previous Macro Design Doesn’t take care
⚫ of recursive macro expansion.
◦ Solutions:
● Write the macro processor in a
programming language which
automatically takes care of the
recursive calls thus retaining the local
variables.
● If written in a language without
recursion support, use a stack to take
care of pushing and popping the local
variables and return addresses thus
retaining their values.
GENERAL PURPOSE MACRO
PROCESSORS
◦ Macro processor that do not depend
on any particular language, can be
used with variety of languages.
◦ Pros
● Programmers do not need not
learn any macro language.
● Although its development costs is
little high than those for the
language specific macro processor,
but these macros does not need to
be repeated for every language.
GENERAL PURPOSE MACRO
PROCESSORS
◦ Macro processor that do not depend on any
particular language, can be used with
variety of languages.
◦ Cons
● Large number of details must be dealt
within a programming language.
● Situations in which normal macro
parameter substitution should not occur,
e.g., comments.
● Facilities for grouping together terms,
expressions, or statements
● Tokens, e.g., identifiers, constants,
operators, keywords.
● Syntax must be consistent with the
programming language.
MACRO PROCESSING WITHIN
LANGUAGE TRANSLATORS
◦ Macro processor discussed so far
are preprocessors that
● Process macro definitions
● Expand macro invocation
● Produces an expanded version of
the macro at the place of the call
and then use it by the assembler
or the compiler.
◦ Macro processing functions can be
combined with the language
translators.
● Line-by-line macro processors
● Integrated macro processors
LINE-BY-LINE MACRO PROCESSORS
◦ Used as sort of input routine the assembler or
compiler.
● Read source program.
● Handle macro definition and expand the
invocation.
● Pass output lines to the assembler or compiler.
◦ Benefits
● Avoid making an extra pass over the source
program.
● Data structures required by the translators and
the macro processor can be kept same.
● Utility subroutines by the translators and the
macros can be kept same.
● Scanning input lines, Searching tables.
INTEGRATED MACRO PROCESSORS

◦ An integrated macro processor

can make use of any information
about the source program that is
extracted by the language
translators

◦ An integrated macro processor

can support macro instructions
that depend upon the context in
which they occur.
INTEGRATED MACRO PROCESSORS

◦ Definitions and invocations of

macros are handled by a
preprocessor, which is generally
not integrated with the rest of the
compiler.
◦ Example
● #DEFINE NULL 0
● #DEFINE EOF (-1)
● #DEFINE EQ ==
● #DEFINE ABSDIF (x, y)
{X>Y? X-Y:Y-X}
 INTEGRATED MACRO PROCESSORS

◦ Parameter substitutions are not

performed within quoted.
◦ #define DISPLAY( EXPR) printf(“
EXPR= %d\ n”, EXPR)

⚫ Example
◦ DISPLAY( I* J+ 1) ==> printf(“
EXPR = %d\ n”, I* J+ 1)
INTEGRATED MACRO PROCESSORS
◦ Recursive macro definitions or
invocations
After a macro is expanded, the macro
processor rescans the text that has been
generated, looking for more macro
definitions or invocations.
Macro cannot invoke or define itself
recursively.
Example
DISPLAY( ABSDIFF( 3, 8))
SCANS
printf(“ ABSDIFF( 3, 8)” “= %d\ n”,
ABSDIFF( 3, 8))
RESCANS
printf(“ ABSDIFF( 3, 8)” “= %d\ n”, (
(3)>( 8) ? (3) -
(8) : (8)-( 3) ))
ANSI C MACRO LANGUAGE
Conditional compilation statements
Example 1
#ifndef BUFFER_ SIZE
#define BUFFER_ SIZE 1024
#endif
Example 2
#define DEBUG 1
:
#if DEBUG == 1
printf(…) /* debugging outout */
#endif
MACRO MACRO PROCESSOR

ABSDIF J,K

MOV AX,J
SUB AX, K
JNS ??0000
NEG AX
??0000:
MACRO MACRO PROCESSOR
ABSDIF MACRO OP1, OP2, SIZE
LOCAL EXIT
IFNB <SIZE>
IFDIF <SIZE> <E>
;ERR
EXITM
ENDIF
ENDIF
MOV SIZEE&AX, OP1
SUB SIZE&AX, OP2
JNS EXIT
NEG SIZE&AX
EXIT:
ENDM
 SUMMARY

⚫ Algorithms
⚫ Nested macros
⚫ Comparison of different macro
design
⚫ Machine-Independent macro
features
⚫ Implementation of conditional
macros