예제 #1
0
        protected virtual BasicExpressionNode ParseBasicExpression(SemanticNode parent, Token token)
        {
            // PARSE: <basic expression> ::= <primary> [<messages> <cascaded messages>]
            BasicExpressionNode result = new BasicExpressionNode(parent);

            IPrimaryNode primary = this.ParsePrimary(result, token);
            if (primary == null)
            {
                this.ReportParserError(result, SemanticErrors.MissingPrimary, token);
                return result;
            }

            token = this.GetNextTokenxx(Preference.Default);
            this.ParseBaseicExpressionMessages(result, primary, token);
            return result;
        }
예제 #2
0
        // <expression> ::=
        //      <assignment> |
        //      <basic expression>
        // <assignment> ::= <assignment target> assignmentOperator <expression>
        // <basic expression> ::= <primary> [<messages> <cascaded messages>]
        // <assignment target> := identifier
        // <primary> ::=
        //      identifier |
        //      <literal> |
        //      <block constructor> |
        //      ( '(' <expression> ')' )
        protected virtual ExpressionNode ParseExpression(SemanticNode parent, Token token)
        {
            // Tricky ... first try for <assignment>
            if (token is IdentifierToken)
            {
                // In here, we either have an <assignment target> or <primary> of a <basic expression>
                IdentifierToken identifier = (IdentifierToken)token;

                // Try to check for assignmentOperator
                token = this.GetNextTokenxx(Preference.Default);
                if (token is AssignmentOperatorToken)
                    // OK, it's <assignment>
                    return this.ParseAssignment(parent, identifier, (AssignmentOperatorToken)token);

                // Must recover ... it is a <basic expression> anyway.
                // PARSE: identifier [<messages> <cascaded messages>]
                BasicExpressionNode result = new BasicExpressionNode(parent);
                this.ParseBaseicExpressionMessages(result, new VariableReferenceleNode(result, identifier), token);
                return result;
            };
            return this.ParseBasicExpression(parent, token);
        }
예제 #3
0
        protected virtual void ParseBaseicExpressionMessages(BasicExpressionNode expression, IPrimaryNode primary, Token token)
        {
            MessageSequenceNode messages = this.ParseMessages(expression, token);
            if (messages == null)
            {
                expression.SetContents(primary, null, null);
                return;
            }

            token = this.GetNextTokenxx(Preference.Default);
            CascadeMessageSequenceNode cascadeMessages = this.ParseCascadeMessageSequenceNode(expression, token);

            expression.SetContents(primary, messages, cascadeMessages);
        }