Translating Natural Semantics to Meta-Modelica Emil Carlsson.

En presentation över ämnet: "Translating Natural Semantics to Meta-Modelica Emil Carlsson."— Presentationens avskrift:

1 Translating Natural Semantics to Meta-Modelica Emil Carlsson

2 Sammanfattning/Introduktion Modelica RML (Naturlig Semantik) Meta-Modelica Översättare

3 Agenda Bakgrund –Modelica –Parsning och Kompilatorer Problemformulering Meta-programmering –Koncept –RML –Meta-Modelica

4 Agenda (forts.) Implementation –Översikt –RML-parser –RML-unparser –Kommentarhantering –Translator –Meta-Modelica unparser Slutsats Frågor

5 Agenda status Bakgrund –Modelica –Parsning och Kompilatorer Problemformulering Meta-programmering Implementation Slutsats Frågor

6 Bakgrund - Modelica Programmeringspråket Modelica –Modelering och simulering –Objekt Orienterat –Stöd för komponentbaserad design –Starkt typat, inga sidoeffekter.

7 Bakgrund - Modelica (forts.) Utveckling av Modelica –Modelica Association –OpenModelica –Kommersiell Dymola och MathModelica

8 Bakgrund - Modelica (forts.) Utökning av Modelica –Meta-programmering –Meta-Modelica

9 Agenda status Bakgrund –Modelica –Parsning och Kompilatorer Problemformulering Meta-programmering Implementation Slutsats Frågor

10 Bakgrund - Parsning Kompilator Faser 3 faser kompilator används i detta exjobb

11 Bakgrund - Parsning (forts.) Lexikal analys (scanning) –Gruppering av nyckelord, identifierare etc. –Tokens –Reguljära utryck: {digit} [0-9]*

12 Bakgrund - Parsning (forts.) Syntaktisk analys (parsning) – a := a + 1;

13 Agenda status Bakgrund Problemformulering Meta-programmering Implementation Slutsats Frågor

14 Problem Formulering RML och meta-programmering RML-parser Utökning av Modelica Implementation –RML-unparser –RML till Meta-Modelica Translator (Översättare)

15 Agenda status Bakgrund Problemformulering Meta-programmering –Koncept –RML –Meta-Modelica Implementation Slutsats Frågor

16 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

17 Agenda status Bakgrund Problemformulering Meta-programmering –Koncept –RML –Meta-Modelica Implementation Slutsats Frågor

18 Meta-programmering - RML RML (Relational Meta Language) –Naturlig Semantik –Relationer –Regler med premisser och konklusioner –Datatyper

19 Meta-programmering - RML (forts.) Moduler –Interface del –Implementerings del –Datatyper, relationer, typdeklarationer, values (konstanter) Uniontypes –Nyckelord datatype följt av namn: datatype Exp =

20 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

21 Meta-programmering - RML (forts.) Primitiva typer –char –string –int –real –bool Typdeclarationer: type ident = string

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

23 Meta-programmering - RML (forts.) Relationer –Nyckelord relation –Signatur (int => Exp) Regler –Nyckelord rule –premiser –konklution

24 Meta-programmering - RML (forts.) Exempel: relation apply_unop: (UnOp,int) => int = rule int_neg(v) => v2 -------------------- apply_unop(NEG,v) => v2 end

25 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

26 Agenda status Bakgrund Problemformulering Meta-programmering –Koncept –RML –Meta-Modelica Implementation Slutsats Frågor

27 Meta-programmering - Meta-Modelica Paket –public eller protected Typer –Integer, String, Real, Boolean Parametriserade typer behöver typ deklareras, exempelvis: type IntegerList = list ; IntegerList int_list; /* int_list is a list of Integers */

28 Meta-programmering - Meta-Modelica Listor –{e1,e2} eller list(e1, e2) –{} eller nil –element::lst eller cons(element, lst) Unions typer –nyckelord uniontype –record

29 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;

30 Meta-programmering - Meta-Modelica Funktioner –algoritm sektion –matchcontinue –case statement Case statement –nyckelord case följt av match utryck –equation statements –then resultat uttryck

31 Meta-programmering - Meta-Modelica protected function neg_int input Integer v1; output Integer v2; algorithm v2 := -v1; end neg_int; 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;

32 Agenda status Bakgrund Problemformulering Meta-programmering Implementation –Översikt –RML-parser –RML-unparser –Kommentarhantering –Translator –Meta-Modelica unparser Slutsats Frågor

33 Implementation - Översikt

34 Agenda status Bakgrund Problemformulering Meta-programmering Implementation –Översikt –RML-parser –RML-unparser –Kommentarhantering –Translator –Meta-Modelica unparser Slutsats Frågor

35 Implementation - RML parser Preliminär parser existerade Scanner skriven i C Parser yacc byttes till bison

36 Agenda status Bakgrund Problemformulering Meta-programmering Implementation –Översikt –RML-parser –RML-unparser –Kommentarhantering –Translator –Meta-Modelica unparser Slutsats Frågor

37 Implementation - RML unparser Traversa parse-träd Skriver ut innehållet i trädet

38 Agenda status Bakgrund Problemformulering Meta-programmering Implementation –Översikt –RML-parser –RML-unparser –Kommentarhantering –Translator –Meta-Modelica unparser Slutsats Frågor

39 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]; };

40 Implementation - kommentarhantering (forts.) Andra Problem –Scanner state kommit långt nog? –Till vilken datastruktur hör kommentaren?

41 Agenda status Bakgrund Problemformulering Meta-programmering Implementation –Översikt –RML-parser –RML-unparser –Kommentarhantering –Translator –Meta-Modelica unparser Slutsats Frågor

42 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

43 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

44 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;

45 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

46 Implementation - Translator (forts.) Identifiers –checka så inte Modelica nyckelord –konstruktor eller variabel Special genererade typer –Vilka har genererats?

47 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

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

49 Implementation - Translator (forts.) Förenklad algoritm sektion används då –endast identifierare som input och utput –endast en regel

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

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

52 Kommentarer –” escapas till \” –relation till function –* tas bort Options –Utbyggbart –Prefixing –Dummy variabler

53 Agenda status Bakgrund Problemformulering Meta-programmering Implementation –Översikt –RML-parser –RML-unparser –Kommentarhantering –Translator –Meta-Modelica unparser Slutsats Frågor

54 Implementation - Unparser Modelica unparser implementerad i Modelica kompilatorn Anpassad till Meta-Modelica

55 Agenda status Bakgrund Problemformulering Meta-programmering Implementation Slutsats Frågor

56 Slutsats Testing –RML exempel –Modelica kompilatorn Kvar att göra –Prestandaförbättring Alternativ till listor - träd, hashtabell eller dylikt cachning –Refactorings

57 Agenda status Bakgrund Problemformulering Meta-programmering Implementation Slutsats Frågor

58 Tack!

59 Frågor