UNIT IV MACRO PROCESSORS

1. BASIC MACRO PROCESSOR FUNCTIONS

2. MACRO DEFINITION AND EXPANSION

3. MACRO PROCESSOR ALGORITHM AND DATA

STRUCTURE

4. MACHINE-INDEPENDENT MACRO PROCESSOR

FEATURES

5. CONCATENATION OF MACRO PARAMETERS

6. GENERATION OF UNIQUE LABELS

7. CONDITIONAL MACRO EXPANSION

8. KEYWORD MACRO PARAMETER

9. MACRO WITHIN MACRO

10.IMPLEMENTATION EXAMPLE

11.MASM MACRO PROCESSOR

12.ANSI C MACRO LANGUAGE.

 MACROPROCESSORS

A macro name is an abbreviation, which stands for some related lines of code. Macros
are useful for the following purposes:
to simplify and reduce the amount of repetitive coding
to reduce errors caused by repetitive coding
to make an assembly program more readable.

Source
Macro Expanded Compiler or obj
Code
(with macro) Processor Code Assembler

Figure 1. Macro expansion on a source program.

Macro expansion
Ex:
User program Macro Definition User program (after macro expansion)

INITZ MACRO header … …

MOV AX, @data INITZ MOV
AX, @data
MOV DS, AX A template MOV
DS, AX
MOV ES, AX (code)
MOV ES, AX
ENDM trailer … …

prototype (macro name) macro call

Using parameters in macros:

Ex: displaying a message. (Assume that: MES2 DB ‗Enter the data as mm/dd/yy‘)

User program Macro Definition User program (after macro expansion)

PROMPT MACRO MESSGE ;dummy argument … …

MOV AH, 09H
LEA DX, MESSGE PROMPT MES2 MOV
AH, 09H
INT 21H … LEA
DX, MES2
ENDM ;end of macro … INT
21H
…
MES2 DB ‘Enter the MES2 DB
‘Enter the
data as mm/dd/yy’ data
as mm/dd/yy’

DATA STRUCTURE
ALGORITHMs
One-Pass Macro Processor

 Prerequisite
» every macro must be defined before it is called
 Sub-procedures
» macro definition: DEFINE
» macro invocation: EXPAND
NAMTAB

DEFINE
MACRO DEFTAB

PROCESSLINE

CALL EXPAND ARGTAB

Data structure Global variable
 DEFTAB
 NAMTAB
 ARGTAB
Nested Macro:

 Macro definition within macros

» process macro definition during expansion time
Nested Macro Definition

 Sub-procedures
» macro definition: DEFINE
» macro invocation: EXPAND
 EXPAND may invoke DEFINE when encounter macro definition

NAMTA DEFINE
MACR

DEFTA PROCESSLINE

CAL EXPAND
ARGTAB

Expandin MACRO
1- Pass Macro Processor

DEFINE
MACRO
PROCESSOR

GETLINE
EXPANDING=FALSE

PROCESSLINE

GETLINE EXPAND
PROCESSLINE

EXPANDING=TRUE

GETLINE GETLINE
PROCESSLINE

EXPANDING FALSE

TRUE

READ FROM READ FROM

DEFTAB INPUT
Comparison of single & 2-Pass design

 Single pass
» every macro must be defined before it is called
» one-pass processor can alternate between macro definition and macro
expansion
» nested macro definitions may be allowed but nested calls are not
 Two pass algorithm
» Pass1: Recognize macro definitions
» Pass2: Recognize macro calls
» nested macro definitions are not allowed

Concatenation of parameter
  Pre-concatenation
» LDA X&ID1
 Post-concatenation
» LDA X&ID 1

Generation of unique labels

 Example
» JEQ *-3
» inconvenient, error-prone, difficult to read
 Example Figure 4.7
– $LOOP TD =X’&INDEV’
» 1st call:
– $AALOOP TD =X’F1’
» 2nd call:
– $ABLOOP TD =X’F1’

RDBUFF F1, BUFFER, LENGTH

Conditional Macro Expansion

 Macro-time conditional statements

