diff --git a/.gitignore b/.gitignore index b3fe7b7..f27ef5d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,68 +1,72 @@ # Compiled Object files *.slo *.lo *.o *.obj # Compiled Dynamic libraries *.so *.so.* *.dylib *.dll # Compiled Static libraries *.lai *.la *.a *.lib # Executables *.exe *.out *.app *.class # Mobile Tools for Java (J2ME) .mtj.tmp/ # Package Files # *.jar *.war *.ear # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* # Qt-es /.qmake.cache /.qmake.stash *.pro.user *.pro.user.* *.moc moc_*.cpp qrc_*.cpp ui_*.h Makefile* *-build-* # QtCreator *.autosave coco/*.old coco/*~ *~ cpp/build-*/* cpp/xreate-debug/* cpp/xreate-release/* cpp/.idea cpp/CMakeLists.txt.user* hs/* project/* nb*.xml .* target/* -/tools/phabricator/xreate-frontend/nbproject/private/ \ No newline at end of file +/tools/phabricator/xreate-frontend/nbproject/private/ +documentation/trash4/ +CMakeFiles/ +gen-cpp/ +gen-php diff --git a/coco/Taste-example.ATG b/coco/Taste-example.ATG deleted file mode 100644 index 1ada837..0000000 --- a/coco/Taste-example.ATG +++ /dev/null @@ -1,147 +0,0 @@ -COMPILER Taste - -Proc curProc; // current program unit (procedure or main program) - -CHARACTERS - letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz". - digit = "0123456789". - cr = '\r'. - lf = '\n'. - tab = '\t'. - -TOKENS - ident = letter {letter | digit}. - number = digit {digit}. - -COMMENTS FROM "/*" TO "*/" NESTED -COMMENTS FROM "//" TO lf - -IGNORE cr + lf + tab - - - -PRODUCTIONS - -/*=================== Program and declarations ============================*/ - -Taste (. String name; .) -= "program" - Ident (. curProc = new Proc(name, null, this); .) - "{" - { VarDecl | ProcDecl } - "}" (. for (Obj obj: curProc.locals) { - if (obj instanceof Proc) ((Proc)obj).dump(); - } .). -/*------------------------------------------------------------------------*/ -VarDecl (. String name; Type type; .) -= Typ - Ident (. curProc.add(new Var(name, type)); .) - { ',' Ident (. curProc.add(new Var(name, type)); .) - } ';'. -/*------------------------------------------------------------------------*/ -Typ -= (. type = Type.INT; .) - ( "int" - | "bool" (. type = Type.BOOL; .) - ). -/*------------------------------------------------------------------------*/ -ProcDecl (. String name; .) -= "void" - Ident (. Proc oldProc = curProc; - curProc = new Proc(name, oldProc, this); - oldProc.add(curProc); .) - '(' ')' - Block (. curProc = oldProc; .). - - -/*============================= Statements ===============================*/ - -Block (. Stat s; .) -= '{' (. b = new Block(); .) - { Stat (. b.add(s); .) - | VarDecl - } - '}' - . -/*------------------------------------------------------------------------*/ -Stat (. String name; Expr e; Stat s2; Block b; .) -= (. s = null; .) -( Ident (. Obj obj = curProc.find(name); .) - ( '=' - Expr ';' (. s = new Assignment(obj, e); .) - | '(' ')' ';' (. s = new Call(obj); .) - ) - -| "if" - '(' Expr ')' - Stat (. s = new If(e, s); .) - [ "else" Stat (. s = new IfElse(s, s2); .) - ] - -| "while" - '(' Expr ')' - Stat (. s = new While(e, s); .) - -| "read" - Ident ';' (. s = new Read(curProc.find(name)); .) - -| "write" - Expr ';' (. s = new Write(e); .) - -| Block (. s = b; .) -). - - - -/*============================ Expressions ===============================*/ - -Expr (. Operator op; Expr e2; .) -= SimExpr - [ RelOp - SimExpr (. e = new BinExpr(e, op, e2); .) - ]. -/*------------------------------------------------------------------------*/ -SimExpr (. Operator op; Expr e2; .) -= Term - { AddOp - Term (. e = new BinExpr(e, op, e2); .) - }. -/*------------------------------------------------------------------------*/ -Term (. Operator op; Expr e2; .) -= Factor - { MulOp - Factor (. e = new BinExpr(e, op, e2); .) - }. -/*------------------------------------------------------------------------*/ -Factor (. String name; .) -= (. e = null; .) - ( Ident (. e = new Ident(curProc.find(name)); .) - | number (. e = new IntCon(Integer.parseInt(t.val)); .) - | '-' Factor (. e = new UnaryExpr(Operator.SUB, e); .) - | "true" (. e = new BoolCon(true); .) - | "false" (. e = new BoolCon(false); .) - ). -/*------------------------------------------------------------------------*/ -Ident -= ident (. name = t.val; .). -/*------------------------------------------------------------------------*/ -AddOp -= (. op = Operator.ADD; .) - ( '+' - | '-' (. op = Operator.SUB; .) - ). -/*------------------------------------------------------------------------*/ -MulOp -= (. op = Operator.MUL; .) - ( '*' - | '/' (. op = Operator.DIV; .) - ). -/*------------------------------------------------------------------------*/ -RelOp -= (. op = Operator.EQU; .) - ( "==" - | '<' (. op = Operator.LSS; .) - | '>' (. op = Operator.GTR; .) - ). - -END Taste. diff --git a/coco/Taste-example.TAS b/coco/Taste-example.TAS deleted file mode 100644 index ff122d6..0000000 --- a/coco/Taste-example.TAS +++ /dev/null @@ -1,31 +0,0 @@ - -// This is a test program which can be compiled by the Taste-compiler. -// It reads a sequence of numbers and computes the sum of all integers -// up to these numbers. - -program Test { - int i; - - void Foo() { - int a, b, max; - read a; read b; - if (a > b) max = a; else max = b; - write max; - } - - void SumUp() { - int sum; - sum = 0; - while (i > 0) { sum = sum + i; i = i - 1; } - write sum; - } - - void Main() { - read i; - while (i > 0) { - SumUp(); - read i; - } - } -} - diff --git a/coco/gen-grammar b/coco/gen-grammar index 814c770..66a5acd 100755 --- a/coco/gen-grammar +++ b/coco/gen-grammar @@ -1 +1,4 @@ -cococpp -frames ./generator-frames ./xreate.ATG +COCO_PATH=/opt/coco-cpp/ + +echo "Run coco generator: " +$COCO_PATH/Coco ./xreate.ATG -frames $COCO_PATH diff --git a/coco/xreate.ATG b/coco/xreate.ATG index 242d665..afc8fda 100644 --- a/coco/xreate.ATG +++ b/coco/xreate.ATG @@ -1,518 +1,549 @@ //TODO add ListLiteral //TODO ExprTyped: assign default(none) type #include "ast.h" #include "ExternLayer.h" #include #include #define wprintf(format, ...) \ char __buffer[100]; \ wcstombs(__buffer, format, 100); \ fprintf(stderr, __buffer, __VA_ARGS__) using namespace xreate; using namespace std; COMPILER Xreate xreate::AST root; // current program unit struct { std::stack scopesOld; xreate::CodeScope* scope = nullptr; } context; void pushContextScope(CodeScope* scope){ context.scopesOld.push(context.scope); context.scope = scope; } void popContextScope(){ context.scope = context.scopesOld.top(); context.scopesOld.pop(); } int skipIdent() { int kind = 0; scanner->ResetPeek(); while ((kind = scanner->Peek()->kind) == _colon) if (scanner->Peek()->kind != _ident) return 0; return kind; } bool checkParametersList() { return la->kind == _ident && skipIdent() == _lparen; } bool checkInfix() { return la->kind == _ident && skipIdent() == _ident; } bool checkIndex() { return la->kind == _ident && skipIdent() == _lbrack; } bool checkFuncDecl() { if (la->kind != _ident) return false; int xkind = skipIdent(); Token* y = scanner->Peek(); return xkind == _assign && (y->kind == _function || y->kind == _pre); } bool checkAssignment() { scanner->ResetPeek(); Token* x = scanner->Peek(); return la->kind == _ident && x->kind == _assign; } CHARACTERS letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz". any = ANY - '"'. digit = "0123456789". cr = '\r'. lf = '\n'. tab = '\t'. TOKENS ident = (letter | '_') {letter | digit | '_'}. number = digit {digit}. string = '"' { any } '"'. function = "function". pre = "pre". lparen = '('. rparen = ')'. lbrack = '['. rbrack = ']'. lcurbrack = '{'. rcurbrack = '}'. equal = "==". assign = '='. implic = '-' '>'. colon = ':'. context = "context". tagcolon = "::". + lse = "<=". + lss = "<". + gte = ">=". + gtr = ">". + + ne1 = "!=". + ne2= "<>". + COMMENTS FROM "/*" TO "*/" NESTED COMMENTS FROM "//" TO lf IGNORE cr + lf + tab PRODUCTIONS Xreate = (. Function* function; .) { ( RuleDecl | InterfaceData | Imprt | ContextSection | IF(checkFuncDecl()) FDecl (. root.add(function); .) | TDecl ) }. Ident = ident {':' ident} (. name = t->val; .). - - -FDecl = (. std::wstring fname; std::wstring varname; TypeAnnotation typIn; TypeAnnotation typOut; bool flagIsPrefunct = false; .) +FDecl = (. std::wstring fname; std::wstring argName; TypeAnnotation typIn; TypeAnnotation typOut; bool flagIsPrefunct = false; Expression binding; .) Ident assign [pre (. flagIsPrefunct = true; .)] function (. f = new Function(fname); f->isPrefunction = flagIsPrefunct; CodeScope* entry = f->getEntryScope(); .) -['(' Ident tagcolon Type (. f->addArg(std::move(varname), move(typIn)); .) -{',' Ident tagcolon Type (. f->addArg(std::move(varname), move(typIn));.) +['(' Ident tagcolon ExprAnnotations (. f->addBinding(Atom(argName), move(binding)); .) +{',' Ident tagcolon ExprAnnotations (. f->addBinding(Atom (argName), move(binding));.) } ')'] [ tagcolon ( IF(flagIsPrefunct) FnTag | Type (. f->setReturnType(typOut); .) ) {';' FnTag }] -BDecl (. entry->__body.bindType(move(typOut));.) +BDecl (. entry->getBody().bindType(move(typOut));.) . ContextSection<>= (. Expression context; Function* f; .) "case" "context" tagcolon MetaSimpExpr lcurbrack { FDecl (. f->guardContext = context; root.add(f); .) } rcurbrack. /** * TYPES * */ TypeTerm = (. std::wstring tid; .) - ("string" | "int" | "num" | "float" | "bool") (. typ = Atom(t->val); .) - . + ("string" | "num" | "int" | "i8" | "i32" | "float" | "bool") (. typ = Atom(t->val); .) +. Type = (. TypeAnnotation typ2; TypeAtom typ3; std::wstring tid, field; .) ( TList | TStruct | TypeTerm (. typ = TypeAnnotation(typ3); .) |IF (checkIndex()) Ident lbrack Ident (. typ = TypeAnnotation(TypeOperator::ACCESS, {}); typ.__valueCustom = Atom(tid).get(); typ.fields.push_back(Atom(field).get()); .) {',' Ident (. typ.fields.push_back(Atom(field).get()); .) } rbrack | Ident (. typ = TypeAnnotation(TypeOperator::CUSTOM, {}); typ.__valueCustom = Atom(tid).get(); .) ['(' Type (. typ.__operator = TypeOperator::CALL; typ.__operands.push_back(typ2); .) {',' Type (. typ.__operands.push_back(typ2); .) } ')'] ) . TList = (. TypeAnnotation ty; .) '[' Type (. typ = TypeAnnotation(TypeOperator::ARRAY, {ty}); .) {',' Type (. typ.__operator = TypeOperator::TUPLE; typ.__operands.push_back(ty); .) }']' . TStruct = (. TypeAnnotation t; std::wstring field; .) '{' Ident tagcolon Type (. typ = TypeAnnotation(TypeOperator::STRUCT, {t}); typ.fields.push_back(Atom(field).get()); .) {',' Ident tagcolon Type} (. typ.__operands.push_back(t); typ.fields.push_back(Atom(field).get()); .) '}'. TDecl = (. std::wstring ttag; TypeAnnotation t, t1; std::wstring tname, arg; std::vector> args; .) Ident assign "type" ( "alias" Type (. root.add(move(t), Atom(tname)); .) | "variant" lparen Ident (. t = TypeAnnotation(TypeOperator::VARIANT, {}); args.push_back(Atom(arg)); .) {',' Ident (. args.push_back(Atom(arg)); .) } rparen (. t.addFields(move(args)); root.add(move(t), Atom(tname)); .) | Ident ['(' Ident (. args.push_back(Atom(arg)); .) {',' Ident (. args.push_back(Atom(arg)); .) } ')'] Type (. t.addBindings(move(args)); root.add(move(t), Atom(tname)); .) ) '.' . -VDecl = (. std::wstring vname; Expression e; TypeAnnotation typ;.) -Ident assign ExprTyped - (. f->addDeclaration(move(vname), move(typ), move(e)); .) +VDecl = (. std::wstring vname; Expression e;.) +Ident assign ExprTyped (. f->addDeclaration(Atom(vname), move(e)); .) . ContextDecl = (. Expression tag; .) context tagcolon -MetaSimpExpr (. scope->tags.push_back(move(tag)); .) -{';' MetaSimpExpr (. scope->tags.push_back(move(tag)); .) +MetaSimpExpr (. scope->tags.push_back(tag); .) +{';' MetaSimpExpr (. scope->tags.push_back(tag); .) }. //TODO forbid multiple body declaration (ExprTyped) -BDecl = (. Expression body; TypeAnnotation typ; pushContextScope(scope); .) +BDecl = (. Expression body; pushContextScope(scope); .) '{' { (RuleContextDecl | ContextDecl '.' | IF(checkAssignment()) VDecl '.' - | ExprTyped (. scope->setBody(body); popContextScope();.) + | ExprTyped (. scope->setBody(body); popContextScope();.) )} '}'. -IfDecl = (. Expression cond; ManagedScpPtr blockTrue = root.add(new xreate::CodeScope(context.scope)); ManagedScpPtr blockFalse = root.add(new xreate::CodeScope(context.scope)); TypeAnnotation typIf; .) -"if" '(' Expr ')' tagcolon Type BDecl<&*blockTrue> "else" BDecl<&*blockFalse> -(. e = Expression(Operator::IF, {cond}); e.addBlock(blockTrue); e.addBlock(blockFalse); e.bindType(move(typIf)); .) +IfDecl = (. Expression cond; ManagedScpPtr blockTrue = root.add(new xreate::CodeScope(context.scope)); ManagedScpPtr blockFalse = root.add(new xreate::CodeScope(context.scope)); .) +"if" '(' Expr ')' (. e = Expression(Operator::IF, {cond}); .) +tagcolon ExprAnnotations +BDecl<&*blockTrue> "else" BDecl<&*blockFalse> (. e.addBlock(blockTrue); e.addBlock(blockFalse); .) . -LoopDecl = - (. Expression eIn, eAcc, eFilters; std::wstring varEl, varAcc, contextClass; TypeAnnotation typEl, typAcc; +LoopDecl = + (. Expression eIn, eAcc, eFilters; std::wstring varEl, varAcc, contextClass; Expression tagsEl; ManagedScpPtr block = root.add(new xreate::CodeScope(context.scope)); .) "loop" - ("map" '(' Expr implic Ident tagcolon Type ')' tagcolon Type BDecl<&*block> - (. e = Expression(Operator::MAP, {eIn}); + ("map" '(' Expr implic Ident (. e = Expression(Operator::MAP, {eIn}); .) + tagcolon ExprAnnotations ')' tagcolon ExprAnnotations BDecl<&*block> + (. e.addBindings({Atom(varEl)}); - block->addArg(Atom(varEl), move(typEl)); - e.addBlock(block); .) - |"fold" '(' Expr implic Ident tagcolon Type ['|' Expr ] ',' Expr implic Ident')' tagcolon Type BDecl<&*block> - (. e = Expression(Operator::FOLD, {eIn, eAcc}); - e.addBindings({Atom(varEl), Atom(varAcc)}); - block->addArg(Atom(varEl), move(typEl)); - block->addArg(Atom(varAcc), move(typOut)); - e.addBlock(block); - .) - + block->addBinding(Atom(varEl), move(tagsEl)); + e.addBlock(block); + .) + + |"fold" + ("inf" '(' Expr implic Ident ')' + (. + e = Expression(Operator::FOLD_INF, {eAcc}); + e.addBindings({Atom(varAcc)}); + .) + tagcolon ExprAnnotations BDecl<&*block> + (. + block->addBinding(Atom(varAcc), Expression()); + e.addBlock(block); + .) + + | '(' Expr implic Ident tagcolon ExprAnnotations ['|' Expr ] ',' Expr implic Ident')' + (. + e = Expression(Operator::FOLD, {eIn, eAcc}); + e.addBindings({Atom(varEl), Atom(varAcc)}); + .) + tagcolon ExprAnnotations BDecl<&*block> + (. + + block->addBinding(Atom(varEl), move(tagsEl)); + block->addBinding(Atom(varAcc), Expression()); + e.addBlock(block); + .) + ) | "context" '(' string (. contextClass = t->val; .) ')' BDecl<&*block> (. e = Expression(Operator::LOOP_CONTEXT, {Expression(Atom(std::move(contextClass)))}); e.addBlock(block); .) ). SwitchDecl = (. TypeAnnotation typ; eSwitch = Expression(Operator::SWITCH, {}); Expression eCondition; Expression tag;.) ["switch" - ("ad" "hoc" lparen Expr tagcolon MetaSimpExpr rparen (. eSwitch.op = Operator::SWITCH_ADHOC; eSwitch.operands.push_back(eCondition); eSwitch.tags.emplace(tag.getValueString(), move(tag)); .) - | lparen Expr rparen tagcolon Type (. eSwitch.operands.push_back(eCondition); eSwitch.type = typ; .) + ( "ad" "hoc" lparen Expr tagcolon MetaSimpExpr rparen (. eSwitch.op = Operator::SWITCH_ADHOC; eSwitch.operands.push_back(eCondition); eSwitch.tags.emplace(tag.getValueString(), move(tag)); .) + | lparen Expr rparen tagcolon ExprAnnotations (. eSwitch.operands.push_back(eCondition);.) ) ] CaseDecl {CaseDecl} . CaseDecl = (. ManagedScpPtr scope = root.add(new xreate::CodeScope(context.scope)); .) "case" ( "default" BDecl<&*scope> (. Expression exprCase(Operator::CASE_DEFAULT, {}); exprCase.addBlock(scope); outer.operands.insert(++outer.operands.begin(), exprCase); .) | CaseParams<&*scope> (. ManagedScpPtr scopeBody = root.add(new xreate::CodeScope(&*scope)); .) BDecl<&*scopeBody> (. Expression exprCase(Operator::CASE, {}); exprCase.addBlock(scope); exprCase.addBlock(scopeBody); outer.addArg(move(exprCase)); .) ). CaseParams = (. Expression e; Expression guard(Operator::LOGIC_AND, {}); pushContextScope(scope); .) CaseParam {',' CaseParam } (. scope->setBody(guard); popContextScope(); .). -CaseParam = (. TypeAnnotation argtyp; Expression condition; .) +CaseParam = (. Expression condition; .) ( IF(checkAssignment()) VDecl - | ExprTyped (. guard.addArg(move(condition)); .) + | ExprTyped (. guard.addArg(move(condition)); .) ). SequenceDecl = "sequence" ListLiteral (. sequence.setOp(Operator::SEQUENCE); .). /*============================ INTERFACES ===============================*/ Imprt<> = "import" "raw" lparen string (. root.__rawImports.push_back(Atom(t->val).get()); .) rparen . InterfaceData<> = "interface" '(' ( "dfa" ')' InterfaceDFA | "extern-c" ')' InterfaceExternC | "cfa" ')' InterfaceCFA | "adhoc" ')' InterfaceAdhoc ). InterfaceAdhoc<> = '{' [ PrefunctionSchemeDecl ] '}'. PrefunctionSchemeDecl<> = (. TypeAnnotation typReturn; std::wstring prefName; Expression exprCases; .) pre function Ident tagcolon Type '{' SwitchDecl '}' (. Expression prefData(Operator::CALL, {Atom(prefName), exprCases}); prefData.type = typReturn; root.addInterfaceData(Adhoc, move(prefData)); .). InterfaceExternC<> = (.xreate::ExternData data; .) '{' {IncludeExternDecl | LibExternDecl } '}' (. root.addExternData(move(data)); .) . LibExternDecl = (. std::wstring pkgname, libname; .) Ident assign "library" tagcolon "pkgconfig" '(' string (. pkgname = t->val; .) ')' '.' (. data.addLibrary(Atom(libname), Atom(pkgname)); .) . IncludeExternDecl = (. Expression inc; .) "include" StructLiteral '.' (. data.addIncludeDecl(move(inc)); .) . InterfaceDFA<> = '{' { InstructDecl } '}' . InstructDecl = (.Operator op; Expression tag; Expression scheme; std::vector& tags = scheme.operands; tags.push_back(Expression()); /* return value */ .) "operator" InstructAlias tagcolon '(' (.scheme.setOp(op); .) [ MetaSimpExpr (. tags.push_back(tag); .) { ',' MetaSimpExpr (. tags.push_back(tag); .) } ] ')' [ implic MetaSimpExpr (. tags[0] = tag; .) ] (. root.addDFAData(move(scheme)); .) '.'. InstructAlias = ( "map" (. op = Operator::MAP; .) | "list_range" (. op = Operator::LIST_RANGE; .) | "list" (. op = Operator::LIST; .) | "fold" (. op = Operator::FOLD; .) | "index" (. op = Operator::INDEX; .) ). InterfaceCFA<> = '{' { InstructCFADecl } '}' . InstructCFADecl<> = (.Operator op; Expression tag; Expression scheme; std::vector& tags = scheme.operands; .) "operator" InstructAlias tagcolon (. scheme.setOp(op); .) [ MetaSimpExpr (. tags.push_back(tag); .) { ',' MetaSimpExpr (. tags.push_back(tag); .) } ] '.' (. root.addInterfaceData(CFA, move(scheme)); .). /*============================ METAPROGRAMMING ===============================*/ // TagsDecl = (. Expression tag; TagModifier mod = TagModifier::NONE; .) // ':' { MetaSimpExpr (. /*f.addTag(std::move(tag), mod); */ .) // }. FnTag = (. Expression tag; TagModifier mod = TagModifier::NONE; .) MetaSimpExpr ['-' TagMod] (. f->addTag(std::move(tag), mod); .). TagMod = ( "assert" (. mod = TagModifier::ASSERT; .) | "require" (. mod = TagModifier::REQUIRE; .) ). RuleDecl<> = "rule" tagcolon (. RuleArguments args; RuleGuards guards; DomainAnnotation typ; std::wstring arg; .) '(' Ident tagcolon Domain (. args.add(arg, typ); .) {',' Ident tagcolon Domain (. args.add(arg, typ); .) } ')' ["case" RGuard {',' RGuard}] '{' RBody '}' . /* - TODO use RGuard for guards-*/ RuleContextDecl = (.Expression eHead, eGuards, eBody; .) "rule" "context" tagcolon MetaSimpExpr "case" MetaSimpExpr '{' MetaSimpExpr '}' (.scope->contextRules.push_back(Expression(Operator::CONTEXT_RULE, {eHead, eGuards, eBody})); .). Domain = ( "function" (. dom = DomainAnnotation::FUNCTION; .) | "variable" (. dom = DomainAnnotation::VARIABLE; .) ). RGuard= (. Expression e; .) MetaExpr (. guards.add(std::move(e)); .). MetaExpr= (.Operator op; Expression e2; .) MetaExpr2 [MetaOp MetaExpr2 (. e = Expression(op, {e, e2}); .) ]. MetaExpr2= ( '(' MetaExpr ')' | MetaSimpExpr ). MetaSimpExpr= (. std::wstring i1, infix; Expression e2; .) ( '-' MetaSimpExpr (. e = Expression(Operator::NEG, {e2}); .) | IF(checkParametersList()) Ident (. e = Expression(Operator::CALL, {Expression(Atom(i1))}); .) '(' [ CalleeParams ] ')' | IF(checkInfix()) Ident Ident MetaSimpExpr (. e = Expression(Operator::CALL, {Expression(Atom(infix))}); e.addArg(Expression(Atom(i1))); e.addArg(std::move(e2)); .) | Ident (. e = Expression(Atom(i1)); .) ). RBody = (. Expression e; std::wstring msg; .) "warning" MetaExpr ["message" string (. msg = t->val; .) ] (. root.add(new RuleWarning(RuleArguments(args), RuleGuards(guards), std::move(e), Atom(msg))); .) . MetaOp< Operator& op> = implic (. op = Operator::IMPL; .) . /*============================ Expressions ===============================*/ - -ExprTyped = (. Expression tag; .) - Expr [tagcolon Type (. e.bindType(move(typ)); .) - {';' MetaSimpExpr (. e.tags.emplace(tag.getValueString(), move(tag)); .) - - }] -. +ExprAnnotations = (. TypeAnnotation typ; Expression tag; e.tags.clear();.) +Type (. e.bindType(move(typ)); .) + {';' MetaSimpExpr (. e.tags.emplace(tag.getValueString(), tag); .) + }. + +ExprTyped = Expr [tagcolon ExprAnnotations]. Expr< Expression& e> (. Operator op; Expression e2; .) -= SimExpr< e> - [ RelOp< op> -SimExpr< e2> (. e = Expression(op, {e, e2}); .) += SimExpr + [ RelOp +SimExpr (. e = Expression(op, {e, e2}); .) ]. SimExpr< Expression& e> (. Operator op; Expression e2; .) = Term< e> { AddOp< op> Term< e2> (. e = Expression(op, {e, e2});.) }. Term< Expression& e> (. Operator op; Expression e2; .) = Factor< e> { MulOp< op> Factor< e2> (. e = Expression(op, {e, e2}); .) }. -Factor< Expression& e> (. std::wstring name; TypeAnnotation typ; .) +Factor< Expression& e> (. std::wstring name; e = Expression(); .) = (IF (checkParametersList()) Ident< name> (. e = Expression(Operator::CALL, {Atom(name)}); .) '(' [CalleeParams] ')' |IF (checkIndex()) Ident lbrack CalleeParams rbrack (. e.setOp(Operator::INDEX); e.setValue({Atom(name)}); .) | Ident< name> (. e = Expression(Atom(name)); root.recognizeVariantIdentifier(e); .) | ListLiteral (. /* tuple */.) - | StructLiteral (. /* struct */.) + | StructLiteral (. /* struct */.) | SequenceDecl - | LoopDecl - | IfDecl + | LoopDecl + | IfDecl | SwitchDecl | AdhocDecl | number (. e = Expression(Atom(t->val)); .) | string (. e = Expression(Atom(t->val)); .) | '-' Factor< e> (. e = Expression(Operator::NEG, {e}); .) - | '(' Expr ')' + | '(' ExprTyped ')' ). StructLiteral = (. std::wstring key; Expression val; std::list> keys; .) '{' Ident '=' Expr (. keys.push_back(Atom(key)); e = Expression(Operator::LIST_NAMED, {val}); .) - {',' Ident '=' Expr (.e.addArg(move(val)); keys.push_back(Atom(key)); .) + {',' Ident '=' Expr (.e.addArg(Expression(val)); keys.push_back(Atom(key)); .) } '}' (. e.addBindings(keys.begin(), keys.end()); .) . ListLiteral = (. Expression eFrom, eTo; .) '[' -[ Expr (. e.addArg(std::move(eFrom)); .) -(".." Expr (. e.addArg(std::move(eTo)); e.setOp(Operator::LIST_RANGE); .) - |{',' Expr (. e.addArg(std::move(eFrom)); .) +[ Expr (. e.addArg(Expression(eFrom)); .) +(".." Expr (. e.addArg(Expression(eTo)); e.setOp(Operator::LIST_RANGE); .) + |{',' Expr (. e.addArg(Expression(eFrom)); .) } (. e.setOp(Operator::LIST); .) ) ] ']'. AdhocDecl = (. Expression command; .) "ad" "hoc" Expr (. e.setOp(Operator::ADHOC); e.addArg(std::move(command)); .). -CalleeParams = (. Expression e2; TypeAnnotation typ; .) - ExprTyped (. e.addArg(std::move(e2)); .) - {',' ExprTyped (. e.addArg(std::move(e2)); .) +CalleeParams = (. Expression e2; .) + ExprTyped (. e.addArg(Expression(e2)); .) + {',' ExprTyped (. e.addArg(Expression(e2)); .) }. AddOp< Operator& op> = (. op = Operator::ADD; .) ( '+' | '-' (. op = Operator::SUB; .) ). MulOp< Operator& op> = (. op = Operator::MUL; .) ( '*' | '/' (. op = Operator::DIV; .) ). RelOp< Operator& op> -= (. op = Operator::EQU; .) += (. op = Operator::EQU; .) ( equal - | '<' (. op = Operator::LSS; .) - | '>' (. op = Operator::GTR; .) + | (ne1 | ne2) (. op = Operator::NE; .) + + | lse (. op = Operator::LSE; .) + | lss (. op = Operator::LSS; .) + + | gte (. op = Operator::GTE; .) + | gtr (. op = Operator::GTR; .) + ). END Xreate. diff --git a/config/default.json b/config/default.json index 08e9bd6..8cbfb4f 100644 --- a/config/default.json +++ b/config/default.json @@ -1,59 +1,73 @@ { "containers": { "id": { "implementations": "impl_fulfill_cluster", "clusters": "var_cluster", "prototypes": "proto_cluster", "linkedlist": "linkedlist" }, "impl": { "solid": "solid", "onthefly": "on_the_fly" } }, "logging": { "id": "logging" }, "function-entry": "entry", "clasp": { "bindings" : { "variable": "bind", "function": "bind_func", "scope": "bind_scope", "function_demand" : "bind_function_demand", "scope_decision": "bind_scope_decision" }, + "context" : { + "decisions":{ + "dependent": "resolution_dependency" + }, + }, + "nonevalue": "nonevalue", "ret": { "symbol": "retv", "tag": "ret" } }, "tests": { - "template": "context", + "template": "default", "templates": { - "basic": "EntryFunction*", "default": "*-", - "types": "Types*-", + + "basic": "Basic.*", + "ast": "AST.*", + "cfa": "CFA.*", + "dfa": "DFA.*", + "compilation": "Compilation.*", "containers": "Containers*-", - "ast": "AST*", - "non-containers": "*-Containers*", + "diagnostic": "Diagnostic.*", + "serializer": "ExpressionSerializer.*", + "externc": "InterfaceExternC.*", + "context": "ExpressionSerializer.*:Context.*", + "types": "Types.*-", "log": "Logging*", - "clang": "ClangAPI*", - "cfg": "CFG.*", - "skip": "SkipDetection*", + "clang": "ClangAPI.*", + "skip": "SkipDetection*:Adhoc_Loop_SkipDetection.*", "raw-xml": "libxml2*", "xml": "Xml.*", - "adhocs": "ExpressionSerializer.*:Adhoc.*:Context.*", - "context": "ExpressionSerializer.*:Context.*", - "installation": "Compilation.*:Sprint1.*" + "installation": "Compilation.*:Sprint1.*", + "exploitation": "Exploitation.*", + "loops": "Loop.*", + "dsl": "Interpretation.*", + "adhocs": "Adhoc.*", } } } diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt index b64dbed..71152a3 100644 --- a/cpp/src/CMakeLists.txt +++ b/cpp/src/CMakeLists.txt @@ -1,228 +1,225 @@ cmake_minimum_required(VERSION 2.8.11) project(xreate) cmake_policy(SET CMP0022 NEW) # BUILD OPTIONS #====================== set(XREATE_DEFINITIONS -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -DWITH_THREADS=1 ) add_definitions(${XREATE_DEFINITIONS}) add_compile_options(-Winvalid-pch -std=c++14 -fPIC) # LLVM #====================== FIND_PACKAGE (LLVM REQUIRED CONFIG PATHS /opt/llvm-3.8.0-0.x86_64/usr/share/llvm/cmake NO_DEFAULT_PATH) set (CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake-tools") #include(PCH_GCC4_v2) set(LLVM_VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}) message ("LLVM LIB PATH:" ${LLVM_LIBRARY_DIRS}) set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}) message ("MPATH:" ${CMAKE_MODULE_PATH}) message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}") message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}") message(STATUS "INCLUDE DIR: ${LLVM_INCLUDE_DIRS}") INCLUDE_DIRECTORIES(${LLVM_INCLUDE_DIRS}) message("LLVM defs: " ${LLVM_DEFINITIONS}) add_definitions(${LLVM_DEFINITIONS}) llvm_map_components_to_libnames(LLVM_LIBS core nativecodegen native executionengine mcjit support) message("LLVM libs: " ${LLVM_LIBS}) # CLANG #====================== set(CLANG_LIBS ${LLVM_LIBRARY_DIRS}/libclangCodeGen.so ${LLVM_LIBRARY_DIRS}/libclangASTMatchers.so ${LLVM_LIBRARY_DIRS}/libclangQuery.so ${LLVM_LIBRARY_DIRS}/libclangTooling.so ${LLVM_LIBRARY_DIRS}/libclangFrontend.so ${LLVM_LIBRARY_DIRS}/libclangSerialization.so ${LLVM_LIBRARY_DIRS}/libclangDriver.so ${LLVM_LIBRARY_DIRS}/libclangParse.so ${LLVM_LIBRARY_DIRS}/libclangSema.so ${LLVM_LIBRARY_DIRS}/libclangAnalysis.so ${LLVM_LIBRARY_DIRS}/libclangAST.so ${LLVM_LIBRARY_DIRS}/libclangEdit.so ${LLVM_LIBRARY_DIRS}/libclangLex.so ${LLVM_LIBRARY_DIRS}/libclangBasic.so ) #find_package(Clang REQUIRED clangTooling libClang) message(STATUS "CLANG LIBS: " ${CLANG_LIBS}) # POTASSCO #====================== set(POTASSCO_PATH "/opt/potassco/clingo" CACHE PATH "Path to potassco sources") set(POTASSCO_INCLUDE_PATH ${POTASSCO_PATH}/libgringo ${POTASSCO_PATH}/libclasp ${POTASSCO_PATH}/libclingo ${POTASSCO_PATH}/libprogram_opts ${POTASSCO_PATH}/liblp ) INCLUDE_DIRECTORIES(${POTASSCO_INCLUDE_PATH}) set (LIBCLASP_PATH ${POTASSCO_PATH}/build/debug) set(LIBCLASP_LIBS clingo clasp gringo program_opts reify lp ) message(STATUS "CLASP LIBS: " ${LIBCLASP_LIBS}) link_directories(${LIBCLASP_PATH}) # OTHER DEPENDENCIES #=========================== set(JEAYESON_INCLUDE_PATH ${CMAKE_HOME_DIRECTORY}/../vendors/jeayeson/include/ ) INCLUDE_DIRECTORIES(${JEAYESON_INCLUDE_PATH}) # COCO #=========================== set(COCO_PATH ${CMAKE_HOME_DIRECTORY}/../coco/) set(COCO_SOURCE_FILES ${COCO_PATH}/Parser.cpp ${COCO_PATH}/Scanner.cpp) INCLUDE_DIRECTORIES(${COCO_PATH}) add_custom_command(OUTPUT ${COCO_SOURCE_FILES} COMMAND ${COCO_PATH}/gen-grammar WORKING_DIRECTORY ${COCO_PATH} MAIN_DEPENDENCY ${COCO_PATH}/xreate.ATG ) message(STATUS "COCO GRAMMAR BUILD STATUS:" ${COCO_OUTPUT}) # XREATE #====================== set(SOURCE_FILES pass/compilepass.cpp + pass/interpretationpass.cpp + compilation/targetinterpretation.cpp ast.cpp ExternLayer.cpp attachments.cpp - pass/interpretationpass.cpp - compilation/targetinterpretation.cpp analysis/cfagraph.cpp analysis/dfagraph.cpp analysis/aux.cpp compilation/containers.cpp compilation/advanced.cpp compilation/transformations.cpp analysis/DominatorsTreeAnalysisProvider.cpp clasplayer.cpp compilation/latecontextcompiler2.cpp query/context.cpp #compilation/latecontextcompiler.cpp serialization/expressionserializer.cpp serialization/expressionserializer2.cpp llvmlayer.cpp utils.cpp passmanager.cpp pass/abstractpass.cpp pass/dfapass.cpp pass/cfapass.cpp pass/loggerpass.cpp pass/adhocpass.cpp #pass/rulespass.cpp # query/containers.cpp query/ptrvalid.cpp contextrule.cpp - - #${POTASSCO_PATH}/app/shared/src/clingocontrol.cc - #${POTASSCO_PATH}/app/pyclingo/src/clingo_lib.cc ) set(XREATE_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/ ) INCLUDE_DIRECTORIES(${XREATE_INCLUDE_DIRS}) set(XREATE_PRIVATE_INCLUDE_DIRS ${XREATE_INCLUDE_DIRS} ${COCO_PATH} ${JEAYESON_INCLUDE_PATH} ${LLVM_INCLUDE_DIRS} ${POTASSCO_INCLUDE_PATH} ) add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES} ${COCO_SOURCE_FILES}) target_link_libraries(${PROJECT_NAME} ${LIBCLASP_LIBS}) target_include_directories(${PROJECT_NAME} INTERFACE ${XREATE_INCLUDE_DIRS} ${COCO_PATH} ${JEAYESON_INCLUDE_PATH} ${LLVM_INCLUDE_DIRS} ${POTASSCO_INCLUDE_PATH} ) get_directory_property(DEFINITIONS_ALL DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS) message("definitions all: " ${DEFINITIONS_ALL}) target_compile_definitions(${PROJECT_NAME} INTERFACE ${DEFINITIONS_ALL}) get_directory_property(COMPILATION_OPTIONS_ALL DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS) message("compilations all: " ${COMPILATION_OPTIONS_ALL}) target_compile_options(${PROJECT_NAME} INTERFACE ${COMPILATION_OPTIONS_ALL}) SET_PROPERTY(TARGET ${PROJECT_NAME} PROPERTY INTERFACE_LINK_LIBRARIES ${LLVM_LIBS} ${CLANG_LIBS} tbb ) #set (LINK_INTERFACE_LIBRARIES "") # FUNCTION(PREPEND var prefix) # SET(listVar "") # FOREACH(f ${ARGN}) # LIST(APPEND listVar "${prefix}/${f}") # ENDFOREACH(f) # SET(${var} "${listVar}" PARENT_SCOPE) # ENDFUNCTION(PREPEND) #set(COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "-j4") #cotire(xreate) # MACRO (ADD_PCH_RULE _header_filename _src_list) # SET(_gch_filename "${_header_filename}.gch") # LIST(APPEND ${_src_list} ${_gch_filename}) # SET (_args ${CMAKE_CXX_FLAGS}) # LIST(APPEND _args -c ${_header_filename} -o ${_gch_filename}) # GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES) # foreach (_inc ${DIRINC}) # LIST(APPEND _args "-I" ${_inc}) # endforeach(_inc ${DIRINC}) # SEPARATE_ARGUMENTS(_args) # add_custom_command(OUTPUT ${_gch_filename} # COMMAND rm -f ${_gch_filename} # COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} ${_args} # DEPENDS ${_header_filename}) # ENDMACRO(ADD_PCH_RULE _header_filename _src_list) # ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/ast.h SOURCE_FILES) # ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/llvmlayer.h SOURCE_FILES) # ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/clasplayer.h SOURCE_FILES) # ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/pass/abstractpass.h SOURCE_FILES) diff --git a/cpp/src/ExternLayer.cpp b/cpp/src/ExternLayer.cpp index 48f3f85..8874a23 100644 --- a/cpp/src/ExternLayer.cpp +++ b/cpp/src/ExternLayer.cpp @@ -1,299 +1,310 @@ // // Created by pgess on 4/21/15. // #include "ExternLayer.h" #include #include #include "clang/Tooling/Tooling.h" #include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/CodeGenOptions.h" #include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/PreprocessorOptions.h" #include #include #include #include "../../vendors/clang-codegen-private-3.8/CodeGenModule.h" using namespace xreate; using namespace std; using namespace clang; using namespace clang::driver; using namespace clang::tooling; using namespace clang::ast_matchers; using namespace llvm; class FinderCallbackTypeDecl : public MatchFinder::MatchCallback { public : QualType typeResult; virtual void run(const MatchFinder::MatchResult &Result) { if (const TypedefDecl* decl = Result.Nodes.getNodeAs("typename")) { typeResult = decl->getUnderlyingType(); } } }; class FinderCallbackFunction : public MatchFinder::MatchCallback { public : QualType typeResult; virtual void run(const MatchFinder::MatchResult &Result) { if (const FunctionDecl* decl = Result.Nodes.getNodeAs("function")) { typeResult = decl->getType(); } } }; void ExternData::addLibrary(Atom&& name, Atom&& package) { __dictLibraries.emplace(name.get(), package.get()); } void ExternData::addIncludeDecl(Expression&& e) { assert(e.op == Operator::LIST_NAMED); //TODO ?? implement Expression parsing(Array of Expr as vector); for(size_t i=0, size=e.operands.size(); i headers; std::transform(listHeaders.operands.begin(), listHeaders.operands.end(), std::inserter(headers, headers.end()), [](const Expression& o){ assert(o.__state == Expression::STRING); return o.getValueString(); }); entries.emplace_back(ExternEntry{package, std::move(headers)}); } } void ExternLayer::addExternalData(const std::vector& data){ entries.insert(entries.end(), data.begin(), data.end()); } ExternLayer::ExternLayer(LLVMLayer *llvm) : __llvm(llvm) {} std::vector ExternLayer::fetchPackageFlags(const ExternEntry& entry){ std::vector args; FILE* flags = popen((string("pkg-config --cflags ") + entry.package).c_str(), "r"); size_t linesize=0; char* linebuf=0; ssize_t linelen=0; while ((linelen=getdelim(&linebuf, &linesize, ' ', flags))>0) { if (linebuf[0]=='\n') continue; if (linelen==1 && linebuf[0]==' ') continue; - if (linebuf[linelen-1 ] == ' ') - linebuf[linelen-1] = 0; + //cut unwanted symbols at the end + char symbLast = linebuf[linelen-1 ]; + if (symbLast == ' ' || symbLast == '\n') linebuf[linelen-1] = 0; + + //print header for debug purposes llvm::outs() << '<' << linebuf << "> "; - args.push_back(linebuf); + args.push_back(linebuf); free(linebuf); linebuf = 0; } + pclose(flags); return (args); } std::vector ExternLayer::fetchPackageLibs(const ExternEntry& entry){ std::vector libs; FILE* flags = popen((string("pkg-config --libs ") + entry.package).c_str(), "r"); size_t linesize=0; char* linebuf=0; ssize_t linelen=0; while ((linelen=getdelim(&linebuf, &linesize, ' ', flags))>0) { - if (linebuf[0]=='\n') continue; - if (linelen==1 && linebuf[0]==' ') continue; - if (linebuf[linelen-1 ] == ' ') - linebuf[linelen-1] = 0; - if (linelen>=2 && linebuf[0] == '-' && linebuf[1] == 'l'){ - libs.push_back(linebuf + 2); - } else { - libs.push_back(linebuf); - } + if (linebuf[0]=='\n') continue; + if (linelen==1 && linebuf[0]==' ') continue; + + //cut unwanted symbols at the end + char symbLast = linebuf[linelen-1 ]; + if (symbLast == ' ' || symbLast == '\n') linebuf[linelen-1] = 0; - llvm::outs() << '<' << linebuf << "> "; - free(linebuf); - linebuf = 0; + //cut unwanted symbols at the beginning + if (linelen>1 && linebuf[0] == '-' && linebuf[1] == 'l'){ + libs.push_back(linebuf + 2); + + } else { + libs.push_back(linebuf); + } + + //print lib name for debug purposes + llvm::outs() << '<' << linebuf << "> "; + free(linebuf); + linebuf = 0; } + pclose(flags); return (libs); } void ExternLayer::loadLibraries(vector&& libs){ string msgErr; for (const string& lib: libs) { const string& libName = string("lib")+lib+".so"; if (!llvm::sys::DynamicLibrary::LoadLibraryPermanently(libName.c_str(), &msgErr)){ llvm::errs()<<"\n"<<"Loading library "<__externdata); - // TODO use default include path from 'clang -xc++ -E' + // TODO -EXTERN01.DIP, use default include path from 'clang -xc++ -E' list code; std::vector args{ "-I/usr/include" ,"-I/usr/local/include" ,"-I/usr/lib/llvm-3.6/lib/clang/3.6.2/include" // ,"-I/usr/lib/gcc/x86_64-linux-gnu/4.9/include" // ,"-I/usr/include/x86_64-linux-gnu" }; std::vector libs; boost::format formatInclude("#include \"%1%\""); for(const ExternEntry& entry: entries) { llvm::outs()<<"[ExternC] Processing package: "<< entry.package << "\n"; llvm::outs()<<"[ExternC] args: "; vector&& args2 = fetchPackageFlags(entry); args.insert(args.end(), args2.begin(), args2.end()); for(const string arg: args2) { llvm::outs()<< "<" << arg << "> "; } llvm::outs()<<"\n[ExternC] libs: "; args2 = fetchPackageLibs(entry); for(const string arg: args2) { llvm::outs()<< "<" << arg << "> "; } libs.insert(libs.end(), args2.begin(), args2.end()); llvm::outs()<<"\n[ExternC] headers: "; std::transform(entry.headers.begin(), entry.headers.end(), std::inserter(code, code.begin()), [&formatInclude](const string header ) { string line = boost::str(formatInclude % header); llvm::outs()<< "<" << line << "> "; return line; }); llvm::outs() << '\n'; } loadLibraries(move(libs)); ast = buildASTFromCodeWithArgs(boost::algorithm::join(code, "\n"), args); __cgo.reset(new CodeGenOptions); __llvm->module->setDataLayout(ast->getASTContext().getTargetInfo().getDataLayoutString()); - + std::unique_ptr __hso(new HeaderSearchOptions()); std::unique_ptr __ppo(new PreprocessorOptions()); - + __cgm.reset(new CodeGen::CodeGenModule( - ast->getASTContext(), - + ast->getASTContext(), + *__hso, *__ppo, - *__cgo, + *__cgo, *__llvm->module, ast->getASTContext().getDiagnostics())); }; bool ExternLayer::isPointer(const clang::QualType &t) { const clang::Type * tInfo = t.getTypePtr(); assert(tInfo); return tInfo->isAnyPointerType(); } llvm::Type* ExternLayer::toLLVMType(const clang::QualType& t){ return __cgm->getTypes().ConvertType(t); } std::vector ExternLayer::getStructFields(const clang::QualType& ty) { clang::QualType t = ty; if (isPointer(ty)){ const clang::PointerType* tPtr = ty->getAs(); t = tPtr->getPointeeType(); } assert(t.getTypePtr()->isRecordType()); const RecordType *record = t->getAsStructureType(); assert(record); std::vector result; //FieldDecl* field: record->getDecl()->fields() for (auto i=record->getDecl()->field_begin(); i!= record->getDecl()->field_end(); ++i){ result.push_back(i->getName()); } return result; } clang::QualType ExternLayer::lookupType(const std::string& id){ MatchFinder finder; FinderCallbackTypeDecl callbackTypeDecl; auto matcherTypeDecl = typedefDecl(hasName(id)).bind("typename"); finder.addMatcher(matcherTypeDecl, &callbackTypeDecl); finder.matchAST(ast->getASTContext()); assert(! callbackTypeDecl.typeResult.isNull()); return callbackTypeDecl.typeResult; } llvm::Function* ExternLayer::lookupFunction(const std::string& name){ if (__functions.count(name)){ return __functions.at(name); } MatchFinder finder; FinderCallbackFunction callback; auto matcher = functionDecl(hasName(name)).bind("function"); finder.addMatcher(matcher, &callback); finder.matchAST(ast->getASTContext()); if (callback.typeResult.isNull()){ cout <<"[External Layer] " << "Unknown function: "<getTypes().ConvertType(tyFuncQual); llvm::FunctionType* tyRawFunc = llvm::dyn_cast(tyRaw); llvm::Function* function = llvm::Function::Create(tyRawFunc, llvm::GlobalValue::ExternalLinkage, name, __llvm->module); __functions.emplace(name, function); return function; } diff --git a/cpp/src/analysis/dfagraph.cpp b/cpp/src/analysis/dfagraph.cpp index 360035b..7ccf9e0 100644 --- a/cpp/src/analysis/dfagraph.cpp +++ b/cpp/src/analysis/dfagraph.cpp @@ -1,237 +1,250 @@ #include "analysis/dfagraph.h" #include "analysis/aux.h" #include using namespace xreate; using namespace xreate::analysis; using namespace std; -namespace xreate {namespace analysis { -void -DFAGraph::print(std::ostringstream& output) const { - std::set symbols; +namespace xreate { + namespace analysis { + + void + DFAGraph::print(std::ostringstream& output) const { + std::set symbols; + + output << endl << "%\t\tStatic analysis: DFA" << endl; + + std::vector>::const_iterator i1; + std::vector::const_iterator i2; + + boost::format formatDfaConnection("dfa_connection(%1%, %2%, %3%)."); + for (i1 = this->__edges.begin(), i2 = this->__data.begin(); i1 != this->__edges.end(); ++i1, ++i2) { + string edgeName; + switch (*i2) { + case DFGConnection::WEAK: edgeName = "weak"; + break; + case DFGConnection::STRONG: edgeName = "strong"; + break; + case DFGConnection::PROTOTYPE: edgeName = "proto"; + break; + } - output << endl << "%\t\tStatic analysis: DFA" << endl; + output << formatDfaConnection + % formatSymbol(i1->first) + % formatSymbol(i1->second) + % edgeName + << " %" << this->__clasp->getHintForPackedSymbol(i1->first) << " - " << this->__clasp->getHintForPackedSymbol(i1->second) + << endl; - std::vector>::const_iterator i1; - std::vector::const_iterator i2; + symbols.insert(i1->first); + symbols.insert(i1->second); + } - boost::format formatDfaConnection("dfa_connection(%1%, %2%, %3%)."); - for (i1= this->__edges.begin(), i2 = this->__data.begin(); i1!= this->__edges.end(); ++i1, ++i2 ) - { - string edgeName; - switch (*i2) - { - case DFGConnection::WEAK: edgeName = "weak"; break; - case DFGConnection::STRONG: edgeName = "strong"; break; - case DFGConnection::PROTOTYPE: edgeName = "proto"; break; - } + boost::format formatDfaDependency("dfa_dependency(%1%, %2%)."); + for (auto i = this->__dependencies.begin(); i != this->__dependencies.end(); ++i) { + output << formatDfaDependency + % formatSymbol(i->first) + % formatSymbol(i->second) + << " %" + << this->__clasp->getHintForPackedSymbol(i->first) << " - " + << this->__clasp->getHintForPackedSymbol(i->second) + << endl; + } - output << formatDfaConnection - %formatSymbol(i1->first) - %formatSymbol(i1->second) - %edgeName - << " %" <__clasp->getHintForPackedSymbol(i1->first) << " - " << this->__clasp->getHintForPackedSymbol(i1->second) - <& tag : this->__tags) { + for (string variant : xreate::analysis::compile(tag.second)) { + output << formatBind + % formatSymbol(tag.first) + % (variant) + << "%" << this->__clasp->getHintForPackedSymbol(tag.first) + << endl; + } - symbols.insert(i1->first); - symbols.insert(i1->second); - } - - boost::format formatDfaDependency("dfa_dependency(%1%, %2%)."); - for (auto i= this->__dependencies.begin(); i!= this->__dependencies.end(); ++i){ - output<first) - %formatSymbol(i->second) - << " %" - << this->__clasp->getHintForPackedSymbol(i->first) << " - " - << this->__clasp->getHintForPackedSymbol(i->second) - <& tag: this->__tags) - { - for (string variant: xreate::analysis::compile(tag.second)) { - output << formatBind - % formatSymbol(tag.first) - % (variant) - << "%" << this->__clasp->getHintForPackedSymbol(tag.first) - << endl; + symbols.insert(tag.first); + } + + for (const SymbolPacked& s : symbols) { + output << "v(" << formatSymbol(s) << ")." + << " %" << this->__clasp->getHintForPackedSymbol(s) + << endl; + } } - symbols.insert(tag.first); - } + class VisitorAddTag : public boost::static_visitor<> { + public: - for (const SymbolPacked& s: symbols) - { - output << "v(" << formatSymbol(s) << ")." - << " %" << this->__clasp->getHintForPackedSymbol(s) - <__tags.emplace(symbol, move(__tag)); + } -class VisitorAddTag: public boost::static_visitor<> { - public: - void operator()(const SymbolPacked& symbol){ - __graph->__tags.emplace(symbol, move(__tag)); - } + void operator()(SymbolTransient& symbol) { + symbol.tags.push_back(move(__tag)); + } - void operator()(SymbolTransient& symbol){ - symbol.tags.push_back(move(__tag)); - } + void operator()(const SymbolInvalid& symbol) { + assert(false && "Undefined behaviour"); + } - void operator()(const SymbolInvalid& symbol){ - assert(false && "Undefined behaviour"); - } + VisitorAddTag(DFAGraph * const dfagraph, Expression&& tag) : + __graph(dfagraph), __tag(tag) { + } + + private: + DFAGraph * const __graph; + Expression __tag; + }; + + class VisitorAddLink : public boost::static_visitor<> { + public: + + void operator()(const SymbolPacked& nodeFrom) { + if (!__graph->isConnected(__nodeTo, nodeFrom)) { + __graph->__edges.emplace_back(__nodeTo, nodeFrom); + __graph->__data.push_back(__link); + + DFAGraph::EdgeId eid = __graph->__edges.size() - 1; + __graph->__outEdges.emplace(nodeFrom, eid); + } + } + + void operator()(const SymbolTransient& symbolFrom) { + switch (__link) { + case DFGConnection::WEAK: + { + //virtual symbol to hold transient annotations + SymbolPacked symbPivot = __graph->createAnonymousSymbol(symbolFrom.scope); + + __graph->addConnection(symbPivot, symbolFrom, DFGConnection::STRONG); + __graph->addConnection(__nodeTo, symbPivot, DFGConnection::WEAK); + break; + } + + case DFGConnection::STRONG: + { + for (const Expression& tag : symbolFrom.tags) { + __graph->__tags.emplace(__nodeTo, tag); + } + break; + } + + default: + assert(false && "Undefined behavior"); + } + } + + void operator()(const SymbolInvalid&) { + if (__link == DFGConnection::STRONG) return; + if (__link == DFGConnection::WEAK) return; - VisitorAddTag(DFAGraph* const dfagraph, Expression&& tag): - __graph(dfagraph), __tag(tag) {} + assert(false && "Undefined behavior"); + } - private: - DFAGraph* const __graph; - Expression __tag; -}; + VisitorAddLink(DFAGraph * const dfagraph, const SymbolPacked& nodeTo, DFGConnection link) : + __graph(dfagraph), __nodeTo(nodeTo), __link(link) { + } -class VisitorAddLink: public boost::static_visitor<> { -public: - void operator()(const SymbolPacked& nodeFrom){ - if (!__graph->isConnected(__nodeTo, nodeFrom)) + private: + DFAGraph * const __graph; + SymbolPacked __nodeTo; + DFGConnection __link; + }; + + class VisitorGetDependencyConnection : public boost::static_visitor> { - __graph->__edges.emplace_back(__nodeTo, nodeFrom); - __graph->__data.push_back(__link); + public: + + list + operator()(const SymbolPacked & nodeFrom) { + return + { + nodeFrom + }; + } - DFAGraph::EdgeId eid = __graph->__edges.size()-1; - __graph->__outEdges.emplace(nodeFrom, eid); - } - } + list + operator()(const SymbolTransient & nodeFrom) { + return nodeFrom.dependencies; + } - void operator()(const SymbolTransient& symbolFrom){ - switch (__link){ - case DFGConnection::WEAK: { - //virtual symbol to hold transient annotations - SymbolPacked symbPivot = __graph->createAnonymousSymbol(symbolFrom.scope); + list + operator()(const SymbolInvalid&) { + assert(false && "Undefined behavior"); + } - __graph->addConnection(symbPivot, symbolFrom, DFGConnection::STRONG); - __graph->addConnection(__nodeTo, symbPivot, DFGConnection::WEAK); - break; + VisitorGetDependencyConnection(DFAGraph * const g) : graph(g) { } + DFAGraph * const graph; + }; + + class VisitorSetDependencyConnection : public boost::static_visitor<> { + public: + + void operator()(SymbolPacked& nodeTo) { + VisitorGetDependencyConnection visitorGetDepenencies(graph); + auto deps = boost::apply_visitor(visitorGetDepenencies, nodeFrom); - case DFGConnection::STRONG: { - for (const Expression& tag: symbolFrom.tags){ - __graph->__tags.emplace(__nodeTo, tag); + for (const SymbolPacked& dep : deps) { + graph->__dependencies.emplace(nodeTo, dep); } - break; } - default: - assert(false && "Undefined behavior"); - } - } + void operator()(SymbolTransient& nodeTo) { + VisitorGetDependencyConnection visitorGetDepenencies(graph); + auto deps = boost::apply_visitor(visitorGetDepenencies, nodeFrom); - void operator()(const SymbolInvalid&){ - if (__link == DFGConnection::STRONG) return; - if (__link == DFGConnection::WEAK) return; + for (const SymbolPacked& dep : deps) { + nodeTo.dependencies.push_back(dep); + } + } - assert(false && "Undefined behavior"); - } + void operator()(SymbolInvalid&) { + assert(false && "Undefined behavior"); + } - VisitorAddLink(DFAGraph* const dfagraph, const SymbolPacked& nodeTo, DFGConnection link): - __graph(dfagraph), __nodeTo(nodeTo), __link(link) {} + VisitorSetDependencyConnection(DFAGraph * const g, SymbolNode s) : graph(g), nodeFrom(s) { + } + DFAGraph * const graph; + SymbolNode nodeFrom; + }; -private: - DFAGraph* const __graph; - SymbolPacked __nodeTo; - DFGConnection __link; -}; + bool + DFAGraph::isConnected(const SymbolPacked& identifierTo, const SymbolPacked& identifierFrom) { + auto range = __outEdges.equal_range(identifierFrom); -class VisitorGetDependencyConnection: public boost::static_visitor> { -public: - list - operator()(const SymbolPacked& nodeFrom){ - return {nodeFrom}; - } - - list - operator()(const SymbolTransient& nodeFrom){ - return nodeFrom.dependencies; - } - - list - operator()(const SymbolInvalid&){ - assert(false && "Undefined behavior"); - } - - VisitorGetDependencyConnection(DFAGraph* const g): graph(g){} - DFAGraph* const graph; -}; - -class VisitorSetDependencyConnection: public boost::static_visitor<> { -public: - void operator()(SymbolPacked& nodeTo){ - VisitorGetDependencyConnection visitorGetDepenencies(graph); - auto deps = boost::apply_visitor(visitorGetDepenencies, nodeFrom); - - for (const SymbolPacked& dep: deps){ - graph->__dependencies.emplace(nodeTo, dep); + for (std::multimap::iterator edge = range.first; edge != range.second; ++edge) { + if (__edges[edge->second].second == identifierTo) + return true; + } + + return false; } - } - - void operator()(SymbolTransient& nodeTo){ - VisitorGetDependencyConnection visitorGetDepenencies(graph); - auto deps = boost::apply_visitor(visitorGetDepenencies, nodeFrom); - - for (const SymbolPacked& dep: deps){ - nodeTo.dependencies.push_back(dep); + + void + DFAGraph::addConnection(const SymbolPacked& nodeTo, const SymbolNode& nodeFrom, DFGConnection link) { + VisitorAddLink visitor(this, nodeTo, link); + boost::apply_visitor(visitor, nodeFrom); } - } - - void operator()(SymbolInvalid&){ - assert(false && "Undefined behavior"); - } - - VisitorSetDependencyConnection(DFAGraph* const g, SymbolNode s): graph(g), nodeFrom(s){} - DFAGraph* const graph; - SymbolNode nodeFrom; -}; - -bool -DFAGraph::isConnected(const SymbolPacked& identifierTo, const SymbolPacked& identifierFrom) -{ - auto range = __outEdges.equal_range(identifierFrom); - - for(std::multimap::iterator edge = range.first; edge != range.second; ++edge) - { - if (__edges[edge->second].second == identifierTo) - return true; - } - return false; -} - -void -DFAGraph::addConnection(const SymbolPacked& nodeTo, const SymbolNode& nodeFrom, DFGConnection link) { - VisitorAddLink visitor(this, nodeTo, link); - boost::apply_visitor(visitor, nodeFrom); -} - -void -DFAGraph::addDependencyConnection(SymbolNode& identifierTo, SymbolNode& identifierFrom){ - VisitorSetDependencyConnection visitor(this, identifierFrom); - boost::apply_visitor(visitor, identifierTo); -} - -void -DFAGraph::addAnnotation(SymbolNode& node, Expression&& tag) { - VisitorAddTag visitor(this, move(tag)); - boost::apply_visitor(visitor, node); -} - -SymbolPacked -DFAGraph::createAnonymousSymbol(const ScopePacked& scope){ - return SymbolPacked{__countAnonymousSymbols++, scope, true}; -} - -}} \ No newline at end of file + void + DFAGraph::addDependencyConnection(SymbolNode& identifierTo, SymbolNode& identifierFrom) { + VisitorSetDependencyConnection visitor(this, identifierFrom); + boost::apply_visitor(visitor, identifierTo); + } + + void + DFAGraph::addAnnotation(SymbolNode& node, Expression&& tag) { + VisitorAddTag visitor(this, move(tag)); + boost::apply_visitor(visitor, node); + } + + SymbolPacked + DFAGraph::createAnonymousSymbol(const ScopePacked& scope) { + return SymbolPacked{__countAnonymousSymbols++, scope, true}; + } + + } +} \ No newline at end of file diff --git a/cpp/src/ast.cpp b/cpp/src/ast.cpp index 1552a18..27b3468 100644 --- a/cpp/src/ast.cpp +++ b/cpp/src/ast.cpp @@ -1,774 +1,816 @@ #include "ast.h" #include "ExternLayer.h" #include #include #include using namespace std; namespace xreate{ class ExpressionHints{ public: static bool isStringValueValid(const Expression& e){ switch (e.__state){ case Expression::INVALID: case Expression::VARIANT: assert(false); case Expression::IDENT: case Expression::STRING: return true; case Expression::NUMBER: case Expression::BINDING: return false; case Expression::COMPOUND: { switch (e.op){ case Operator::CALL: case Operator::INDEX: return true; default: return false; } } } return false; } static bool isDoubleValueValid(const Expression& e){ switch (e.__state){ case Expression::NUMBER: return true; case Expression::INVALID: case Expression::VARIANT: assert(false); case Expression::IDENT: case Expression::STRING: case Expression::COMPOUND: case Expression::BINDING: return false; } return false; } }; class TypesResolver { private: const AST* ast; std::map scope; std::map signatures; ExpandedType expandType(const TypeAnnotation &t, const std::vector &args = std::vector()){ return TypesResolver(ast, scope, signatures)(t, args); } std::vector expandOperands(const std::vector& operands) { std::vector pack; pack.reserve(operands.size()); std::transform(operands.begin(), operands.end(), std::inserter(pack, pack.end()), [this](const TypeAnnotation& t){ return expandType(t); }); return pack; } public: TypesResolver(const AST* root, const std::map& scopeOuter = std::map(), std::map signaturesOuter = std::map()) : ast(root), scope(scopeOuter), signatures(signaturesOuter) { } ExpandedType operator()(const TypeAnnotation &t, const std::vector &args = std::vector()) { //assert(args.size() == t.bindings.size()); // invalid number of arguments for (size_t i=0; i elTy = expandType(t.__operands.at(0)); return ExpandedType(TypeAnnotation(tag_array, elTy, t.__size)); } case TypeOperator::STRUCT: { assert(t.__operands.size()); std::vector&& pack = expandOperands(t.__operands); auto tnew = TypeAnnotation(TypeOperator::STRUCT, move(pack)); tnew.fields = t.fields; return ExpandedType(move(tnew)); }; case TypeOperator::CALL: { std::string alias = t.__valueCustom; //find in local scope: TypeAnnotation ty; if (scope.count(alias)) { ty = scope.at(alias); } else if (ast->__indexTypeAliases.count(alias)){ ty = ast->__indexTypeAliases.at(alias); } else { assert(false && "Undefined or external type"); } std::vector&& operands = expandOperands(t.__operands); TypeAnnotation signature(TypeOperator::CALL, move(operands)); signature.__valueCustom = alias; if (signatures.count(signature)) { auto link = TypeAnnotation(TypeOperator::LINK, {}); link.conjuctionId = signatures.at(signature); return ExpandedType(move(link)); } int cid = signatures.size(); signatures[signature] = cid; TypeAnnotation tyResult = expandType(ty, operands); tyResult.conjuctionId = cid; return ExpandedType(move(tyResult)); }; case TypeOperator::CUSTOM: { std::string alias = t.__valueCustom; /* if (signatures.count(alias)) { return ExpandedType(TypeAnnotation(TypeOperator::LINK, {t})); } signatures[alias].emplace(t); */ //find in local scope: if (scope.count(alias)) { return expandType(scope.at(alias)); } // find in general scope: if(ast->__indexTypeAliases.count(alias)) { return expandType(ast->__indexTypeAliases.at(t.__valueCustom)); } //if type is unknown keep it as is. return ExpandedType(TypeAnnotation(t)); }; case TypeOperator::ACCESS: { std::string alias = t.__valueCustom; ExpandedType tyAlias= ExpandedType(TypeAnnotation()); //find in local scope: if (scope.count(alias)) { tyAlias = expandType(scope.at(alias)); //find in global scope: } else if((ast->__indexTypeAliases.count(alias))) { tyAlias = expandType(ast->__indexTypeAliases.at(alias)); } else { assert(false && "Undefined or external type"); } assert(tyAlias->__operator == TypeOperator::STRUCT); for (const string& field: t.fields){ auto fieldIt = std::find(tyAlias->fields.begin(), tyAlias->fields.end(), field); assert(fieldIt != tyAlias->fields.end() && "unknown field"); int fieldId = fieldIt - tyAlias->fields.begin(); tyAlias = expandType(tyAlias->__operands.at(fieldId)); } return tyAlias; } case TypeOperator::TUPLE: { assert(t.__operands.size()); std::vector pack; pack.reserve(t.__operands.size()); std::transform(t.__operands.begin(), t.__operands.end(), std::inserter(pack, pack.end()), [this](const TypeAnnotation& t){ return expandType(t); }); return ExpandedType(TypeAnnotation(TypeOperator::TUPLE, move(pack))); } case TypeOperator::VARIANT: { return ExpandedType(TypeAnnotation(t)); } case TypeOperator::NONE: { return ExpandedType(TypeAnnotation(t)); } default: assert(false); } assert(false); return ExpandedType(TypeAnnotation()); } }; TypeAnnotation::TypeAnnotation() { } TypeAnnotation::TypeAnnotation(const Atom &typ) : __value(typ.get()) { ; } TypeAnnotation::TypeAnnotation (TypePrimitive typ) : __value(typ) {} TypeAnnotation::TypeAnnotation(TypeOperator op, std::initializer_list operands) : __operator(op), __operands(operands) { } TypeAnnotation::TypeAnnotation (TypeOperator op, std::vector&& operands) : __operator(op), __operands(operands) {} TypeAnnotation::TypeAnnotation (llvm_array_tag, TypeAnnotation typ, int size) :TypeAnnotation(TypeOperator::ARRAY, {typ}) { __size=size; } bool TypeAnnotation::operator< (const TypeAnnotation& t) const{ if (__operator != t.__operator) return __operator < t.__operator; if (__operator == TypeOperator::NONE) return __value < t.__value; if (__operator == TypeOperator::CALL || __operator == TypeOperator::CUSTOM || __operator == TypeOperator::ACCESS){ if (__valueCustom != t.__valueCustom) return __valueCustom < t.__valueCustom; } return __operands < t.__operands; } /* TypeAnnotation (struct_tag, std::initializer_list) {} */ void TypeAnnotation::addBindings(std::vector>&& params) { bindings.reserve(bindings.size() + params.size()); std::transform(params.begin(), params.end(), std::inserter(bindings, bindings.end()), [](const Atom& ident){return ident.get(); }); } void TypeAnnotation::addFields(std::vector>&& listFields) { fields.reserve(fields.size() + listFields.size()); std::transform(listFields.begin(), listFields.end(), std::inserter(fields, fields.end()), [](const Atom& ident){return ident.get(); }); } Expression::Expression(const Atom& number) : __state(NUMBER), op(Operator::NONE), __valueD(number.get()) { } Expression::Expression(const Atom& a) : __state(STRING), op(Operator::NONE), __valueS(a.get()) { } Expression::Expression(const Atom &ident) : __state(IDENT), op(Operator::NONE), __valueS(ident.get()) { } Expression::Expression(const Operator &oprt, std::initializer_list