Translating natural semantics to Meta-Modelica

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