» Example: Figure 4.8
» IF-ELSE-ENDIF

 Macro-time variables
» any symbol that begins with the character & and that is not a macro
parameter
» macro-time variables are initialized to 0
» macro-time variables can be changed with their values using SET
– &EORCK SET 1
 Macro-time looping statement
» Example: Figure 4.9
» WHILE-ENDW
 Macro processor function
» %NITEMS: THE NUMBER OF MEMBERS IN AN ARGUMENT LIST

Only part of the macro is copied out into the code. Which part is copied out will be under
the control of the parameters in the macro call.

CONMB (condition) branch address

Ex:Line
no. Assembly instructions

… …
8 CONMB (&C>2), 15
9
… …
15
… …

If condition is true, skip the code up to line 15.

If condition is false, expansion continues from line 9.
Design for a simple Macroassembler

read macro definitions into a memory buffer

more
source N Assembler
code
Y

get next line

N Y
write line to the output file macro call call Macro Expander routine

Figure 2. A macroprocessor front end for an assembler

Find the appropriate macro definition

Build a parameter table to relate dummy and real parameters

LP = first line in the template

Examine the line

N conditional Y
assembly call

substitute real parameters evaluate the Boolean

expression
write it to the output file N True Y

LP = LP + 1 LP = LP + 1 LP = line number in
the
statement

Y more lines N return LP: line

pointer

Figure 3. Macro Expander Routine

Ex:

Source program Macro definition

… ALPHA MACRO ARG1, ARG2, ARG3

ALPHA A, 2, C
… …
ENDM

Parameter table
Dummy Real
parameter parameter
ARG1 A
ARG2 2
ARG3 C
Keyword Macro Parameters

 Positional parameter: parameters and arguments were associated with each other
according to their positions in the macro prototype and the macro invocation
statement
 Keyword parameters: each argument value is written with a keyword that named
the corresponding parameter
 Each parameter name is followed by an equal sign, which identifies a keyword
parameter
 The parameter is assumed to have the default value if its name does not appear in
the macro invocation statement

Macro calls within Macros

- Use a stack to keep the order of the macro calls

- Create a parameter table at each macro call
- If a dummy parameter appears in the real parameter field of a called macro, search the
parameter table of the calling macro and replace it with the appropriate real
parameter.
 Find the appropriate macro definition

Build a parameter table to relate dummy and real parameters

Push LP onto the stack

LP = first line in the template

Examine the line

instruction
conditional macro call macro end
assembly call

substitute real parameters evaluate the Boolean expression Find the

appropriate Pop from stack
macro definition
and set LP and

current param.
write it to the output file N True Y
table pointer
Build a parameter table

LP = LP + 1 LP = LP + 1 LP = line number in
the statement
Push LP and the pointer
to the last parameter
table
onto the stack

LP = first line in the

template
 Y more lines N return
LP: line pointer

Figure 4. Macro Expander Routine that allows macro calls within macros
ARGTAB

DEFTAB MACRO Definition

DEFINE
NAMTAB

GETLINE
PROCESSLINE

Macro Invocation
EXPAND
ARGTAB
I- PASS macroprocessor

DEFINE
MACRO
PROCESSOR

GETLINE
EXPANDING=FALSE

PROCESSLINE

GETLINE EXPAND
PROCESSLINE

EXPANDING=TRUE

GETLINE
GETLINE
PROCESSLINE

EXPANDING FALSE

TRUE

READ FROM READ FROM

DEFTAB INPUT

Allowing Nested Macro Invocation

DEFINE(f)
MACRO
PROCESSOR

GETLINE(f)

PROCESSLINE(f)
GETLINE(0)
PROCESSLINE(0) EXPAND

GETLINE(1)
PROCESSLINE(1)
GETLINE(f)

f FALSE

TRUE

READ FROM READ FROM

DEFTAB INPUT
Macro Assembler

DEFINE(f)
MACRO
PROCESSOR

GETLINE(f)

PROCESSLINE(f)
GETLINE(0)
PROCESSLINE(0) EXPAND

GETLINE(1)
PROCESSLINE(1)
GETLINE(f)

