public override ASTNode VisitProgram([NotNull] CoolParser.ProgramContext context) { return(new ProgramNode(context) { Classes = context.classDefine().Select(x => Visit(x) as ClassNode).ToList() }); }
public override Node VisitProgram([NotNull] CoolParser.ProgramContext context) { var cl = context.classdef(); //bool[] b = new bool[s.Length]; int c = 0; //TODO improve this: /* * in here I do an n^2 iteration through the classdef [] s * n order to add the classes in order of dependencies * meaning this to never add a class before it's parent * I mean I colud sure add the class without parent and then * when it comes up update it but this way seems to be better * since the classes have now a partial order :S ? */ for (int j = 0; j < cl.Length; j++) { for (int i = 0; i < cl.Length; i++) { /* In antlr when there are two IToken of the same type in a single rule production * they provide a method theat returns an array of that kind of tokens * * this is an example: TYPE()=> ITerminalNode[], TYPE(int i) => ith ITerminalNode */ var pname = "Object"; if (cl[i].TYPE(1) != null) // if there is a type from wich this class inherits { pname = cl[i].TYPE(1).GetText(); // take it } //var f= s[i].TYPE(); var name = cl[i].TYPE(0).GetText(); // also take your name if (SymbolTable.Classes.ContainsKey(pname) && !(SymbolTable.Classes.ContainsKey(name))) // If you know my father, and not myself { SymbolTable.Classes.Add(name, new ClassNode(name, SymbolTable.Classes[pname])); //let me introduce myself //b[i] = true; c++; //if (c == cl.Length) // return VisitChildren(context); } } } var s = VisitChildren(context); this.Root = new ProgramNode(context, s); return(this.Root); }
public void Parser_Class_Attr() { string text = @" class A { x : Int; y : Bool; z : Int <- 1 << 20; }; "; var parser = CalcParser(text); CoolParser.ProgramContext tree = parser.program(); var v = tree.children[0]; Assert.IsNotNull(tree); }
public override object VisitProgram([NotNull] CoolParser.ProgramContext context) { p = new ProgramSemantic(); foreach (var child in context.children) { if (child is TerminalNodeImpl) { continue; } string name = ((CoolParser.ClassdefContext)child).TYPE()[0].GetText(); // There is an atempt of type redefinition if (p.Types.ContainsKey(name) && !isDummy(p.Types[name])) { p.Errors.Add(new Error("Types can't be redefined", null)); return(p); } Type type = (Type)Visit(child); p.Types[name] = type; } // This is to remove all the types that were used in the tree but not actually defined in the cool file, they are not cool. foreach (var item in p.Types.TakeWhile(e => isDummy(e.Value))) { p.Types.Remove(item.Key); } foreach (var t in p.Types) { // All types not explicitly inheriting, actually are, from Object if (t.Value.Parent == null && t.Key != "Object") { t.Value.Parent = p.Types["Object"]; p.Types["Object"].Children.Add(t.Value); } } //Run the AST in Program p to update the types of all the nodes //Another check Type_check typer = new Type_check(p); typer.VisitProgram(); return(p); }
public override Node VisitProgram([NotNull] CoolParser.ProgramContext context) { var cl = context.classdef(); //bool[] b = new bool[s.Length]; int c = 0; for (int j = 0; j < cl.Length; j++) { for (int i = 0; i < cl.Length; i++) { /* In antlr when there are two IToken of the same type in a single rule production * they provide a method theat returns an array of that kind of tokens * * this is an example: TYPE()=> ITerminalNode[], TYPE(int i) => ith ITerminalNode */ var pname = "Object"; if (cl[i].TYPE(1) != null) // if there is a type from wich this class inherits { pname = cl[i].TYPE(1).GetText(); // take it } //var f= s[i].TYPE(); var name = cl[i].TYPE(0).GetText(); // also take your name if (SymbolTable.Classes.ContainsKey(pname) && !(SymbolTable.Classes.ContainsKey(name))) // If you know my father, and not myself { SymbolTable.Classes.Add(name, new ClassNode(name, SymbolTable.Classes[pname])); //let me introduce myself //b[i] = true; c++; //if (c == cl.Length) // return VisitChildren(context); } } } var s = VisitChildren(context); this.Root = new ProgramNode(context, s); return(this.Root); }
public void Parser_Calc() { string text = @" 4+5*2; (6*3)/7; 8+9; 9/3; 2*2*2*2 + 5 + 2; true + false; true < 2; 2*2*2*2 = (2+2)*(2+2); true <= false; not (not true + false*true + 0*(1+5+8)/9 + 1/9); (0-1); (0-1)*(0-1); ~(0-1) ; "; var parser = CalcParser(text); CoolParser.ProgramContext tree = parser.program(); CoolVisitor visitor = new CoolVisitor(); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(0)), 14); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(1)), 2); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(2)), 17); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(3)), 3); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(4)), 2 * 2 * 2 * 2 + 5 + 2); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(5)), 1); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(6)), 1); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(7)), 1); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(8)), 0); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(9)), 1); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(10)), -1); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(11)), 1); Assert.AreEqual(visitor.Visit((tree.children[0]).GetChild(12)), 0); }
public override object VisitProgram([NotNull] CoolParser.ProgramContext context) { return(VisitChildren(context)); }
/// <summary> /// Visit a parse tree produced by <see cref="CoolParser.program"/>. /// <para> /// The default implementation returns the result of calling <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/> /// on <paramref name="context"/>. /// </para> /// </summary> /// <param name="context">The parse tree.</param> /// <return>The visitor result.</return> public virtual Result VisitProgram([NotNull] CoolParser.ProgramContext context) { return(VisitChildren(context)); }
/// <summary> /// Exit a parse tree produced by <see cref="CoolParser.program"/>. /// <para>The default implementation does nothing.</para> /// </summary> /// <param name="context">The parse tree.</param> public virtual void ExitProgram([NotNull] CoolParser.ProgramContext context) { }
//private Node Childs; public ProgramNode(CoolParser.ProgramContext context, Node s) : base(s.Childs) { this.context = context; //this.Childs = s; }