示例#1
0
        private ArmOperation ParseCallExpression(ref ArmExpressionTokenizer tokenizer, ArmExpressionIdentifierToken identifier)
        {
            var arguments = new List <ArmExpression>();

            ArmExpressionToken token;
            bool sawCloseParen = false;

            while (!sawCloseParen)
            {
                token = tokenizer.NextToken();
                switch (token.Type)
                {
                case ArmExpressionTokenType.Identifier:
                    arguments.Add(ParseIdentifierExpression(ref tokenizer, (ArmExpressionIdentifierToken)token));
                    break;

                case ArmExpressionTokenType.String:
                    arguments.Add(new ArmStringLiteral(token.CoerceToString()));
                    break;

                case ArmExpressionTokenType.Integer:
                    arguments.Add(new ArmIntegerLiteral(token.CoerceToLong()));
                    break;

                case ArmExpressionTokenType.Boolean:
                    arguments.Add(ArmBooleanLiteral.FromBool(token.CoerceToBool()));
                    break;

                case ArmExpressionTokenType.CloseParen:
                    if (arguments.Count == 0)
                    {
                        sawCloseParen = true;
                        continue;
                    }
                    goto default;

                default:
                    throw Error($"Expected an expression but instead got '{token}' in input '{tokenizer.Input}' at index {tokenizer.PreviousIndex}");
                }

                token = tokenizer.NextToken();
                switch (token.Type)
                {
                case ArmExpressionTokenType.Comma:
                    break;

                case ArmExpressionTokenType.CloseParen:
                    sawCloseParen = true;
                    break;

                default:
                    throw Error($"Expected an expression delimiter but instead got '{token}' in input '{tokenizer.Input}' at index {tokenizer.PreviousIndex}");
                }
            }

            if (identifier.Identifier.Is(ParametersFunction))
            {
                return(new ArmParameterReferenceExpression((IArmString)arguments[0]));
            }

            if (identifier.Identifier.Is(VariablesFunction))
            {
                return(new ArmVariableReferenceExpression((IArmString)arguments[0]));
            }

            return(new ArmFunctionCallExpression(new ArmStringLiteral(identifier.Identifier), arguments.ToArray()));
        }
示例#2
0
        private ArmOperation ParseIdentifierExpression(ref ArmExpressionTokenizer tokenizer, ArmExpressionIdentifierToken identifier)
        {
            ArmExpressionToken token = tokenizer.NextToken();

            switch (token.Type)
            {
            case ArmExpressionTokenType.OpenParen:
                ArmOperation expression = ParseCallExpression(ref tokenizer, identifier);
                return(ParseDotExpression(ref tokenizer, expression));

            default:
                throw Error($"Expected a token of type '{ArmExpressionTokenType.OpenParen}' but instead got '{token}' in '{tokenizer.Input}' at index '{tokenizer.PreviousIndex}'");
            }
        }