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”

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


vs.


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

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



vs.


Motivation (#4)

Laziness (abbreviation):

vs.






Motivation (#5)

Encapsulation (hide complexity):

vs.






Macro Survey


Many Macro Languages

CPP

M4

TEX

Scheme

C++templates

MS2

...and many more

Dylan

JTS

<bigwig>


Non-Alphabetical Characters

CPP

M4

TEX

Scheme

C++templates

MS2

...and many more

Dylan

JTS

<bigwig>


Level of Operation

CPP

M4

TEX

Scheme

C++templates

Dylan

JTS

Lexical Syntactic

...and many more

MS2

<bigwig>


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


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

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




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


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


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


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

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

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


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


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>

}


}




**

exp

exp

Eexp

E


}


}~




**

exp

exp

Eexp

E

y + 1y

+ 1

exp


}


}

square( )

~




**

exp

exp

Eexp

E

**

exp

y + 1y

+ 1 y + 1y

+ 1

exp

Eexp

Ey

+ 1y + 1

exp


}


}

square( ) =>

~


Lexical Macros

CPP, M4, TEX, (Dylan)

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


CPP

• 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)

#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 => ???

B => 87B => 87


Body Expansion

• Consider:


• Lazy expansion (invocation-time):


B => ???


B => ???

B => 87B => 87

B => AB => A CPP


Body Expansion

• Consider:


• Lazy expansion (invocation-time):


B => ???


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(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(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)



CPP




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



CPP




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



CPP




• 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)



CPP


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 => ???


x => ???

CPP


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 => ???


x => ???

CPP


M4

• 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)


square(3)


M4 Example





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


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


M4 Example





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


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


TEX

• Flexible invocation syntax:• Designed by macro programmer

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



TEX



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


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


TEX



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




TEX






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


TEX

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





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


TEX


– 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))


TEX


– 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:



(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 ...)


(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 ...)


(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 ...)


(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


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






JTS

• 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

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




JTS


– Fixed invocation syntax:



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


JTS


– Fixed invocation syntax: – Safe:

• Guaranteed termination, only generate legal syntax



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


MS2

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

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

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

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


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

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

Macro Survey


<bigwig>

• 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 <regexp> plus ( <regexp R> ) ::= { concat(star(<R>),<R>)

}

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> ) ; ::= { {

<S>

while (<E>) <S>

}

}


<S>

while (<E>) <S>

}

}


Example: repeat

• Invocation syntax design:• Guides the parser

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


<S>

while (<E>) <S>

}

}


<S>

while (<E>) <S>

}

}


Example: repeat


bool first = true;

while (first || !<E>) {

<S>

first = false;

}

}

}


bool first = true;


<S>

first = false;

}

}

}


Example: repeat

-Conversion:• first => first_87


bool first = true;


<S>

first = false;

}

}

}


bool first = true;


<S>

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)

T


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]

T


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!

weave


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



Lists

• 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))))

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

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


e-BNF

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

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


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


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


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


enums , id enums


Example: enummetamorph <decls> enums;

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

const int <X> = e++;

<Ds>

}




<Ds>

}


enums , id enums


enums , id enums





<Ds>

}

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

<Ds>

}




<Ds>

}


<Ds>

}


enums , id enums


enums , id enums





<Ds>

}


<Ds>

}

morph <enums> ::= { }




<Ds>

}


<Ds>

}



enums , id enums


enums , id enums


Guaranteed Termination

• Termination proof:• Transition system + termination function

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

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




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

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

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) > …

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




– Termination function:( , ) =

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

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




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

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

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





– || t || = 0

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

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





– || t || = 0

– || N0 || = k+1

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

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) > …

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 xlist X

xlist X xlist

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 xlist X

xlist X xlist

xlist X xlist

xlist X xlist

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









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









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


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


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


res id res

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




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


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


res id res


Example: enum (cont’d)



=>


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;

<Ds>

}

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

<Ds>

}


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


<Ds>

}


<Ds>

}



enums , id enums


enums , id enums


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


<Ds>

}


<Ds>

}


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


<Ds>

}


<Ds>

}



enums , id enums


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


FIN


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

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

squarex x

x squarez

macro languages aopl

s02 macro webstersmacro

macro pronunciation

iterator iterator

square slide

s02 introduction slide