C# ParseTreeNode.FindToken方法代码示例

 // Builds an argument for the constructor.
 public static void BuildArgument(IronyParser parser, Constructor method, ParseTreeNode node)
 {
     // Check for a directioned argument (out, ref).
     if (node.Term.ToString() == "out_parameter")
     {
         var a = new DirectionedParameter(null, node.FindToken().Convert());
         switch (node.ChildNodes[0].ChildNodes[0].Term.ToString())
         {
             case "ref":
                 a.Direction = ParameterDirection.Ref;
                 break;
             case "out":
                 a.Direction = ParameterDirection.Out;
                 break;
         }
         a.TypeName = parser.CheckAlias(node.ChildNodes[1].FindTokenAndGetText());
         a.Name = node.ChildNodes[2].FindTokenAndGetText();
         method.Parameters.Add(a);
     }
     else
     {
         // Build an undirectioned argument.
         var a = new SimpleParameter(null, node.FindToken().Convert());
         a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText());
         a.Name = node.ChildNodes[1].FindTokenAndGetText();
         method.Parameters.Add(a);
     }
 }

        // Build property declaration statement
        public static void BuildProperty(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            var property = new Property(parentExpression, currentNode.Token.Convert());
            parentExpression.ChildExpressions.Add(property);

            // If the parent is a module, make the property shared
            var c = parentExpression as Class;
            if (c.IsModule)
            {
                property.IsShared = true;
            }

            // Interpret the modifiers for the property declaration
            InterpretModifiers(root, property, currentNode.ChildNodes[0].ChildNodes[0]);

            // Check for conflicting/invalid property modifiers
            if (property.IsShared && (property.IsFinal || property.IsOverride))
                root.CompilerErrors.Add(new IncompatibleModifiersCompilerError("", currentNode.FindToken().Location.Line,
                    currentNode.FindToken().Location.Position));

            // Find the return type for the property: check if it's generic or an array
            var typeNode = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0];
            if(typeNode.ChildNodes[0].Term.ToString() == "array")
            {
                property.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText();
                property.TypeName = parser.CheckAlias(typeNode.ChildNodes[0].ChildNodes[0].FindTokenAndGetText()) + "[]";
            }
            else if (typeNode.ChildNodes[0].Term.ToString() == "generic_identifier")
            {
                property.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText();
                property.TypeName = typeNode.ChildNodes[0].ChildNodes[0].FindTokenAndGetText() + "<";
                for(int i = 0; i < typeNode.ChildNodes[0].ChildNodes[2].ChildNodes.Count; i++)
                {
                    property.TypeName += typeNode.ChildNodes[0].ChildNodes[2].ChildNodes[i].FindTokenAndGetText();
                    if (i < typeNode.ChildNodes[0].ChildNodes[2].ChildNodes.Count - 1)
                        property.TypeName += ",";
                }
                property.TypeName += ">";
            }
            else
            {
                property.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText();
                property.TypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].FindTokenAndGetText());
            }

            // Build the get block for the property
            parser.ConsumeParseTree(root, property.GetBlock, currentNode.ChildNodes[1]);

            // Build the set block for the property
            parser.ConsumeParseTree(root, property.SetBlock, currentNode.ChildNodes[2]);
        }

        // Build the arguments of the delegate declaration.
        public static void BuildArgument(IronyParser parser, DelegateDeclaration method, ParseTreeNode node)
        {
            if (node.Term.ToString() == "out_parameter")
            {
                var a = new DirectionedParameter(null, node.FindToken().Convert());
                switch (node.ChildNodes[0].ChildNodes[0].Term.ToString())
                {
                    case "ref":
                        a.Direction = ParameterDirection.Ref;
                        break;
                    case "out":
                        a.Direction = ParameterDirection.Out;
                        break;

                }
                a.TypeName = parser.CheckAlias(node.ChildNodes[1].FindTokenAndGetText());
                a.Name = node.ChildNodes[2].FindTokenAndGetText();
                method.Parameters.Add(a);
            }
            else if (node.Term.ToString() == "array_parameter")
            {
                var a = new SimpleParameter(null, node.FindToken().Convert());
                a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText()) + "[]";
                a.Name = node.ChildNodes[3].FindTokenAndGetText();
                method.Parameters.Add(a);
            }
            else if(node.Term.ToString() == "generic_parameter")
            {
                var a = new SimpleParameter(null, node.FindToken().Convert());
                string typeName = node.ChildNodes[0].ChildNodes[0].FindTokenAndGetText() + "<";
                for (int i = 0; i < node.ChildNodes[0].ChildNodes[2].ChildNodes.Count; i++ )
                {

                    typeName += parser.CheckAlias(node.ChildNodes[0].ChildNodes[2].ChildNodes[i].FindTokenAndGetText());
                    if (i < node.ChildNodes[0].ChildNodes[2].ChildNodes.Count - 1)
                        typeName += ",";
                }
                typeName += ">";
                a.TypeName = typeName;
                a.Name = node.ChildNodes[1].FindTokenAndGetText();
                method.Parameters.Add(a);
            }
            else
            {
                var a = new SimpleParameter(null, node.FindToken().Convert());
                a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText());
                a.Name = node.ChildNodes[1].FindTokenAndGetText();
                method.Parameters.Add(a);
            }
        }

        // Builds a "class" expression: really could be a class, struct, or module.
        public static void BuildClass(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            Class c = new Class(parentExpression, currentNode.FindToken().Convert());
            parentExpression.ChildExpressions.Add(c);

            int i = 0;

            // Interpret the declaration modifiers (abstract, public, internal, etc).
            InterpretClassModifiers( root, c, currentNode.ChildNodes[i]);

            i++;

            // Determine if it's a class, module, or struct.
            switch(currentNode.ChildNodes[i].Term.ToString())
            {
                case "module":
                    c.IsModule = true;
                    c.IsFinal = true;
                    c.IsPartial = true;
                    break;
                case "struct":
                    c.IsStruct = true;
                    c.IsModule = false;
                    break;
                default:
                    c.IsStruct = false;
                    c.IsModule = false;
                    break;
            }

            i++;

            // Class name
            c.UnqualifiedName = currentNode.ChildNodes[i].FindTokenAndGetText();

            i++;

            // Get the generic type list.
            if (currentNode.ChildNodes[i].ChildNodes.Count > 0)
            {
                var generics = currentNode.ChildNodes[i].ChildNodes[0].ChildNodes[1];
                foreach (string s in IronyParser.InterpretList(generics))
                    c.GenericTypeNames.Add(s);
            }

            i++;

            // Get the base type list.
            if (currentNode.ChildNodes[i].ChildNodes.Count > 0)
            {
                var baseTypes = currentNode.ChildNodes[i].ChildNodes[0].ChildNodes[0];
                foreach (string s in IronyParser.InterpretList(baseTypes))
                    c.BaseTypeNames.Add(s);
            }

            i+=1;

            // Build the child expressions of the class.
            parser.ConsumeParseTree(root, c, currentNode.ChildNodes[i]);
        }

        // Build a number, string, or character literal: v = 1234
        public static void BuildLiteral(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            var e = new Literal(parentExpression, currentNode.FindToken().Convert());
            parentExpression.ChildExpressions.Add(e);
            e.ParentExpression = parentExpression;

            e.Value = currentNode.Token.Value;
        }

        // Build a namespace expression
        public static void BuildNamespace(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            Namespace n = new Namespace(parentExpression, currentNode.FindToken().Convert());
            n.Name = currentNode.ChildNodes[1].FindTokenAndGetText();
            parentExpression.ChildExpressions.Add(n);

            parser.ConsumeParseTree(root, n, currentNode.ChildNodes[2]);
        }

 // Build an import expression: one for each name imported.
 public static void BuildImport(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
 {
     foreach (var node in currentNode.ChildNodes[1].ChildNodes)
     {
         var i = new Import(parentExpression, currentNode.FindToken().Convert());
         parentExpression.ChildExpressions.Add(i);
         i.ParentExpression = parentExpression;
         i.Name = node.FindTokenAndGetText();
     }
 }

        // Build a boolean literal: v = true
        public static void BuildBoolLiteral(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            var e = new Literal(parentExpression, currentNode.FindToken().Convert());
            parentExpression.ChildExpressions.Add(e);
            e.ParentExpression = parentExpression;

            if (currentNode.ChildNodes[0].FindTokenAndGetText() == "true")
                e.Value = true;
            else
                e.Value = false;
        }

        // Build a method invocation statement (foo(1))
        public static void BuildMethodInvocation(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            var methodInvocation = new MethodInvocation(parentExpression, currentNode.FindToken().Convert());
            methodInvocation.Name = currentNode.ChildNodes[0].FindTokenAndGetText();
            parentExpression.ChildExpressions.Add(methodInvocation);

            // interpret the expressions that are passed to the invocation as arguments
            if (currentNode.ChildNodes[1].ChildNodes.Count > 0)
            {
                foreach (var n in currentNode.ChildNodes[1].ChildNodes)
                {
                    parser.ConsumeParseTree(root, methodInvocation.Parameters, n);

                }
            }
        }

        // Build an if conditional statement.
        public static void BuildIfBlock(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            var i = new IfBlock(parentExpression, currentNode.FindToken().Convert());
            parentExpression.ChildExpressions.Add(i);

            int c = 1;

            // Build the conditional expression
            parser.ConsumeParseTree(root, i.Conditional, currentNode.ChildNodes[c]);

            c++;

            // Build the true block
            parser.ConsumeParseTree(root, i.TrueBlock, currentNode.ChildNodes[c]);

            c++;

            // Build the false block if one exists.
            if(currentNode.ChildNodes[c].ChildNodes.Count != 0)
                parser.ConsumeParseTree(root, i.FalseBlock, currentNode.ChildNodes[c]);
        }

        // Build an assignment statement: i = 0, i += 1, i |= foo, etc
        public static void BuildAssignment(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            var assignment = new Assignment(parentExpression, currentNode.FindToken().Convert());
            parentExpression.ChildExpressions.Add(assignment);

            // Get the expression being assigned to
            parser.ConsumeParseTree(root, assignment, currentNode.ChildNodes[0]);

            // Determine what kind of assignment this is
            switch(currentNode.ChildNodes[1].FindTokenAndGetText())
            {
                case "=":
                    assignment.AssignmentType = AssignmentType.Equal;
                    break;
                case "+=":
                    assignment.AssignmentType = AssignmentType.Add;
                    break;
                case "-=":
                    assignment.AssignmentType = AssignmentType.Subtract;
                    break;
                case "*=":
                    assignment.AssignmentType = AssignmentType.Multiply;
                    break;
                case "/=":
                    assignment.AssignmentType = AssignmentType.Divide;
                    break;
                case "|=":
                    assignment.AssignmentType = AssignmentType.Or;
                    break;
                case "&=":
                    assignment.AssignmentType = AssignmentType.And;
                    break;
            }

            // Get the value being assigned.
            parser.ConsumeParseTree(root, assignment, currentNode.ChildNodes[2]);
        }

 public override void Init(AstContext context, ParseTreeNode parseNode)
 {
     //throw(new NotImplementedException());
     this.Content = parseNode.FindToken().ValueString;
 }

        void IAstNodeInit.Init(AstContext context, ParseTreeNode parseNode)
        {
            NodeName = parseNode.Term == null ? GetType().Name : parseNode.Term.Name;

            var tokens = new List<Token>();

            var iToken = parseNode.FindToken();
            if (iToken != null) {
                tokens.Add(new Token(iToken.Location.Column, iToken.Location.Line, iToken.Text, iToken.Value));
            }

            var childNodes = new List<ISqlNode>();

            foreach (var childNode in parseNode.ChildNodes) {
                ISqlNode child;
                if (childNode.Term is KeyTerm) {
                    var childIToken = childNode.FindToken();
                    child = new SqlKeyNode(new Token(childIToken.Location.Column, childIToken.Location.Line, childIToken.Text, childIToken.Value));
                } else {
                    child = (ISqlNode)childNode.AstNode;
                }

                child = OnChildNode(child);

                if (child != null) {
                    if (child is ISqlChildNode)
                        (child as ISqlChildNode).SetParent(this);

                    childNodes.Add(child);
                    tokens.AddRange(child.Tokens);
                }
            }

            ChildNodes = childNodes.ToArray();
            Tokens = tokens.ToArray();

            OnNodeInit();
        }

        // Build a binary operator statement
        public static void BuildBinaryOperator(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            var op = new BinaryOperator(parentExpression, currentNode.FindToken().Convert());
            parentExpression.ChildExpressions.Add(op);

            // Determine which binary operator this is
            switch (currentNode.ChildNodes[1].Term.ToString())
            {
                case "*":
                    op.OperatorType = BinaryOperatorType.Multiply;
                    break;
                case "/":
                    op.OperatorType = BinaryOperatorType.Divide;
                    break;
                case "+":
                    op.OperatorType = BinaryOperatorType.Add;
                    break;
                case "-":
                    op.OperatorType = BinaryOperatorType.Subtract;
                    break;
                case "%":
                    op.OperatorType = BinaryOperatorType.Modulo;
                    break;
                case "<=":
                    op.OperatorType = BinaryOperatorType.LessOrEqual;
                    break;
                case "<":
                    op.OperatorType = BinaryOperatorType.Less;
                    break;
                case "==":
                    op.OperatorType = BinaryOperatorType.Equal;
                    break;
                case "!=":
                    op.OperatorType = BinaryOperatorType.NotEqual;
                    break;
                case ">=":
                    op.OperatorType = BinaryOperatorType.GreaterOrEqual;
                    break;
                case ">":
                    op.OperatorType = BinaryOperatorType.Greater;
                    break;
                case ">>":
                    op.OperatorType = BinaryOperatorType.BitwiseShiftRight;
                    break;
                case "<<":
                    op.OperatorType = BinaryOperatorType.BitwiseShiftLeft;
                    break;
                case "&&":
                    op.OperatorType = BinaryOperatorType.LogicalAnd;
                    break;
                case "||":
                    op.OperatorType = BinaryOperatorType.LogicalOr;
                    break;
                case "|":
                    op.OperatorType = BinaryOperatorType.BitwiseOr;
                    break;
                case "&":
                    op.OperatorType = BinaryOperatorType.BitwiseAnd;
                    break;
                case "^":
                    op.OperatorType = BinaryOperatorType.BitwiseXor;
                    break;
                case "as":
                    op.OperatorType = BinaryOperatorType.As;
                    break;
            }

            // Get the left operand
            parser.ConsumeParseTree(root, op, currentNode.ChildNodes[0]);

            // "as" operator is a type case and needs to be handled differently
            if(op.OperatorType == BinaryOperatorType.As)
            {
                var v = new VariableReference(op, null);
                v.Name = currentNode.ChildNodes[2].ChildNodes[0].FindTokenAndGetText();
                op.ChildExpressions.Add(v);
            }
            else
                parser.ConsumeParseTree(root, op, currentNode.ChildNodes[2]);
        }

        // Build a method declaration expression
        public static void BuildMethodDeclaration(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            MethodDeclaration e = new MethodDeclaration(parentExpression, currentNode.FindToken().Convert());
            parentExpression.ChildExpressions.Add(e);

            int i = 0;

            // Set default modifiers
            var c = parentExpression as Class;
            if(c.IsModule) // If the parent is a module, set the method to shared.
            {
                e.IsShared = true;
            }

            // Interpret the modifiers for the method declaration
            InterpretModifiers(root, e, currentNode.ChildNodes[0].ChildNodes[0]);

            if(e.IsShared && (e.IsFinal || e.IsOverride))
                root.CompilerErrors.Add(new IncompatibleModifiersCompilerError("", currentNode.FindToken().Location.Line,
                    currentNode.FindToken().Location.Position));

            i+=1; // skip the def

            // Interpret the return type name: check if it's an array, generic, or simple type name
            if (currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].Term.ToString() == "array")
            {
                e.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText();
                e.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].FindTokenAndGetText()) + "[]";
            }
            else if (currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0].Term.ToString() == "generic_identifier")
            {
                var genericNode = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].ChildNodes[0];
                e.Name = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText());
                e.ReturnTypeName = parser.CheckAlias(genericNode.ChildNodes[0].FindTokenAndGetText()) + "<";
                for(int n = 0; n < genericNode.ChildNodes[2].ChildNodes.Count; n++)
                {
                    e.ReturnTypeName += parser.CheckAlias(genericNode.ChildNodes[2].ChildNodes[n].FindTokenAndGetText());
                    if(n < genericNode.ChildNodes[2].ChildNodes.Count - 1)
                        e.ReturnTypeName += ",";
                }
                e.ReturnTypeName += ">";
            }
            else
            {
                e.Name = currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[1].FindTokenAndGetText();
                e.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[0].ChildNodes[1].ChildNodes[0].FindTokenAndGetText());
            }

            i++;

            i++;

            // Add the generic type names for the method declaration
            if (currentNode.ChildNodes[1].ChildNodes.Count > 0)
            {
                var generics = currentNode.ChildNodes[1].ChildNodes[0].ChildNodes[1];
                foreach (string s in IronyParser.InterpretList(generics))
                    e.GenericTypeNames.Add(s);
            }

            i+=1;

            // add the arguments for the method declaration
            if (currentNode.ChildNodes[2].ChildNodes.Count > 0)
            {
                foreach (var n in currentNode.ChildNodes[2].ChildNodes)
                {
                    BuildArgument(parser, e, n.ChildNodes[0]);
                }
            }

            // Build the body of statements in the method declaration
            parser.ConsumeParseTree(root, e, currentNode.ChildNodes[3]);
        }