This document discusses nested macros in system programming. It defines a macro as a unit of program specification that allows code expansion. A macro can contain a call to another macro, known as a nested macro call. Nested macro calls are expanded following the LIFO (last-in-first-out) rule, where the innermost macro call is expanded first. The document provides an example of a nested macro call in C code and how the macros would expand to generate the final code.

1. System Programming Sunita M. Dol, CSE Dept
Walchand Institute of Technology, Solapur Page 1
HANDOUT#05
Aim:
Implementation of nested macro
Theory:
A macro is a unit of specification for program generation through expansion.
Macro Definition
A macro definition is enclosed between a macro header statement and a macro end
statement. Macro definitions are typically located at the start of a program. Macro
definition consists of:
1. Macro prototype statements
2. One or more model statements
3. Macro preprocessor statements
1. Macro prototype statements.
The macro prototype statement declares the name of the macro and the names and
kinds of its parameters. The macro prototype statement has the following syntax:
<macro name> [<formal parameter specification>[ …..]]
where <macro name> appears in the mnemonic field of assembly Statement and
<formal parameter specification> is of the form
&<parameter name> [<parameter kind>]
2. Model statements.
A model statement is a statement from which assembly language statements may
be generated during macro expansion.
3. Macro preprocessor statements.
A preprocessor statement is used to perform auxiliary functions during macro
expansion.

2. System Programming Sunita M. Dol, CSE Dept
Walchand Institute of Technology, Solapur Page 2
Macro call
A macro is called by writing the macro name in the mnemonic field of an
assembly statement. The macro call has syntax
<macro name> [<actual parameter specification>[,….]]
where actual parameter resembles an operand specification in assembly statement.
Example
The definition of macro INCR is given below
MACRO
INCR &MEM_VAL, &INCR_VAL, &REG
MOVER &REG, &MEM_VAL
ADD &REG, &INCR-VAL
MOVEM &REG, &MEM_VAL
MEND
Macro Expansion
A macro leads to macro expansion. During macro expansion, the use of a macro
name with a set of actual parameters i.e. the macro call statement is replaced by a
sequence of assembly code. To differentiate between the original statement of a
program and the statements resulting from macro expansion, each expanded
statement is marked with a ‘+’ preceding its label field.
There are two kinds of expansions
1. Lexical expansion.
2. Semantic expansion
1. Lexical expansion.
Lexical expansion implies replacement of a character string by another character
string during program generation. It replaces the occurrences of formal parameter
by corresponding actual parameters.
Example
Consider the following macro definition
MACRO
INCR &MEM_VAL, &INCR_VAL, &REG
MOVER &REG, &MEM_VAL
ADD &REG, &INCR-VAL
MOVEM &REG, &MEM_VAL

3. System Programming Sunita M. Dol, CSE Dept
Walchand Institute of Technology, Solapur Page 3
MEND
Consider macro call statement on INCR
INCR A, B, AREG
The values of formal parameters are:
Formal parameter value
MEM_VAL A
INCR_VAL B
REG AREG
Lexical expansion of the model statement leads to the code
+ MOVER AREG, A
+ ADD AREG, B
+ MOVEM AREG, A
2. Semantic expansion
Semantic expansion implies generation of instructions tailored to the requirements
of a specific usage e.g. generation of type specific instruction for manipulation of
byte and word operands. It is characterized by the fact that different use of macro
can lead to codes which differ in the number, sequence and opcodes of
instructions.
Example
Consider the macro definition
MACRO
CLEAR &X, &N
LCL &M
&M SET 0
MOVER AREG, =’0’
.MORE MOVEM AREG, &X+&M
&M SET &M+1
AIF (&M NE N) .MORE
MEND
Consider the macro call CLEAR B, 3

4. System Programming Sunita M. Dol, CSE Dept
Walchand Institute of Technology, Solapur Page 4
This macro call leads to generation of statements:
+ MOVER AREG, =’0’
+ MOVEM AREG, B
+ MOVEM AREG, B+1
+ MOVEM AREG, B+2
Nested Macro Calls
A model statement in a macro may constitute a call on another macro. Such calls
are known as nested macro calls. Expansion of nested macro calls follows the last-
in-first-out (LIFO) rule. Thus, in a structure of nested macro calls, expansion of the
latest macro call (I.e. the innermost macro call in the structure) is completed first.
Example
Consider an example
MACRO
COMPUTE &FRIST, &SECOND
MOVEM BREG, TMP
INCR &FIRST, &SECOND, AREG
MOVER BREG, TMP
MEND
and macro definition
MACRO
INCR &MEM_VAL, &INCR_VAL, &REG=
MOVER &REG, &MEM_VAL
ADD &REG, &INCR-VAL
MOVEM &REG, &MEM_VAL
MEND

5. System Programming
Walchand Institute of Technology
Input:
#include<stdio.h>
#define as 20+asd
#define xyz 5
#define asd 10+xyz
#define pf printf
#define sf scanf
void main(void)
{
pf("Enter a no:");
sf("%d",&a);
b=as+asd+xyz;
pf("xyz=%d",b);
}
Sunita M. Dol, CSE Dept
Walchand Institute of Technology, Solapur
#define asd 10+xyz
pf("Enter a no:");
sf("%d",&a);
b=as+asd+xyz;
pf("xyz=%d",b);
Sunita M. Dol, CSE Dept
Page 5

6. System Programming Sunita M. Dol, CSE Dept
Walchand Institute of Technology, Solapur Page 6
Output:
The old file
#include<stdio.h>
#define as 20+asd
#define xyz 5
#define asd 10+xyz
#define pf printf
#define sf scanf
void main(void)
{
pf("Enter a no:");
sf("%d",&a);
b=as+asd+xyz;
pf("xyz=%d",b);
}
MACRO EXPANSION
as 20+asd
xyz 5
asd 10+xyz
pf printf
sf scanf
The new file
#include<stdio.h>
void main(void)
{
printf("Enter a no:");
scanf("%d",&a);
b=20+10+5+10+5+5;
printf("xyz=%d",b);
}

7. System Programming Sunita M. Dol, CSE Dept
Walchand Institute of Technology, Solapur Page 7
Conclusion:
A macro is a unit of specification for program generation through expansion.
A model statement in a macro may constitute a call on another macro. Such
calls are known as nested macro calls.
Expansion of nested macro calls follows the last-in-first-out (LIFO) rule.
Nested macro is implemented in C-language.