Macro Processor Functions

• Macro instructions are a shorthand way for programmers to write programs.
• The macro processor replaces each macro instruction with corresponding source language statements via expansion.
• Macro processors typically perform no analysis of the text and are machine independent.

Basic Macro Processor Functions

• Assembler directives used in macro definition:
• MACRO identifies the start.
• MEND identifies the end.
• Prototype structure:
• name MACRO parameters ... MEND
• Parameters start with '&'.
• Body contains statements generated when expanded.

Macro Expansion

• Here's an example of macro expansion:
• Source: M1 MACRO &D1, &D2. Instructions STA &D1, STB &D2. Ends with MEND. Invoked as M1 DATA1, DATA2.
• Expanded source: STA DATA1, STB DATA2. Invoked as M1 DATA4, DATA3 results in STA DATA4, STB DATA3.

Macro Invocation

• A macro invocation statement (macro call) specifies the macro's name and arguments for expansion: macro_name p1, p2, ...
• Key difference between macro and procedure calls:
• Macro body statements are expanded each invocation.
• Subroutine statements appear only once, regardless of call count in procedure calls.
• Macro calls insert code directly, while procedure calls jump to a subroutine, calling macros impacts size and procedure calls impact reusability.

Macro Expansion Details

• Macro invocation statements expand into the macro's body statements.
• Arguments from invocation replace parameters of macro prototype based on position.
• Comments are dropped.
• Macro invocation statement becomes a comment.
• Its labels are kept on the first macro expansion statement.
• Use macro instructions like assembler mnemonics.

Labels In Macro Bodies

• Issue: Expanding the same macro multiple times leads to duplicate labels, causing assembler errors.
• Solutions:
• Avoid labels in macro bodies.
• Use PC-relative addressing. Example: RDBUFF and WRBUFF macros, JEQ *+11, JLT *-14. But, this is error-prone.

Multi-Pass Macro Processors

• Two-pass macro processor:
• Pass 1: Processes macro definitions.
• Pass 2: Expands macro invocation statements.
• one-pass can be sufficient.
• Macros must be defined before invocation, also bodies of macros can contain definitions of other macros.

Recursive Macro Definitions

• MACROS (for SIC) contains RDBUFF and WRBUFF definitions in SIC instructions.
• MACROX (for SIC/XE) contains definitions in SIC/XE instructions.
• Defining MACROS/MACROX doesn't define RDBUFF/WRBUFF until their invocation is expanded.

One-Pass Macro Expansion of Recursive Definitions

• Able to alternate macro definition and expansion to handle recursive macro definitions.
• A macro's definition must appear before it is invoked.

Data Structures for One-Pass Processing

• DEFTAB (Definition Table):
• Stores macro definitions including the prototype and body with comments omitted.
• Macro parameter references are converted to positional notation.
• NAMTAB:
• Stores macro names.
• Serves as an index to DEFTAB, containing pointers to start and end macro definitions.
• ARGTAB:
• Stores macro invocation arguments by position.
• Used to substitute arguments during macro body expansion

One-Pass Macro Processing Algorithm

• Main program iterates through GETLINE and PROCESSLINE.
• Gets the next line to be processed from DEFTAB if EXPANDING, else read next input file.
• Sets up argument values in ARGTAB (EXPAND).
• The algorithm searches MAMTAB for OPCODE, expanding if found or defining if OPCODE is 'MACRO'; otherwise, it writes source line to expanded file (PROCESSLINE).
• A counter LEVEL tracks macro definition depth, incrementing and decrementing with MACRO and MEND directives respectively, terminating definition at LEVEL 0 (DEFINE).

Handling Nested Macro Definitions

• Use a LEVEL counter to track macro definition levels.
• Increase LEVEL on MACRO.
• Decrease LEVEL on MEND.
• A MEND terminates definition when LEVEL reaches 0.

Comparison of Macro Processor Designs:

• One-pass algorithm:
• Macros must be defined before use.
• Processes macro definition and expansion.
• Allows nested definitions, no nested calls.
• Two-pass algorithm:
• Recognizes macro definitions (Pass 1) and calls (Pass 2).
• Disallows nested definitions.