Chapter 4 Macro Processors

-- Basic Macro Processor Functions

Introduction
A macro instruction (macro) is a notational convenience for the programmer
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)
Normally, it performs no analysis of the text it handles. It does not concern the meaning of the involved statements during macro expansion.

The design of a macro processor generally is machine independent!

Basic macro processor functions

Two new assembler directives are used in macro definition
MACRO: identify the beginning of a macro definition MEND: identify the end of a macro definition

Prototype for the macro

Each parameter begins with & name MACRO parameters : body : MEND Body: the statements that will be generated as the expansion of the macro.

Macro expansion
Source M1 MACRO &D1, &D2 STA &D1 STB &D2 MEND . M1 DATA1, DATA2 . M1 DATA4, DATA3 Expanded source . . . STA DATA1 STB DATA2 . STA DATA4 STB DATA3 .

Example of macro definition Figure 4.1, pp. 178

! " # ! ( ( ( $ "% & $ # ! " $ " ) " # ! ! ' ! !

4 4 5 5 , ,

*" " / 0 " / 0 ' ) / ) "

+ ,. ) $ " % 12 . ) $ " % & 1* $ # ! "& ) 12 , $ '

! ! "% ! " " ' " ) ' ! ' # %

"

'

3 " # ! !

"

) " 3'

3'

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 of how many times the subroutine is called.

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); }

Whats the result?

4

Pass by Reference
void exchange(int *p1, int *p2) { int temp; temp = *p1; *p1 = *p2; *p2 = temp; } main() { int i=1, j=3; printf("BEFORE - %d %d\n", i, j); exchange(&i, &j); printf("AFTER - %d %d\n", i, j); }

12 Lines of Assembly Code

. Subroutine EXCH EXCH LDA @P1 STA TEMP LDA @P2 STA @P1 LDA TEMP STA @P2 RSUB P1 RESW 1 P2 RESW 1 TEMP RESW 1 LDA #1 STA I LDA #3 STA J . Call a subroutine LDA #I STA P1 LDA #J STA P2 JSUB EXCH I RESW 1 J RESW 1 END MAIN MAIN

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); }

6 Lines of Assembly Code

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 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 In the macro invocation: argument

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.

Example of macro invocation Figure 4.1, pp. 178

4 4 5 , , " # ! " + / 0 6 # ! / " 6 # ! / # ' " 3' # ! 6 " 6 6 # " ,3' ,-2# # ! " & 8 &' " 7 " & # ! & 3' ) 6 ! ! !" " ( ( " & # ! 3' & 3' % " ! " " " " # ! 3

Example of macro expansion Figure 4.2, pp. 179

! 5 , , , 9 , : , ; , , < , , = , , > , ? , @ , / ) ) 12 , 3' ' / 0 ' *" " / 0 " + ,. ) 12 . ) & 1* # ! & ) ! # % " ) ' ) '" 3' # ! ! 3' ! " " ) ! ! "% " " " " 3' ( " # ! ) " & # ! & 3' % " ! " ! " " # ! ! !

Example of macro expansion Figure 4.2, pp. 179

, " + / 0 6 # ! ) 9 : ; " "' " / 0 < 6" ) = / / ( " 6 # ! & &' 7 12 # ! . ) 12 . ) 6 ! '% # 6 3' & ) 3 ' ! ! "% ! ' ' " # ! " & # ! & 3' ) 6 ! ! ! !" " 3' "

Example of macro expansion Figure 4.2, pp. 179

" 9 : ; " "' " / 0 < 6" ) = / / # ' " 3' # ! 6 " 6 6 # " ,,-2# # ! 12 8 " . ) 12 . ) 6 ! '% # 6 ) ' & ) 3 ' ! ! "% ! ' ' " # ! !

No label in the 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 addressing instead.
Ex, in RDBUFF and WRBUFF macros, JEQ *+11 JLT *-14 It is inconvenient and error-prone.

The way of avoiding such error-prone method will be discussed in Section 4.2.2

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

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.
5

Example of recursive macro definition Figure 4.3, pp.182

MACROS (for SIC)
Contains the definitions of RDBUFF and WRBUFF written in SIC instructions.
" # ! ( ( ( " 6 # ! ( ( " ( ( ( " A ; < C , A "< ; ;B $ "% & $ # ! "& $ ' A ; ;B C : C

A ; <" # ! C $ !"% & $ # ! "& $ A ; ;B A ; < 6 # ! C C

'

Example of recursive macro definition Figure 4.3, pp.182

MACROX (for SIC/XE)
Contains the definitions of RDBUFF and WRBUFF written in SIC/XE instructions.
) " # ! ( ( ( " 6 # ! ( ( ( " ( ( " A ; < )C A "< D ) : C $ "% & $ # ! "& $ ' A D ) B C

A ; <" # ! C $ !"% & $ # ! "& $ A D ) B C

'

A ; < 6 # ! C

Example of macro definitions

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 structures 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.

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 structures

Algorithm
MAIN program - Iterations of GETLINE PROCESSLINE

Procedure GETLINE If EXPANDING then get the next line to be processed from DEFTAB Else read next line from input file

Procedure PROCESSLINE DEFINE EXPAND Output source line

Procedure EXPAND Set up the argument values in ARGTAB Expand a macro invocation statement (like in MAIN procedure) - Iterations of GETLINE PROCESSLINE

Procedure DEFINE Make appropriate entries in DEFTAB and NAMTAB

Algorithm Figure 4.5, pp. 184

A : H : C ) " I . " 3 A F = @ C A : H : C "

: = <E ; ) " F A

#< " " . E: @ C

"

G H ; ;< @

Algorithm Figure 4.5, pp. 185

" : : H I 2 % J 3 = : @ # H " #

A "

E 9 E H @ < H @ " # " . % I . % * " . " % I . % A < : C A F = @ C #H 9 ; ; < ;< C

4

Algorithm Figure 4.5, pp. 185

) ) " " 3I . ! < @ < : ;< A H HC < " E H E < : B: 3 # F = @ : B: G H ; ;< @ : ; < : ;< 3 A F = @ C " 3I . " C #

) A) 3

" 3 G@ E 9 E A < C < : ;< E < < " 3 #< H # @

A 3

; G@ < C

H E< @ 5

Handling nested macro definition

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. 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 Processors 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

Two-pass algorithm
Pass1: Recognize macro definitions Pass2: Recognize macro calls Nested macro definitions are not allowed