chapter 4 macro processors l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Chapter 4 Macro Processors PowerPoint Presentation
Download Presentation
Chapter 4 Macro Processors

Loading in 2 Seconds...

play fullscreen
1 / 53

Chapter 4 Macro Processors - PowerPoint PPT Presentation


  • 801 Views
  • Uploaded on

Chapter 4 Macro Processors. System Software Chih-Shun Hsu. Introduction. A macro represents a commonly used group of statements in the source programming language

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

Chapter 4 Macro Processors


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
    Presentation Transcript
    1. Chapter 4 Macro Processors System Software Chih-Shun Hsu

    2. Introduction • A macro represents a commonly used group of statements in the source programming language • The macro processor replaces each macro instruction with the corresponding group of source language statement, this is called expanding macros • The functions of a macro processor essentially involve the substitution of one group of characters or lines for another

    3. Macro Definition and Expansion • The MACRO statement identifies the beginning of a macro definition • The symbol in the label field is the name of the instruction • The entries in the operand field identify the parameter of the macro instruction • Each parameter begins with the character & • The MEND assembler directive marks the end of the macro definition • A macro invocation statement gives the name of the macro instruction being invoked and the arguments to be used in expanding the macro

    4. Use of macros in a SIC/XE Program(3/1)

    5. Use of macros in a SIC/XE Program(3/2)

    6. Use of macros in a SIC/XE Program(3/3)

    7. Program with Macro Expanded(3/1)

    8. Program with Macro Expanded(3/2)

    9. Program with Macro Expanded(3/3)

    10. Macro Processor Data Structures • The macro definitions themselves are stored in definition table (DEFTAB), which contains the macro prototype and the statements that make up the macro body • The macro names are entered into NAMTAB, which serves as an index to DEFTAB • For each macro instruction defined NAMTAB contains pointers to the beginning and end of the definition in DEFTAB • The third data structure is an argument table (ARGTAB), which is used during the expansion of macro invocations • When a macro invocation statement is recognized, the arguments are stored in ARGTAB according to their position in the argument list

    11. Macro Processor Data Structures

    12. Algorithm for a One-pass Macro Processor(3/1)

    13. Algorithm for a One-pass Macro Processor(3/2)

    14. Algorithm for a One-pass Macro Processor(3/3)

    15. Machine-Independent Macro Processor Features • Concatenation of Macro Parameters • Generation of Unique Labels • Conditional Macro Expansion • Keyword Macro Parameters

    16. Concatenation of Macro Parameters(2/1) • Most macro processors allow parameters to concatenated with other character strings • If similar processing is to be performed on each series of variables, the programmer might want to incorporate this processing in to a macro instruction • The body of the macro definition might contain a statement like “LDA X&ID1” in which the parameter &ID is concatenated after the character string X and before the character string 1 • If the macro definition contained both &ID and &ID1 as parameters, the situation would be ambiguous • Most macro processors deal with this problem by providing a special concatenation operator (e.g. ) • LDA X&ID1

    17. Concatenation of Macro Parameters(2/2)

    18. Generation of Unique Labels • Relative addressing in a source statement may be acceptable for short jumps such as “JEQ *-3* • For longer jumps spanning several instructions, such notation is very inconvenient, error-prone and difficult to read • Allow the creation of special types of labels • Each symbol beginning with $ has been modified by replacing $ with $xx, where xx is a two character alphanumeric counter of the number of macro instructions expanded • For the first macro expansions, xx will have the value AA • For succeeding macro expansions, xx will be set to AB, AC, etc

    19. Generation of Unique Labels with Macro Expansion(2/1)

    20. Generation of Unique Labels with Macro Expansion(2/1)

    21. Conditional Macro Expansion(2/1) • Most macro processors can modify the sequence of statements generated for a macro expansion, depending on the arguments supplied in the macro invocation • The IF statement evaluates a Boolean expression that is its operand • If the value of this expression is TRUE, the statements following the IF are generated until an ELSE is encountered • Otherwise, these statements are skipped, and the statements following the ELSE are generated • The ENDIF statement terminates the conditional expression that was begun by the IF statement

    22. Conditional Macro Expansion(2/2) • The macro processor must maintain a symbol table that contains the values of all macro-time variables used • Entries in this table are made or modified when SET statements are processed • The implementation outlined above does not allow for nested IF structures • WHILE: a macro-time looping statement • The WHILE statement specifies that the following lines, until the next ENDW statement, are to be generated repeatedly as long as a particular condition is true • The macro-time variable &CTR is used to count the number of times the lines following the WHILE statement have been generated

    23. Use of Macro-time Conditional Statements(5/1)

    24. Use of Macro-time Conditional Statements(5/2)

    25. Use of Macro-time Conditional Statements(5/3) RDBUFF F3, BUF, RECL, 04, 2048

    26. Use of Macro-time Conditional Statements(5/4)

    27. Use of Macro-time Conditional Statements(5/5)

    28. Use of Macro-time looping Statements(2/1)

    29. Use of Macro-time looping Statements(2/2)

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

    31. Use of Keyword Parameters in Macro Instructions(3/1)

    32. Use of Keyword Parameters in Macro Instructions(3/2)

    33. Use of Keyword Parameters in Macro Instructions(3/3)

    34. Macro Processor Design Options • Recursive Macro expression • General-Purpose Macro Processors • Macro Processing within Language Translators

    35. Recursive Macro Expansion • Macro within macro can be solved if the macro 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

    36. Example of Nested Macro Invocation(2/1)

    37. Example of Nested Macro Invocation(2/2)

    38. General-Purpose Macro Processors(2/1) • 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

    39. General-Purpose Macro Processors(2/2) • A general-purpose facility must provide some way for a 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

    40. Macro Processing within Language Translators(2/1) • 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

    41. Macro Processing within Language Translators(2/2) • 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

    42. MASM Macro Processor(2/1) • 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

    43. MASM Macro Processor(2/2) • ;; 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

    44. Examples of MASM Macro and Conditional Statements(3/1)

    45. Examples of MASM Macro and Conditional Statements(3/2)

    46. Examples of MASM Macro and Conditional Statements(3/3)

    47. Example of MASM Iteration Statement

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

    49. The ELENA Macro Processor • Macro definitions in ELENA are composed of a header and a body • The header consists of keywords and parameter markers, which are identified by the character % • At least one of the first two token s in a macro header must be a keyword, not a parameter marker • The macro processor appends a numeric value to create unique labels • ELENA provides macro-time variables and macro-time instructions that can be used to control the macro expansion • The IF statement is a macro-time conditional “go to” statement • The macro is identified by the sequence of keywords that appear in its header

    50. Examples of ELENA Macro Definition and Invocation(2/1)