May 14, 2002 Macro Languages AoPL, S'02 Macro Languages Claus Brabrand Michael I. Schwartzbach...

May 14, 2002 Macro Languages AoPL, S'02

Macro Languages

Claus Brabrand

Michael I. Schwartzbach

BRICS, University of Aarhus, Denmark

Outline

• Introduction

• Macro survey:• Lexical macros: CPP, M4, TEX, (Dylan)

• Syntax macros: C++ templates, Scheme, JTS, MS2

• The <bigwig> macro language

• Metamorphic syntax macros

• Next week: The metafront Tool• Specificity parsing• Language transformation

Introduction

“Macro”

Webster’s(“macro”) =

Main Entry: 2macroPronunciation: 'ma-(")krOFunction: nounInflected Form(s): plural macrosEtymology: short for macroinstructionDate: 1959“a single computer instruction that stands for a sequence of operations”

Motivation (#1)

Abstraction (language extension):

Iterator iterator = list.iterator();while (iterator.hasNext()) { String s = (String) iterator.next(); System.out.println(s);}

foreach (String s in list) { System.out.println(s); }

Motivation (#2)

Genericity (uniform abstraction mechanism): • Generic abstraction mechanism for all syntactic

categories:

…whereas functions only “take” and “give” expressions:

<exp> <id> ( <exps> )<exp> <id> ( <exps> )

Principle of Abstraction:

“Any semantically meaningful syntactic class can in principle be used as the body of an abstraction”

- Robert Tennent, 1981

Principle of Abstraction:

“Any semantically meaningful syntactic class can in principle be used as the body of an abstraction”

- Robert Tennent, 1981

Motivation (#3)

Consistency:

Object[] strings = list.toArray();for (int i=0; i<strings.length; i++) { String s = (String) strings[i]; System.out.println(s); }

Motivation (#4)

Laziness (abbreviation):

Motivation (#5)

Encapsulation (hide complexity):

Macro Survey

Many Macro Languages

Scheme

C++templates

...and many more

Non-Alphabetical Characters

Scheme

C++templates

...and many more

Level of Operation

Scheme

C++templates

Lexical Syntactic

...and many more

Lexical Macros

• Operate on token sequences:• MLEX: (TOKENSEQ)n TOKENSEQ

• Precede actual compilation (conceptually)– i.e. a preprocessor

• Independent of host language syntax

• Languages:• CPP: “The C Preprocessor”• M4: “The Unix Macro Preprocessor”• TEX: TEX’s macro mechanism• Dylan: Dylan’s macro mechanism (hybrid)

Lexical Macro Example

• Square (CPP):#define square(X) X * X#define square(X) X * X

• Square (CPP):#define square(X) X * X

square(z + 1)

#define square(X) X * X

square(z + 1)

( )z + 1square

square(z + 1) => z + 1 * z + 1

( )z + 1 z + 1 z + 1*=>square

square(z + 1) => z +(1 * z)+ 1

( )z + 1 z + 1 z + 1*=>square

• Square (CPP):

• Work-around: Explicitly add parentheses

square(z + 1) => z +(1 * z)+ 1

#define square(X) (X) * (X)#define square(X) (X) * (X)

( )z + 1 z + 1 z + 1*=>square

• Square (CPP):

square(z + 1) => z +(1 * z)+ 1

#define square(X) (X) * (X)

square(z + 1) => (z + 1)*(z + 1)

( )z + 1 z + 1 z + 1*=>square

• Square (CPP):

– Problem: Independent of host language syntax• Unsafe: parse errors discovered at invocation-time

square(z + 1) => z +(1 * z)+ 1

square(z + 1) => (z + 1)*(z + 1)

( )z + 1 z + 1 z + 1*=>square

Syntactic Macros

• Operate on abstract syntax trees:• MSYN: (AST)n AST

• Integrated with host language– typed with host language nonterminals

• Languages:• C++: The C++ template mechanism• Scheme: Scheme’s define-syntax mechanism• JTS: “Jakarta Tool Suite” macro

mechanism• MS2: “Meta Syntactic Macro System”• <bigwig>: The <bigwig> macro language

Syntactic Macro Example

• Square (<bigwig>):

macro <exp> square ( <exp E> ) ::= { <E> * <E>

y + 1y

square( )

y + 1y

+ 1 y + 1y

+ 1y + 1

square( ) =>

Lexical Macros

CPP, M4, TEX, (Dylan)

( )z + 1 z + 1 z + 1*=>square

• CPP (“The C Preprocessor”):

• Also as a stand-alone expander:• gcc –E program• cpp program

• Intercepts preprocessor directives “#”:• #define, #undef, #ifdef, #if, #include, #line, ##, …

#define square(X) (X) * (X)square(z + 1) => (z + 1)*(z + 1)

Fixed Invocation Syntax#define swap(X,Y) { int t=X; X=Y; Y=t; } #define swap(X,Y) { int t=X; X=Y; Y=t; }

Fixed Invocation Syntax#define swap(X,Y) { int t=X; X=Y; Y=t; }

if (a>b) swap(a,b); else b = 0;

#define swap(X,Y) { int t=X; X=Y; Y=t; }

*** test.c:3: parse error before ‘else’*** test.c:3: parse error before ‘else’

#define swap(X,Y) do { int t=X; X=Y; Y=t; } while(0)

Fixed Invocation Syntax

– Problem: fixed invocation syntax• same for exp, stm, … M(x,y,z)

Body Expansion

• Consider: #define A 87#define B A#undef A#define A 42

B => ???

#define A 87#define B A#undef A#define A 42

B => ???

Body Expansion

• Consider:

• Eager expansion (definition-time):

B => ???

B => 87B => 87

Body Expansion

• Consider:

• Lazy expansion (invocation-time):

B => ???

B => 87B => 87

B => AB => A CPP

Body Expansion

• Consider:

• Lazy expansion (invocation-time):

B => ???

B => 87B => 87

B => A => 42B => A => 42 CPP

Order of Expansion

• Consider: #define id(X) X#define one(X) id(X)#define two a,b

one(two) => ???

#define id(X) X#define one(X) id(X)#define two a,b

one(two) => ???

Order of Expansion

• Consider:

• Inner (aka. “AOR”, call-by-value):

one(two) => ???

one(two) => one(a,b) => *** arity error ‘one’one(two) => one(a,b) => *** arity error ‘one’

Order of Expansion

• Consider:

• Inner (aka. “AOR”, call-by-value):

• Outer (aka. “NOR”, call-by-name):

one(two) => ???

one(two) => one(a,b) => *** arity error ‘one’one(two) => one(a,b) => *** arity error ‘one’

one(two) => id(two) => two => a,bone(two) => id(two) => two => a,b

CPP: Order of Expansion

• “Argument prescan”:

one(two) one(two)

one(two) => id(a,b)one(two) => id(a,b)

one(two) => id(a,b) => *** arity error ‘id’one(two) => id(a,b) => *** arity error ‘id’

• For piecing together new macro invocations• partly from the arguments, partly from the body:

one(two) => id(a,b) => *** arity error ‘id’one(two) => id(a,b) => *** arity error ‘id’

#define succ(X) ((X) + 1)#define call7(X) X(7)

call7(succ) => succ(7) => ((7) + 1)

#define succ(X) ((X) + 1)#define call7(X) X(7)

call7(succ) => succ(7) => ((7) + 1)

Recursion

• Consider: #define x 1+x

x => ???

#define x 1+x

x => ???

Recursion

• Consider:

• Definition-time (static intercept-and-reject):

#define x 1+x

x => ???

#define x 1+x

x => ???

#define x 1*x *** definition-time error!#define x 1*x *** definition-time error!

Recursion

• Consider:

• Definition-time (static intercept-and-reject):

• Invocation-time (non-termination):

#define x 1+x

x => ???

#define x 1+x

x => ???

#define x 1*x *** definition-time error!#define x 1*x *** definition-time error!

x => 1+x => 1+1+x => … // loop at compile-time!x => 1+x => 1+1+x => … // loop at compile-time!

CPP: Recursion

• “Dynamic intercept-and-ignore”:• Keep stack of macro invocations• Ignore invocations of already invoked macros:

x => 1+xx => 1+x

int x = 2;#define x 1+x

x => ???

CPP: Recursion

• “Dynamic intercept-and-ignore”:• Keep stack of macro invocations• Ignore invocations of already invoked macros:

x => 1+x // intercept-and-ignore: (at runtime x 3)x => 1+x // intercept-and-ignore: (at runtime x 3)

x => ???

• M4 (Unix Macro Preprocessor):• Originally called “ratfor”:

– “The Rational Fortran Preprocessor”

• Not tailored for a particular language• universal preprocessor

• 30+ built-in constructions:• macro definition, arithmetic evaluation, string

operations, file and system interfacing, …

M4 Example

• Implicit arguments (named: $1, …, $9)• Excess arguments ignored• Missing arguments default to “”

• Quoting:– Expansion removes one layer of quotes

• Controls expansion-time (eager by default):

define(‘square’, ‘eval($1 * $1)’)define(‘square’, ‘eval($1 * $1)’)

M4 Example

define(‘square’, ‘eval($1 * $1)’)

square(3)

M4 Example

square(3) => eval(3 * 3)

M4 Example

square(3) => eval(3 * 3) => 9

• Flexible invocation syntax:• Designed by macro programmer

\def \vector #1[#2..#3]{ // header $({#1}_{#2},\ldots,{#1}_{#3})$ // body}

\vector x’[0..n-1]

\vector x’[0..n-1] => $({x’}_{0},\ldots,{x’}_{n-1})$

(x’0, …, x’n-1)(x’0, …, x’n-1)

• Flexible invocation syntax:• Designed by macro programmer• Parsing ambiguities (chooses shortest invocation)

(x’0, …, x’n-1)(x’0, …, x’n-1)

– Implies:

(x’0, …, x’n-1)(x’0, …, x’n-1)

M M x // invokes M(M), not M(M(x))M M x // invokes M(M), not M(M(x))

– Implies:

• Recursion permitted:• TC compile-time language to “break the recursion”

(x’0, …, x’n-1)(x’0, …, x’n-1)

M M x // invokes M(M), not M(M(x))M M x // invokes M(M), not M(M(x))

Syntax Macros

C++ templates, Scheme, JTS, MS2

C++ Templates

• Intended as a genericity mechanism• But often used as a macro language

C++ Templates

• Syntax types:• Arguments: id, const, all types (e.g. int)• The result is always a declaration

C++ Templates

• Multiple definitions:template<int X, int Y> struct M { … }template<int X> struct M { … }

template<int X, int Y> struct M { … }template<int X> struct M { … }

C++ Templates

• Multiple definitions:

• Constant folding:

template<int X, int Y> struct M { … }template<int X> struct M { … }

(1 + 2) 3 // at compile-time(1 + 2) 3 // at compile-time

However…template<int X>struct ct_pow<X,0> { static const int res = 1;};

template<int X, int Y>struct ct_pow { static const int res = X * ct_pow<X,Y-1>::res;};

const int z = ct_pow<5,3>::res; // c-time z 125

template<int X>struct ct_pow<X,0> { static const int res = 1;};

However…

• Constant folding + multiple definition =Turing complete (at compile-time)!

Scheme

• Convenient pattern matching

(define-syntax and (syntax-rules () ((and) #t) ((and b) b) ((and b …) (if b (and …) #f)))))))))))))))))) :)

Scheme

• Convenient pattern matching

(and a (if x y z) c) => (if ...)

Scheme

• Convenient pattern matching• Multiple definitions:

– Selection: first match in order listed

(and a (if x y z) c) => (if ...)

Scheme

• Convenient pattern matching• Multiple definitions:

– Selection: first match in order listed

• Ellipsis list constructor: “…”– More on this later…

(and a (if x y z) c) => (if ...)

Hygienic Macro Expansion

• Scheme has automatic -conversion:• Identifier renaming to avoid name capture

(define-syntax gen-inc (syntax-rules () ((gen-inc i) (lambda (x) (+ x i))))

• let ((x 3)) (

• let ((x 3)) (• Without -conversion

((gen-inc x) 5) ((gen-inc x) 5)

((gen-inc x) 5) => ((lambda (x) (+ x x)) 5) ((gen-inc x) 5) => ((lambda (x) (+ x x)) 5)

((gen-inc x) 5) => ((lambda (x) (+ x x)) 5) => 10((gen-inc x) 5) => ((lambda (x) (+ x x)) 5) => 10

• With -conversion:

((gen-inc x) 5) ((gen-inc x) 5) )

((gen-inc x) 5) => ((lambda (x’) (+ x’ x)) 5) ((gen-inc x) 5) => ((lambda (x’) (+ x’ x)) 5) )

((gen-inc x) 5) => ((lambda (x’) (+ x’ x)) 5) => 8((gen-inc x) 5) => ((lambda (x’) (+ x’ x)) 5) => 8 )

Compile-Time Programming

• Basically compile-time functions on S-exps• Lazy (inv.-time) body expansion ( evaluation):

(define-syntax m (syntax-rules () ((m) (if 1 2 3 4))))

(m) => // *** parse error: too many arg’s to if

• Non-termination possible:

(define-syntax ct-loop (syntax-rules () ((ct-loop) (ct-loop))))

• Non-termination possible:

(ct-loop) => // c-time loop

• JTS (“Jakarta Tool Suite”):

macro swap(AST_QualifiedName x, AST_QualifiedName y) local temp // explicit -conversion stm{ // body constructor: stm integer temp = x; x = y; y = temp; }stm

• JTS (“Jakarta Tool Suite”):• Argument types: name, exp, stm, decl, class, type• Result types: “exp”, “stm”, “mth”, “cls”, “prg”

– Fixed invocation syntax:

#swap(C.x, y);#swap(C.x, y);

– Fixed invocation syntax: – Safe:

• Guaranteed termination, only generate legal syntax

#swap(C.x, y);#swap(C.x, y);

• MS2 (“Meta Syntactic Macro System”):• Turing complete AST programming language

– for computing C parse trees at compile-time

syntax decl myenum[] {| $$id::name { $$+\,id::ids }; |} { return (list(`[enum $name $ids;], `[$(symbolconc(“print_”,name))(arg) { switch (arg) $(map((| @id id; `{ case $id: printf(“%s”, $(pstring(id)));}), ids))}));}

• MS2 (“Meta Syntactic Macro System”):• Turing complete AST programming language

– for computing C parse trees at compile-time

syntax decl myenum[] {| $$id::name { $$+\,id::ids }; |} { return (list(`[enum $name $ids;], `[$(symbolconc(“print_”,name))(arg) { switch (arg) $(map((| @id id; `{ case $id: printf(“%s”, $(pstring(id)));}), ids))}));}myenum fruit { apple, orange }; print_fruit(apple);

• 8 Languages:• { CPP, M4, TEX, Dylan, C++ Templates, Scheme, JTS, MS2 }

Macro Survey

• 31 Properties:• { Level of operation, body expansion, order of expansion, … }

Macro Survey

• 31 Properties:• { Level of operation, body expansion, order of expansion, … }

Macro Survey

• Declarative:• Based entirely on simple concepts: grammars and

substitution

• Safe:• Guaranteed termination• Only generate legal (and -converted) syntax

• Flexible:• All (55) nonterminals may be arg and return types• Invocation syntax design (guides parsing)

On all (55) Nonterminals

• <floatconst>:macro <floatconst> pi ::= { 3.1415926 }macro <floatconst> pi ::= { 3.1415926 }

• <floatconst>:

• <stm>:

macro <floatconst> pi ::= { 3.1415926 }macro <floatconst> pi ::= { 3.1415926 }

macro <stm> maybe <stm S> ::= { if (random(2)==0) <S>

• <floatconst>:

• <stm>:

• <regexp>:

macro <floatconst> pi ::= { 3.1415926 }macro <floatconst> pi ::= { 3.1415926 }

macro <stm> maybe <stm S> ::= { if (random(2)==0) <S>

macro <regexp> plus ( <regexp R> ) ::= { concat(star(<R>),<R>)

Example: repeat

• Invocation syntax design:• Guides the parser

macro <stm> repeat <exp E> until ( <stm S> ) ; ::= { {

while (<E>) <S>

Example: repeat

• Invocation syntax design:• Guides the parser

• Code duplication: <S>• Worst-case: O(2n)

while (<E>) <S>

Example: repeat

bool first = true;

while (first || !<E>) {

first = false;

bool first = true;

first = false;

Example: repeat

-Conversion:• first => first_87

bool first = true;

first = false;

bool first = true;

first = false;

Multiple Definitions

• Macros with same name: si/si-sinon:

• Parsing:• Which macro to select?

macro <stm> si (<exp E>) <stm S> ::= { if (<E>) <S>

macro <stm> si (<exp E>) <stm S> sinon <stm T> ::= { if (<E>) <S> else <T>

macro <stm> si (<exp E>) <stm S> ::= { if (<E>) <S>

macro <stm> si (<exp E>) <stm S> sinon <stm T> ::= { if (<E>) <S> else <T>

Specificity Parsing

macro <exp> select <id I> from <exp E> where <exp E2>

macro <exp> select all from <exp E> where <exp E2>

Specificity Parsing

• Challenge rounds:– Select most specific productions (wrt. FIRST sets)

• Resolves many ambiguities• Independent of definition-order• Overloading• Avoids keywordification• Commit no branch explosion, no backtracking

Pretty Print and Error Reporting

• Pretty Printing:• Terminal printers:

ASCII, LA EX, HTML(+/- expansion)

Pretty Print and Error Reporting

• Pretty Printing:• Terminal printers:

ASCII, LA EX, HTML(+/- expansion)

• Error Reporting:• stdout, HTML*** symbol errors:*** test.wig:7: Identifier ‘inf’ not declared in macro argument ‘S’ in macro invocation ‘reader’ (test.wig:7) defined in [std.wigmac:44]

*** symbol errors:*** test.wig:7: Identifier ‘inf’ not declared in macro argument ‘S’ in macro invocation ‘reader’ (test.wig:7) defined in [std.wigmac:44]

Concurrency Stack

Representation

macro <ids> MXY ( <ids Is> ) ::= { X, <Is>, Y }

A, MXY(B, C), D A, X, B, C, Y, D

Representation

• “Weaving” yields transparency!

Metamorphic Syntax Macros

Argument Structure

• Many variants of an abstraction?

enum { zero };

enum { zero, one };

enum { zero, one, two };

enum { zero };

enum { zero, one };

Argument Structure

– Syntax:• Argument structure?

– Transformation:• Specification?

enum { zero };

enum { zero, one };

enum { zero };

enum { zero, one };

Argument Structure

– Syntax:• Argument structure?

– Transformation:• Specification?

enum { zero };

enum { zero, one };

enum { zero };

enum { zero, one };

Safety?

Multiple Definitionsmacro <decls> enum { <id X> }; ::= { const int <X> = 0;

macro <decls> enum { <id X>, <id Y> }; ::= { const int <X> = 0;

const int <Y> = 1;

macro <decls> enum { <id X>, <id Y>, <id Z> }; ::= { const int <X> = 0;

const int <Y> = 1;

const int <Z> = 2;

macro <decls> enum { <id X> }; ::= { const int <X> = 0;

macro <decls> enum { <id X>, <id Y> }; ::= { const int <X> = 0;

const int <Y> = 1;

macro <decls> enum { <id X>, <id Y>, <id Z> }; ::= { const int <X> = 0;

const int <Y> = 1;

const int <Z> = 2;

Multiple Definitionsmacro <decls> enum { <id X> }; ::= {…}

macro <decls> enum { <id X>, <id Y> }; ::= {…}

macro <decls> enum { <id X>, <id Y>, <id Z> }; ::= {…}

macro <decls> enum { <id X> }; ::= {…}

decls enum { id } ;

enum { id , id } ;

enum { id , id , id } ;

decls enum { id } ;

enum { id , id } ;

• Corresponds togrammar extension:

decls enum { id } ;

enum { id , id } ;

decls enum { id } ;

enum { id , id } ;

Three unrelated productions

decls enum { id } ;

enum { id , id } ;

decls enum { id } ;

enum { id , id } ;

• Problems:• Only fixed (finite) extent

decls enum { id } ;

enum { id , id } ;

decls enum { id } ;

enum { id , id } ;

• Problems:• Only fixed (finite) extent• Highly redundant

• Scheme:• Special list constructor: “...”

decls ( enum id * )decls ( enum id * )

(define-syntax and (syntax-rules () ((and) #t) ((and b) b) ((and b ...) (if b (and ...) #f))))

(enum x y z)(enum x y z)

• MS2:• Regular expressions:

– Optionals “?”, lists “+, *”, tuples “{…}”, t-sep. lists “\+t”

syntax decl myenum[] {| $$id::name { $$+\,id::ids }; |} { return (list(`[enum $name $ids;], `[$(symbolconc(“print_”,name))(arg) { switch (arg) $(map((| @id id; `{ case $id: printf(“%s”, $(pstring(id)));}), ids))}));

decls enum { id , } ;decls enum { id

myenum fruit { apple, orange }; print_fruit(apple);myenum fruit { apple, orange }; print_fruit(apple);

Grammar

• Dylan (and JSE, a Java adaptation):• Describe argument syntax via

user-defined nonterminals

decls enum { id enums } ;

enums , id enums

Grammar

• Dylan (and JSE, a Java adaptation):• Describe argument syntax via

user-defined nonterminals

– Unsafe:• Transformations return lexical token sequences• Return user defined abstract syntax trees?

enums , id enums

Metamorphisms

• <bigwig>:• Attach host nonterminals to user def’d nonterminals• Specify morphing (into host syntax) inductively

metamorph <decls> enums;

macro <decls> … <enums: Ds> … ::= { … <Ds> … }

morph <enums> … ::= { … }

macro <decls> … <enums: Ds> … ::= { … <Ds> … }

morph <enums> … ::= { … }

enums , id enums

Example: enum

• Ideally:

enum { a, b, c };enum { a, b, c };const int a = 0;const int b = 1;const int c = 2;

const int a = 0;const int b = 1;const int c = 2;

Example: enum

• Ideally:

• But requires compile-time evaluation: 0, 1, 2, …

Example: enum

• Ideally:

• But requires compile-time evaluation: 0, 1, 2, …

• Instead generate:

enum { a, b, c };enum { a, b, c };const int e = 0;const int a = e++;const int b = e++;const int c = e++;

const int e = 0;const int a = e++;const int b = e++;const int c = e++;

Example: enummetamorph <decls> enums;metamorph <decls> enums;

enums , id enums

Example: enummetamorph <decls> enums;

macro <decls> enum { <id X> <enums: Ds> } ; ::= { int e = 0;

const int <X> = e++;

enums , id enums

morph <enums> , <id X> <enums: Ds> ::= { const int <X> = e++;

enums , id enums

morph <enums> ::= { }

enums , id enums

Guaranteed Termination

• Termination proof:• Transition system + termination function

0 1 2 …(0) > (1) > (2) > …

– States: ( , ) (T N)* sentential form T* input string

0 1 2 …(0) > (1) > (2) > …

– States: ( , ) (T N)* sentential form T* input string

– Transitions:– (t , t ) (, )– (N , ) ( , ) , if N

0 1 2 …(0) > (1) > (2) > …

– Termination function:( , ) =

0 1 2 …(0) > (1) > (2) > …

– Termination function:( , ) = < | |, || || >

0 1 2 …(0) > (1) > (2) > …

– || t || = 0

0 1 2 …(0) > (1) > (2) > …

– || t || = 0

– || N0 || = k+1

0 1 2 …(0) > (1) > (2) > …

N0 N1 1 N2 2 1 … Nk k … 1N0 N1 1 N2 2 1 … Nk k … 1

longest

– Termination function:( , ) = < | |, || || > lexicographically

ordered– || t || = 0

– || N0 || = k+1

0 1 2 …(0) > (1) > (2) > …

N0 N1 1 N2 2 1 … Nk k … 1N0 N1 1 N2 2 1 … Nk k … 1

longest

Metamorph Wellformedness

• Check at definition time:• No left-recursion

– guarantees parser termination:

xlist xlist X

xlist X xlist

Metamorph Wellformedness

• Check at definition time:• No left-recursion

– guarantees parser termination:

• Derivability– metamorphisms must derive something finite:

xlist xlist X

xlist X xlist

xlist X xlistxlist X xlist

Example: switchmetamorph <stm> swb;

metamorph <stm> swb;

stm switch ( exp ) { swb }

swb case exp : stms break; swb

case exp : stms break;

macro <stm> switch ( <exp E> ) { <swb: S> } ::= { { var x = <E>; <S> }}

macro <stm> switch ( <exp E> ) { <swb: S> } ::= { { var x = <E>; <S> }}morph <swb> case <exp E> : <stms Ss> break; <swb: S> ::= { if (x == <E>) { <Ss> } else <S>}

macro <stm> switch ( <exp E> ) { <swb: S> } ::= { { var x = <E>; <S> }}morph <swb> case <exp E> : <stms Ss> break; <swb: S> ::= { if (x == <E>) { <Ss> } else <S>}morph <swb> case <exp E> : <stms Ss> break; ::= { if (x == <E>) { <Ss> }}

Example: reserve

stm reserve ( res ) stm

res id res

reserve ( a b c ) ...;reserve ( a b c ) ...;

acquire(a); acquire(b); acquire(c); ...; release(c); release(b);release(a);

Example: reserve

• Requires non-local transformations• e.g. “b” must generate both “acquire(b)” and

“release(b)” at different locations

res id res

reserve ( a b c ) ...;reserve ( a b c ) ...;

acquire(a); acquire(b); acquire(c); ...; release(c); release(b);release(a);

Multiple Results

• Extend metamorphisms:• Attach host nonterminals to user def’d nonterminals

metamorph <stms,stms> res;

macro <stm> … <res: As,Rs> … ::= { … <As> … <Rs> … }

morph <res> … ::= { … } { … }

macro <stm> … <res: As,Rs> … ::= { … <As> … <Rs> … }

morph <res> … ::= { … } { … }

res id res

Example: reserve

macro <stm> reserve ( <res: As,Rs> ) <stm S> ::= { { <As> <S> <Rs> }

morph <res> <id X> <res: As,Rs> ::= { acquire(<X>); <As>

<Rs> release(<X>);

morph <res> ::= { } { }

macro <stm> reserve ( <res: As,Rs> ) <stm S> ::= { { <As> <S> <Rs> }

morph <res> <id X> <res: As,Rs> ::= { acquire(<X>); <As>

<Rs> release(<X>);

morph <res> ::= { } { }

res id res

Example: enum (cont’d)

• Suppose no initialization expressions• Instead generate:

– CPS Style:• Send initialization expression to metamorphism

enum { a, b, c };enum { a, b, c };const int a = 0;const int b = 1;const int c = 1+1;

const int a = 0;const int b = 1;const int c = 1+1;

Metamorph Argumentsmetamorph <decls> enums(<exp K>);

macro <decls> enum { <id X> <enums: Ds>({1}) }; … { const int <X> = 0;

morph <enums> , <id X> <enums: Ds>({<K>+1}) ::= { const int <X> = <K>;

metamorph <decls> enums(<exp K>);

enums , id enums

Metamorph Argumentsmetamorph <decls> enums(<exp K>);

metamorph <decls> enums(<exp K>);

enums , id enums

enum {…x…}; => … const int x = 1+1+1+1; …enum {…x…}; => … const int x = 1+1+1+1; …

Metamorph Advantages

• Flexibility:• Tree structures• Non-local transformations (multiple results)

• Safety:• No parse errors as a conseq. of macro expansion• Guaranteed termination

• Simplicity: • Based entirely on declarative concepts:

grammars and substitution

vDSL:very Domain-Specific Languagestudies

course Math101

title “Mathematics 101”

2 point fall term

exclusions

Math101 <> MathA

Math102 <> MathB

prerequisites

Math101, Math102 < Math201, Math202, Math203

Math101, CS101 < CS202

studies

course Math101

title “Mathematics 101”

2 point fall term

exclusions

Math101 <> MathA

Math102 <> MathB

prerequisites

Math101, Math102 < Math201, Math202, Math203

Math101, CS101 < CS202

Next Week: metafront

• Macros are just a special case usage:• A is an extension of B: m: L+ => L

• Make sure only need to write delta: = L+ \ L

metafront

x: A => B

program.a program.b

transformation

input language

input program(s) output program(s)

output language

May 14, 2002 Macro Languages AoPL, S'02 Macro Languages Claus Brabrand Michael I. Schwartzbach...

Documents

Transcript of May 14, 2002 Macro Languages AoPL, S'02 Macro Languages Claus Brabrand Michael I. Schwartzbach...

Macro 101 - State of Oregon Macro 101.pdfFeb 04, 2020 · Macro 101. 5-What is the process to create a new macro or repair a broken macro? –Because each macro is customized for

Chapter 5 Macro and Macro Processors

PHASE-III MACRO SYSTEM A case of fractal system architecture using programming languages and procedures from SAS Institute Inc. Wolf-Dieter Batz PhUSE.

Macro Prudence vs. Macro Prudential Regulation Uni 2013 Risk Day... · Macro Prudence Macro Prudential Supervision: ... banks fail too often ... Agency roles in Macro Prudence

When Inequality Matters for Macro and Macro ... - Princeton · When Inequality Matters for Macro and Macro Matters for Inequality ... seeMcKay and Reis ... not only does macro matter

API-AOPL Annual Liquids Pipeline Safety Excellence Performance Report & Strategic Plan

26799437 17 Basidiomycota Macro de Macro

ASSEMBH V1.2A Reference Manual - Fujitsumanuals.ts.fujitsu.com/file/957/assh_bs.pdf · ASSEMBH is a language processor for the assembly and macro languages. ASSEMBH processes one

Macro-Tech i Series Serie Macro-Tech i Macro ... - Crown Audio

Excel Macro and VBA. Recording/Editing Macro Recording macro: –Tools/Macro/Record new macro Editing macro: –Tools/Macro/Macros Excel’s macros are VBA.

Technical Data - asset.conrad.com · Focus range 0.5m. ~ infinity Macro mode 11cm – 18cm Digital zoom 4x Flash mode Auto / force / off ... OSD languages English / German / Italian

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

Macro Processor. Macro Instruction A macro instruction (macro) is simply a notational convenience for the programmer. A macro represents a commonly used.

Aopl Brochure 2014

Prof. Fateman CS 164 Lecture 261 Macro Expansion/ Macro Languages Lecture 26.

AOPL Flyer Draft #3 - Art of Hosting · 2019. 12. 21. · AOPL Flyer Draft #3 Author: Amber Huffstickler Keywords: DADtu5wXcww,BACMmzenB7Y Created Date: 12/17/2019 7:31:46 PM ...

Aopl Workbook Ec

DX200 OPTIONS INSTRUCTIONS...Macro Command 2 Preparation of Macro Commands 2.2 Teaching a Macro Job. 2.2 Teaching a Macro Job. Teach a macro job which is prepared as a macro command

Macro Expansion/ Macro Languages

Macro F1 and Macro F1