Translating Natural Semantics to Meta-Modelica Emil Carlsson Sammanfattning/Introduktion • • • • Modelica RML (Naturlig Semantik) Meta-Modelica Översättare Agenda • Bakgrund – Modelica – Parsning och Kompilatorer • Problemformulering • Meta-programmering – Koncept – RML – Meta-Modelica Agenda (forts.) • Implementation – – – – – – Översikt RML-parser RML-unparser Kommentarhantering Translator Meta-Modelica unparser • Slutsats • Frågor Agenda status • Bakgrund – Modelica – Parsning och Kompilatorer • • • • • Problemformulering Meta-programmering Implementation Slutsats Frågor Bakgrund - Modelica • Programmeringspråket Modelica – Modelering och simulering – Objekt Orienterat – Stöd för komponentbaserad design – Starkt typat, inga sidoeffekter. Bakgrund - Modelica (forts.) • Utveckling av Modelica – Modelica Association – OpenModelica – Kommersiell Dymola och MathModelica Bakgrund - Modelica (forts.) • Utökning av Modelica – Meta-programmering – Meta-Modelica Agenda status • Bakgrund – Modelica – Parsning och Kompilatorer • • • • • Problemformulering Meta-programmering Implementation Slutsats Frågor Bakgrund - Parsning • Kompilator • Faser • 3 faser kompilator används i detta exjobb Bakgrund - Parsning (forts.) • Lexikal analys (scanning) – Gruppering av nyckelord, identifierare etc. – Tokens – Reguljära utryck: {digit} [0-9]* Bakgrund - Parsning • Syntaktisk analys (parsning) – a := a + 1; (forts.) Agenda status • • • • • • Bakgrund Problemformulering Meta-programmering Implementation Slutsats Frågor Problem Formulering • • • • RML och meta-programmering RML-parser Utökning av Modelica Implementation – RML-unparser – RML till Meta-Modelica Translator (Översättare) Agenda status • Bakgrund • Problemformulering • Meta-programmering – Koncept – RML – Meta-Modelica • Implementation • Slutsats • Frågor Meta-programmering - Koncept • Design och modifikation(!) av andra programmerings språk • Tar ett annat program (object-program) • Traverserar och modifierar interna strukturen • Returnerar den modifierade strukturen • Lagrar träd representation (ast) av program Agenda status • Bakgrund • Problemformulering • Meta-programmering – Koncept – RML – Meta-Modelica • Implementation • Slutsats • Frågor Meta-programmering - RML • RML (Relational Meta Language) – – – – Naturlig Semantik Relationer Regler med premisser och konklusioner Datatyper Meta-programmering - RML • Moduler – Interface del – Implementerings del – Datatyper, relationer, typdeklarationer, values (konstanter) • Uniontypes – Nyckelord datatype följt av namn: datatype Exp = (forts.) Meta-programmering - RML (forts.) • Uniontypes (forts) – Konstruktor namn följt av en lista med typer: INTPAIR of int * int • Exempel: datatype Exp = INT of int | | | | BINARY of Exp * BinOp * Exp UNARY of UnOp * Exp ASSIGN of Ident * Exp IDENT of Ident datatype BinOp = ADD | SUB | MUL | DIV datatype UnOp = NEG Meta-programmering - RML • Primitiva typer – char – string – int – real – bool • Typdeclarationer: type ident = string (forts.) Meta-programmering - RML (forts.) • Datastrukturer (parametriserade typer) – list ex: int list – vector, array ex: int vector – option ex: int option – Kombineras: int vector list option • Listor: – [e1, e2] eller list(e1, e2) – [] eller nil – element::lst eller cons(element,lst) Meta-programmering - RML • Relationer – Nyckelord relation – Signatur (int => Exp) • Regler – Nyckelord rule – premiser – konklution (forts.) Meta-programmering - RML (forts.) • Exempel: relation apply_unop: (UnOp,int) => int = rule int_neg(v) => v2 -------------------apply_unop(NEG,v) => v2 end Meta-programmering - RML (forts.) relation eval: Exp => real = axiom eval( RCONST(ival) ) => ival (* eval of an integer node *) rule eval(e1) => v1 & eval(e2) => v2 & real_add(v1,v2) => v3 ---------------------------------------------------------eval( ADDop(e1,e2) ) => v3 rule eval(e1) => v1 & eval(e2) => v2 & real_sub(v1,v2) => v3 ---------------------------------------------------------eval( SUBop(e1,e2) ) => v3 rule eval(e1) => v1 & eval(e2) => v2 & real_mul(v1,v2) => v3 ---------------------------------------------------------eval( MULop(e1,e2) ) => v3 rule eval(e1) => v1 & eval(e2) => v2 & real_div(v1,v2) => v3 ---------------------------------------------------------eval( DIVop(e1,e2) ) => v3 rule eval(e) => v1 & real_neg(v1) => v2 (*aa*) ----------------------------------eval( NEGop(e) ) => v2 (*ss*) end Agenda status • Bakgrund • Problemformulering • Meta-programmering – Koncept – RML – Meta-Modelica • Implementation • Slutsats • Frågor Meta-programmering - Meta-Modelica • Paket – public eller protected • Typer – Integer, String, Real, Boolean • Parametriserade typer behöver typ deklareras, exempelvis: type IntegerList = list<Integer>; IntegerList int_list; /* int_list is a list of Integers */ Meta-programmering - Meta-Modelica • Listor – {e1,e2} eller list(e1, e2) – {} eller nil – element::lst eller cons(element, lst) • Unions typer – nyckelord uniontype – record Meta-programmering - Meta-Modelica public uniontype Exp record INT Integer integer; end INT; record BINARY Exp exp1; BinOp binop2; Exp exp3; end BINARY; record UNARY UnOp unop; Exp exp; end UNARY; record ASSIGN Ident ident; Exp exp; end ASSIGN; record IDENT Ident ident; end IDENT; end Exp; public uniontype BinOp record ADD end ADD; record SUB end SUB; record MUL end MUL; record DIV end DIV; end BinOp; public uniontype UnOp record NEG; end NEG; end UnOp; Meta-programmering - Meta-Modelica • Funktioner – algoritm sektion – matchcontinue – case statement • Case statement – nyckelord case följt av match utryck – equation statements – then resultat uttryck Meta-programmering - Meta-Modelica protected function neg_int input Integer in_v; output Integer out_v; algorithm out_v:= matchcontinue(in_v) local v1; case(v1) then -v1; end matchcontinue; end neg_int; protected function neg_int input Integer v1; output Integer v2; algorithm v2 := -v1; end neg_int; Agenda status • • • • Bakgrund Problemformulering Meta-programmering Implementation – – – – – – Översikt RML-parser RML-unparser Kommentarhantering Translator Meta-Modelica unparser • Slutsats • Frågor Implementation - Översikt Agenda status • • • • Bakgrund Problemformulering Meta-programmering Implementation – – – – – – Översikt RML-parser RML-unparser Kommentarhantering Translator Meta-Modelica unparser • Slutsats • Frågor Implementation - RML parser • Preliminär parser existerade • Scanner skriven i C • Parser yacc byttes till bison Agenda status • • • • Bakgrund Problemformulering Meta-programmering Implementation – – – – – – Översikt RML-parser RML-unparser Kommentarhantering Translator Meta-Modelica unparser • Slutsats • Frågor Implementation - RML unparser • Traversa parse-träd • Skriver ut innehållet i trädet Agenda status • • • • Bakgrund Problemformulering Meta-programmering Implementation – – – – – – Översikt RML-parser RML-unparser Kommentarhantering Translator Meta-Modelica unparser • Slutsats • Frågor Implementation - kommentarhantering • Problem – Kommentarer tillåts över allt – Går ej skriva sådan parser-grammatik • Egen lösning: – kommentarer lagras i struct med information: struct CommentInfo { int bound; /* is a bound? (used to mark next datastructure)*/ int firstline, firstcol; /* start position of this comment */ int lastline, lastcol; /* end position of this comment */ char buffer[LEXER_COMMENT_MAXLENGTH]; }; Implementation - kommentarhantering (forts.) • Andra Problem – Scanner state kommit långt nog? – Till vilken datastruktur hör kommentaren? Agenda status • • • • Bakgrund Problemformulering Meta-programmering Implementation – – – – – – Översikt RML-parser RML-unparser Kommentarhantering Translator Meta-Modelica unparser • Slutsats • Frågor Implementation - Translator • Skillnader mellan RML och Meta-Modelica – – – – Variabler Typdeklarationer Namnkonflikter Kommentarer • Hänseende till läsbarhet och enkelhet – Bra och smarta identifierarnamn – Enkel kod och få genererade lines – Läsbar kod Implementation - Translator (forts.) • Moduler blir paket • Datatype blir uniontype – Variabel namn för varje typ • först x1, x2 etc • baserade på typ • baserade på kommentar Implementation - Translator (forts.) (* The basic element type in Modelica *) datatype Element = ELEMENT of bool (* final *) * bool (* replaceable *) * InnerOuter (* inner/outer *) * Ident (* Element name *) * ElementSpec (* Actual element specification*) * string (* Source code file *) * int (* Line number *) * ConstrainClass option (* only valid for classdef and component*) uniontype Element " - Elements The basic element type in Modelica " record ELEMENT Boolean final "final "; Boolean replaceable "replaceable "; InnerOuter innerouter "inner/outer "; Ident ident "Element name "; ElementSpec elementspec "Actual element specification"; String string "Source code file "; Integer integer "Line number "; ConstrainClassOption constrainclassoption "only valid for classdef and component"; end ELEMENT; end Element; Implementation - Translator (forts.) • Relationer till funktioner – public eller protected – Signaturer till Input/Output variabler – rules till Meta-Modelica case statements • Program databas (PDB) – Behövs för att bestämma typ på variabler – Position och typ för identifiers Implementation - Translator (forts.) • Identifiers – checka så inte Modelica nyckelord – konstruktor eller variabel • Special genererade typer – Vilka har genererats? Implementation - Translator (forts.) • Lokala variabler – Samla in alla variabler i relationen – Lagra i TypeVarsElement datatype TypeVarsElement = VTELEMENT of Absyn.RMLType * Absyn.Ident list – Relation för att uppdatera – Variabler slås upp i program databasen – Samma namn olika typ Implementation - Translator (forts.) • Rules till case-statement – Uttryck och mönster – Fördefinierade relationer – Skippa sista tilldelningen z = z + 1; then z; – Istället then z + 1; Implementation - Translator (forts.) • Förenklad algoritm sektion används då – endast identifierare som input och utput – endast en regel Implementation - Translator (forts.) relation eval: Exp => real = axiom eval( RCONST(ival) ) => ival (* eval of an integer node *) rule eval(e1) => v1 & eval(e2) => v2 & real_add(v1,v2) => v3 ---------------------------------------------------------eval( ADDop(e1,e2) ) => v3 rule eval(e1) => v1 & eval(e2) => v2 & real_sub(v1,v2) => v3 ---------------------------------------------------------eval( SUBop(e1,e2) ) => v3 ... end Implementation - Translator (forts.) public function eval " Abstract syntax of the language Exp1 Evaluation semantics of Exp1 " input Exp in_exp; output Integer out_integer; algorithm out_integer:= matchcontinue (in_exp) local Integer ival,v1,v2; Exp e1,e2,e; case (INTconst(ival)) then ival; " eval of an integer node is the integer itself " case (ADDop(e1,e2)) equation v1 = eval(e1); v2 = eval(e2); then v1 + v2; case (SUBop(e1,e2)) equation v1 = eval(e1); v2 = eval(e2); then v1 - v2; ... end matchcontinue; end eval; Implementation - Translator (forts.) • Kommentarer – ” escapas till \” – relation till function – * tas bort • Options – Utbyggbart – Prefixing – Dummy variabler Agenda status • • • • Bakgrund Problemformulering Meta-programmering Implementation – – – – – – Översikt RML-parser RML-unparser Kommentarhantering Translator Meta-Modelica unparser • Slutsats • Frågor Implementation - Unparser • Modelica unparser implementerad i Modelica kompilatorn • Anpassad till Meta-Modelica Agenda status • • • • • • Bakgrund Problemformulering Meta-programmering Implementation Slutsats Frågor Slutsats • Testing – RML exempel – Modelica kompilatorn • Kvar att göra – Prestandaförbättring • Alternativ till listor - träd, hashtabell eller dylikt • cachning – Refactorings Agenda status • • • • • • Bakgrund Problemformulering Meta-programmering Implementation Slutsats Frågor Tack! Frågor