Using Stratego/XT for generation of software connectors.

Using Stratego/XT for Generation of Software Connectors Michal Malohlava Supervisor: RNDr. Tomáš Bureš, Ph. D. DISTRIBUTED SYSTEMS RESEARCH GROUP http://dsrg.mff.cuni.cz/ CHARLES UNIVERSITY IN PRAGUE Faculty of Mathematics and Physics

Outline Connector generation ● Existing connector generator overview ● Stratego/XT overview ● Proposed solution ● Conclusion ● 2

Connectors? Generation? Why? Why should be component interested in communication? ● It should just implement business logic – => Connectors ● Displace communication matters from components – Design time view – Model component interaction (communication style, NFP) ● Run-time view – Implements interaction with help of some middleware ● Additional services (e.g. Logging) ● Preparation of connectors ● During deployment time – complete info about application and its distribution ● 3 Automatic generation (component interface, depl. docks, ● requirements, code template)

General goal Define and implement simple method of ● defining connectors implementations Template based system – Source code generation – Integrate new solution with existing solution – Non-invasively (preserve original functionality) ● 4

Connector architecture Connector ● Connector units – Connector elements ● 5

Existing connector generator Architecture resolver ● Find architecture of connector in according to described – requirements (HLCS) Source code generation ● Driven by generation script – Generates Java code – Per conn. element ● Simple templates ● Compile java code – Package binaries – 6