f FALSE

TRUE

READ FROM READ FROM

DEFTAB INPUT

Macro Processor Design Options

 Recursive Macro expression
 General-Purpose Macro Processors
 Macro Processing within Language Translators

Recursive Macro Expansion

 processor is being written in a programming language that allows recursive calls
 The compiler would be sure that previous value of any variables declared within a
procedure were saved when that procedure was called recursively
 If would take care of other details involving return from the procedure

General Purpose Macro Processor

 Advantages of general-purpose macro processors:
 The programmer does not need to learn about a different macro facility for
each compiler or assembler language—the time and expense involved in
training are eliminated
 The costs involved in producing a general-purpose macro processor are
somewhat greater than those for developing a language-specific processor
  However, this expense does not need to be repeated for each language; the
result is substantial overall saving in software development cost
 user to define the specific set of rules to be followed
 Comments should usually be ignored by a macro processor, however, each
programming language has its own methods for identifying comments
 Each programming language has different facilities for grouping terms,
expressions, or statements—a general-purpose macro processor needs to taking
these grouping into account
 Languages differ substantially in their restrictions on the length of identifiers and
the rules for the formation of constants
 Programming languages have different basic statement forms—syntax used for
macro definitions and macro invocation statements

 ELENA
» Software: Practice and Experience

 Macro definition

» header:
– a sequence of keywords and parameter markers (%)
– at least one of the first two tokens in a macro header must be a
keyword, not a parameter marker

» body:
– the character & identifies a local label
– macro time instruction (.SET, .IF .JUMP, .E)
– macro time variables or labels (.)

 Macro invocation
» There is no single token that constitutes the macro ―name‖
» Constructing an index of all macro headers according to the keywords in
the first two tokens of the header
» Example
– DEFINITION:
 ADD %1 TO %2
 ADD %1 TO THE FIRST ELEMENT OF %2
– INVOCATION:
 DISPLAY TABLE

Macro Processing within Language Translators

 The macro processor reads the source statements and performs all of its functions,
the output lines are passed to the language translator as they are generated
 The macro processor operates as a sort of input routine for the assembler or
compiler
  The line-by-line approach avoids making an extra pass over the source program,
so it can be more efficient than using a macro preprocessor
 Some of the data structures required by the macro processor and the language
translator can be combined
 A line-by-line macro processor also makes it easier to give diagnostic messages
that are related to the source statement containing the error
 An integrated macro processor can potentially make use of any information about
the source program that is extracted by the language translator
 An integrated macro processor can support macro instructions that depend upon
the context in which they occur
 Line-by-line macro processors must be specially designed and written to work
with a particular implementation of an assembler or compiler, which results in a
more expensive piece of software
 The assembler or compiler will be considerably larger and more complex than it
would be
 The additional complexity will add to the overhead of language translation

MASM
 The macro processor of MASM is integrated with Pass 1 of the assembler
 MASM generates the unique names of local labels in the form ??n, where n is a
hexadecimal number in the range 0000 to FFFF
 .ERR: signals to MASM that an error has been detected
 EXITM: directs MASM to terminate the expansion of the macro
 &: is a concatenation operator
 ;; is a macro comment, serves only as documentation for the macro definition
 ; is an ordinary assembler language comment, included as part of the macro
expansion
 IRP: sets the macro-time variable to a sequence of values specified in <…>
 The statements between the TRP and the matching ENDM are generated once for
each value of the variable
 ANSI C Macro Language
 In the ANSI C language, definitions and invocations of macros are handled by a
preprocessor, which is generally not integrated with the rest of the compiler
 #define ABSDIFF(X,Y) X>Y ? X-Y : Y-X
 #define DISPLAY(EXPR) printf(#EXPR‖=%d\n‖,EXPR)
 Macro in ANSI C may contain definitions or invocations of other macros
 DISPLAY(ABSDIFF(3,8)) ABSDIFF(3,8)=5
 The ANSI C preprocessor also provides conditional compilation statements
 #ifndef BUFFER_SIZE
#define BUFFER_SIZE 1024
#endif