C# VariableType.Equals方法代码示例

        /// <summary>
        /// To parse the expression
        /// In EBNF: <expression> ::= <term>, { ‘+’|’-’, <term> };
        /// </summary>
        private Node ParseExpression(Node node, VariableType type)
        {
            CheckIfOutOfTokens();

            //A numeric expr can be made up of terms, but a string expr is made up of string factors only
            //(we can't multilply, divide or subtract strings)
            if (type.Equals(VariableType.Integer))
                node = ParseTerm(node);
            else if (type.Equals(VariableType.Boolean))
                node = ParseCondition(node);
            else
                node = ParseFactor(node, VariableType.String);

            //While a valid operator is found
            while (GetCurrentToken().Value.Equals("+") || (type.Equals(VariableType.Integer) &&
                                                           GetCurrentToken().Value.Equals("-")))
            {
                if (node == null)
                    node = new Node();

                Node clonedNode = node.Clone();
                node.Left = clonedNode;
                node.Value = GetCurrentToken().Value;
                TokenIndex++;

                if (type.Equals(VariableType.Integer))
                    node.Right = ParseTerm(node.Right);
                else
                    node.Right = ParseFactor(node.Right, VariableType.String);
            }

            return node;
        }

        /// <summary>
        /// Parse a facor in an expression
        /// EBNF: <factor> ::= <IDENTIFIER> | <CONSTANT> | ( ‘(’, <expression>, ‘)’ ) | ( '-', <factor> );
        /// We need to have the node where the factor is to be held
        /// A the type so we know whether we are expecting an int or a string
        /// </summary>
        private Node ParseFactor(Node node, VariableType type)
        {
            //Check if we have any tokens left
            CheckIfOutOfTokens();

            //First check for a parenthesised expression
            //( ‘(’, <expression>, ‘)’ )
            if (GetCurrentToken().Value.Equals("("))
            {
                //Skip the parenthesis
                TokenIndex++;

                //Get the expression
                node = ParseExpression(node, type);

                if (!GetCurrentToken().Value.Equals(")"))
                    Console.WriteLine("Expected closing bracket");

                //Skip the closing paren
                TokenIndex++;

                return node;
            }

            //If it's not a parenthesised expression
            //Check for a negative number
            //( '-', <factor> )
            if (type.Equals(VariableType.Integer))
            {
                if (GetCurrentToken().Value.Equals("-"))
                {
                    TokenIndex++;
                    node = ParseFactor(node, type);

                    //Apply the negative sign to the parsed factor
                    node.Value = "-" + node.Value;
                    return node;
                }
            }

            //We have narrowed it down to either a <IDENTIFIER> or <CONSTANT>
            node = new Node();

            //Store the value in the node
            node.Value = GetCurrentToken().Value;

            //Semantics - check if variable exists
            if (GetCurrentToken().Type.Equals(TokenType.Identifier) && !VariableExists(GetCurrentToken().Value))
                Console.WriteLine("Undeclared variable");

            //Give the node extra info to aid in code gen
            if (GetCurrentToken().Type.Equals(TokenType.Identifier))
                node.Attributes[0] = "VARIABLE";
            else
                node.Attributes[1] = "VALUE";

            TokenIndex++;

            return node;
        }

        public static bool IsAssignable(VariableType left, VariableType right)
        {
            if (left == null || right == null)
                return false;

            if (left.TypeEnum == VariableTypeEnum.Integer)
            {
                return (right.TypeEnum == VariableTypeEnum.Integer || right.TypeEnum == VariableTypeEnum.Char);
            }
            else if (left.TypeEnum == VariableTypeEnum.Array && right.TypeEnum == VariableTypeEnum.NULL)
            {
                return true;
            }
            return (left.Equals(right));
        }