Existing connector generator Simple code templates which are processed by Java class ● Class just substitutes parts enclosed in % by Java code – Sufficient for primitive connector elements, but composite ● element looks like this: package %PACKAGE%; imports org...runtime.*; public class %CLASS% implements ElementLocalServer , ElementLocalClient , ElementRemoteServer , ElementRemoteClient { protected Element[] subElements ; protected UnitReferenceBundle[] boundedToRRef; public %CLASS%( ) { } %INIT METHODS% // this part processed by special Java class } 7

Existing connector generator Simple code templates which are processed by Java class ● Class just substitutes parts enclosed in % by Java code – Sufficient for primitive connector elements, but composite ● element looks like this: package %PACKAGE%; imports org...runtime.*; public class %CLASS% implements This variable is unfolded into into 200LOC by ElementLocalServer , Java class with ElementLocalClient , 1200LOC! ElementRemoteServer , ElementRemoteClient { protected Element[] subElements ; protected UnitReferenceBundle[] boundedToRRef; public %CLASS%( ) { } %INIT METHODS% // this part processed by special Java class } 8

Stratego/XT Developed at Delft University of Technology, ● Netherlands (Eelco Visser, Martin Bravenboer) Tool set ● Grammar tools – SDF – Syntax Definition Formalism ● Pretty printers ● Grammar definitions (Java, C/C++, XML, ...) ● Program transformation language Stratego – Based on AST rewriting via strategies ● 9

Stratego/XT - architecture How does it work? ● 10

Stratego/XT - SDF Modular, one grammar defines: ● Lexical tokens – Context-free rules – Generation of parser (scannerless generalized LR parser) ● Generates “a forest of Abstract Syntax Trees (AST)” – ambiguous parts are explicitly marked ● AST represented by ATerm – 11

Stratego/XT – SDF example module Expr−literals module Expr−expressions imports Expr−literals exports exports sorts Int lexical syntax sorts Exp context−free syntax ”0” −> Int [1−9][0−9]* −> Int I n t −> Exp { cons ( ” I n t ” )} lexical restrictions Exp ”+” Exp −> Exp { cons ( ”Add” ) , assoc} Int −/− [0−9] Exp ”−” Exp −> Exp { cons ( ”Sub” ) , left } Exp ” *” Exp −> Exp { cons ( ”Mul ” ) , assoc} Exp ” / ” Exp −> Exp { cons ( ” Div ” ) , assoc} Exp ” ˆ ” Exp −> Exp { cons ( ”Pow” ) , right } ” ( ” Exp ” ) ” −> Exp { bracket } SDF grammar for simple language describing numerical expressions ● 12

Stratego/XT – Stratego language Based on strategies manipulating with AST ● Input/Output: AST represented by ATerms – Rewriting strategies and rules ● Strategy – Describes how is AST traversed and rewrited ● Rule – simple rewrite strategy ( Rule: A -> B <=> ?A; !B) ● Many predefined strategies and rules for AST traversing (id, fail, ● bottomup, topdown, try,...), system access strategies (e.g. ls, chmod, open_file,...) Dynamic rules – Allows creating rewrite rules on the fly in according to context ● Program in Stratego language is translated into C and compiled 13 ●

Stratego/XT – Stratego example module EExpr imports liblib Expr−eval strategies io−EExpr = io−wrap ( expr−eval ) imports Expr strategies expr-eval = innermost(EvalAdd <+ EvalMul <+ EvalSub <+ EvalDiv <+ EvalPow) rules EvalAdd: Add(Int(i), Int(j)) -> Int(<addS>(i,j)) EvalSub: Sub(Int(i), Int(j)) -> Int(<subtS>(i,j)) EvalMul: Mul(Int(i), Int(j)) -> Int(<mulS>(i,j)) EvalDiv: Div(Int(i), Int(j)) -> Int(<divS>(i,j)) EvalPow: Pow(Int(i), Int(j)) -> Int(<powS>(i,j)) strategies powS = (string-to-int, string-to-int); pow; int-to-string 14 pow = ?(A,B); <copy>(B, A); foldr(!1, mul) // à la Haskell

Goals revisited Rebuild source code generator ● Design more sophisticated templates based on DSL – Implement source code generator – Test eligibility of Stratego/XT for this purposes – Incorporate the developed connector element code – generator into the existing solution 15

Solution – DSL Designed new Domain Specific Language ● Mixture of meta-language ElLang and target language (Java) – MetaBorg method developed by Stratego/XT group ● Allows embedding language into another language – Connecting selected nonterminals of both languages – ● Defined via SDF Meta-language ElLang ● Meta-variables – ${a}, ${a[index]} ● Meta-queries – ${a.b.c} ● Meta-statements – $set, $if, $include, $foreach, $rforeach 16 ●

Solution – DSL Designed new Domain Specific Language ● – Recursive foreach – designed ElLang of Java grammar constraints Mixture of meta-language because and target language (Java) MetaBorg method developed by Stratego/XT group ● $rforeach(PORT in ${ports.port(type=PROVIDED)} )$ if (quot;${PORT.name}quot;.equals(portName)) {into another language – Allows embedding language ObjectConnecting selected neterminals of both languages – result = ((ElementLocalServer) subElements[${el[PORT....]}]); Defined via SDF ● if (isTopLevel) { Meta-language ElLang ● dcm.reregisterConnectorUnitReference(parentUnit, portName, result); } – Meta-variables return result; } else $recpoint$ ● ${a}, ${a[index]} $final$ throw new ElementLinkException(quot;Invalid port 'quot;+portName+quot;'.quot;); – Meta-queries $end$ ${a.b.c} ● Meta-statements – $set, $if, $include, $foreach, $rforeach 17 ●

Solution - DSL Special meta-statements ● Simple templates inheritance (extends) – Extension points ($extPoint$) – Allow define points in template which can be extended in a ● child template Method templates – Important for implementing component interfaces ● ! component iface is not known when template is designing ! – Language should provides information about iface ● methods ${method.name}, ${method.variables}, ... – 18

Solution - DSL Special meta-statements element console_log extends quot;primitive_default.ellangquot; { ● implements interface ${ports.port(name=in).signature} { Simplemethod template inheritance (extends) templates { – ${method.declareReturnValue} ExtensionSystem.out.println(quot;method > ${method.name} < calledquot;); points ($extPoint$) – Allow define points in template which can be extended in a $if (method.returnVar) $ ● child template${method.returnVar} = this.target.${method.name}(${method.variables}); – Method templates $else$ this.target.${method.name}(${method.variables}); ● Important for implementing component interfaces $end$ ! component iface is not known when needed //generates return statemene if it is templates is designing ! – Language should provides information about iface ${method.returnStm} ● } methods } } ${method.name}, ${method.variables}, ... – 19

Solution – template structure ElLang-J = mixture of ElLang and Java ● package ${package}; import org . . . runtime .* ; element console_log extends “primitive_default.ellang” { public ${classname} { / / constructor } implements interface ElementLocalClient { public void bindElPort(String portName , Object target ) { /* ... */ } } implements interface ${ ports.port (name=line).signature} { method template { } } 20

Solution – generator architecture Java part ● Prepares low-level connector configuration – Description of connector element internals ● Stratego part ● Generates source code – From template written in ElLang-J ● From L-LCC passed from Java part of generator ● 21

Solution - Java part Implementing action interface ● JimplGeneratorInterface rewrites Low-Level – Connector configuration into XML and passed it to Stratego part Just defines new action for – script controlling generation Bridge between Java and ● Stratego: JNI – Shell (execute connector – 22 generator)

Solution – Java v. Stratego part low-level connector ● configuration Describes ports ● Name – Type (provided, required, – remote) Resolved port signature – List of subelements ● Name – Implementing class – Bindings between ● subelements Selects template for ● implementation 23

Solution – Stratego part Pipe line of several small ● transformation components Input XML preprocessor – Template parser – Template evaluation – Target code gen. – Query component – All of them transform and ● produce AST (in ATerms) 24

Solution – Query module Provides access to input XML (contains L-LCC) ● Simple queries à la XPath – Traversing XML ● ${ports.port.name} – ● conditions ● ${ports.port(name=call).signature} – ● Returns signature of port called “call” Count operator ● – ${elements.element#count} ● Returns number of sub-elements 25

Solution – evaluation module Pipe-line of evaluation modules ● Processing extends – Processing imports – Template adjustment – Normalization of statements with different notations ● e.g. If -> If-Else ( in ATerms: If(cond,body) -> If(cond, body, [])) – Queries evaluation – Meta-statements evaluation – 26

Evaluation (pro-and-con) Advantages ● Simple template which has at least the same power as the – previous solution Shown by implementing all connectors elements into new ● templates Extensible template language (e.g. ElLang-C#) – New generator can be used just by modifying script – controlling connector generation Disadvantages ● Stratego/XT is C-based, rest of generator is in Java – ? Java implementation of Stratego ? ● Annoying long-time compilation of longer Stratego programs – Should be fixed in new release of Stratego ● 27

Future work Byte code manipulation ● To avoid need of javac (~SDK) during deployment – process Templates are precompiled into binary form – Presented and implemented in master thesis – “Optimizing performance of software connectors code generator”, Pavel Petřek Simplifying connectors ● Merging generated Java classes – Implements ElLang-C# ● 28 Improve method templates ●

Results T. Bureš, M. Malohlava, P. Hnětynka “Using ● DSL for Automatic Generation of Software Connector” Accepted at 7th IEEE International Conference on – Composition Based Software Systems (ICCBSS), Madrid, February 2008 29

Using Stratego/XT for generation of software connectors.

by Michal Malohlava

Accessibility

Categories

Upload Details

Usage Rights

2 Embeds 15

Statistics