Esempio n. 1
0
        public override ASTNode VisitMethod([NotNull] CoolParser.MethodContext context)
        {
            MethodNode node = new MethodNode(context);

            IdNode idMethod = new IdNode(context, context.ID().GetText());

            node.Id = idMethod;

            node.Arguments = (from x in context.formal() select Visit(x) as FormalNode).ToList();

            var typeReturn = new TypeNode(context.TYPE().Symbol.Line, context.TYPE().Symbol.Column, context.TYPE().GetText());

            node.TypeReturn = typeReturn;

            node.Body = Visit(context.expression()) as ExpressionNode;
            return(node);
        }
Esempio n. 2
0
        public override AST_Node VisitMethod([NotNull] CoolParser.MethodContext context)
        {
            AST_Id                   id     = new AST_Id(context.ID(), context.ID().GetText());
            AST_Type_Node            type   = new AST_Type_Node(context.TYPE(), context.TYPE().GetText());
            List <AST_ClassProperty> param  = new List <AST_ClassProperty>();
            AST_Expresion            corpus = (AST_Expresion)Visit(context.expr());

            foreach (var item in context.formal())
            {
                var iid             = new AST_Id(item.ID(), item.ID().GetText());
                var ity             = new AST_Type_Node(item.TYPE(), item.TYPE().GetText());
                var formald         = new AST_FormalDec(item, iid, ity);
                AST_ClassProperty i = new AST_ClassProperty(item, formald, null);
                param.Add(i);
            }
            return(new AST_MethodDef(context, id, type, new AST_ListProp(context, param), corpus));
        }
        public override ASTNode VisitMethod([NotNull] CoolParser.MethodContext context)
        {
            var methodNode = new MethodNode(context);

            methodNode.Id = new IdNode(context.ID().Symbol.Line, context.ID().Symbol.Column, context.ID().GetText());

            var formalNodes = new List <FormalNode>();

            foreach (var x in context.formal())
            {
                formalNodes.Add(Visit(x) as FormalNode);
            }
            methodNode.Arguments = formalNodes;

            methodNode.TypeReturn = new TypeNode(context.TYPE().Symbol.Line, context.TYPE().Symbol.Column, context.TYPE().GetText());

            methodNode.Body = Visit(context.expr()) as ExpressionNode;

            return(methodNode);
        }
 /// <summary>
 /// Visit a parse tree produced by <see cref="CoolParser.method"/>.
 /// <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 VisitMethod([NotNull] CoolParser.MethodContext context)
 {
     return(VisitChildren(context));
 }
Esempio n. 5
0
 /// <summary>
 /// Enter a parse tree produced by <see cref="CoolParser.method"/>.
 /// <para>The default implementation does nothing.</para>
 /// </summary>
 /// <param name="context">The parse tree.</param>
 public virtual void EnterMethod([NotNull] CoolParser.MethodContext context)
 {
 }