Examples with ParsedFunctionArgument stanhebben.zenscript.definitions.ParsedFunctionArgument used on opensource projects

Example 1 with ParsedFunctionArgument

use of stanhebben.zenscript.definitions.ParsedFunctionArgument in project ZenScript by CraftTweaker.

the class ParsedExpression method readPrimaryExpression.

private static ParsedExpression readPrimaryExpression(ZenPosition position, ZenTokener parser, IEnvironmentGlobal environment) {
    switch(parser.peek().getType()) {
        case T_INTVALUE:
            long l = Long.decode(parser.next().getValue());
            return new ParsedExpressionValue(position, new ExpressionInt(position, l, Long.bitCount(l) > 32 ? ZenType.LONG : ZenTypeInt.INSTANCE));
        case T_FLOATVALUE:
            String value = parser.next().getValue();
            ZenType zenType = ZenTypeDouble.INSTANCE;
            if (value.endsWith("f") || value.endsWith("F")) {
                zenType = ZenTypeFloat.INSTANCE;
                value = value.substring(0, value.length() - 1);
            }
            return new ParsedExpressionValue(position, new ExpressionFloat(position, Double.parseDouble(value), zenType));
        case T_STRINGVALUE:
            return new ParsedExpressionValue(position, new ExpressionString(position, unescapeString(parser.next().getValue())));
        /*
             * case T_DOLLAR: { Expression result = new
             * ExpressionDollar(position); if (parser.isNext(T_STRINGVALUE))
             * { return new ExpressionIndexString(position, result,
             * unescapeString(parser.next().getValue())); } return result; }
             */
        case T_ID:
            return new ParsedExpressionVariable(position, parser.next().getValue());
        case T_FUNCTION:
            // function (argname, argname, ...) { ...contents... }
            parser.next();
            parser.required(T_BROPEN, "( expected");
            List<ParsedFunctionArgument> arguments = new ArrayList<>();
            if (parser.optional(T_BRCLOSE) == null) {
                do {
                    String name = parser.required(T_ID, "identifier expected").getValue();
                    ZenType type = ZenTypeAny.INSTANCE;
                    if (parser.optional(T_AS) != null) {
                        type = ZenType.read(parser, environment);
                    }
                    arguments.add(new ParsedFunctionArgument(name, type));
                } while (parser.optional(T_COMMA) != null);
                parser.required(T_BRCLOSE, ") expected");
            }
            ZenType returnType = ZenTypeAny.INSTANCE;
            if (parser.optional(T_AS) != null) {
                returnType = ZenType.read(parser, environment);
            }
            parser.required(T_AOPEN, "{ expected");
            List<Statement> statements = new ArrayList<>();
            if (parser.optional(T_ACLOSE) == null) {
                while (parser.optional(T_ACLOSE) == null) {
                    statements.add(Statement.read(parser, environment, returnType));
                }
            }
            return new ParsedExpressionFunction(position, returnType, arguments, statements);
        case T_LT:
            {
                Token start = parser.next();
                List<Token> tokens = new ArrayList<>();
                Token next = parser.next();
                while (next.getType() != ZenTokener.T_GT) {
                    tokens.add(next);
                    next = parser.next();
                }
                IZenSymbol resolved = parser.getEnvironment().getBracketed(environment, tokens);
                if (resolved == null) {
                    StringBuilder builder = new StringBuilder();
                    builder.append('<');
                    Token last = null;
                    for (Token token : tokens) {
                        if (last != null)
                            builder.append(' ');
                        builder.append(token.getValue());
                        last = token;
                    }
                    builder.append('>');
                    if (!parser.ignoreBracketErrors) {
                        parser.getEnvironment().getErrorLogger().error(start.getPosition(), "Could not resolve " + builder.toString());
                    } else {
                        parser.getEnvironment().getErrorLogger().info(start.getPosition(), "Could not resolve " + builder.toString());
                    }
                    return new ParsedExpressionInvalid(start.getPosition());
                } else {
                    return new ParsedExpressionValue(start.getPosition(), parser.getEnvironment().getBracketed(environment, tokens).instance(start.getPosition()));
                }
            }
        case T_SQBROPEN:
            {
                parser.next();
                List<ParsedExpression> contents = new ArrayList<>();
                if (parser.optional(T_SQBRCLOSE) == null) {
                    while (parser.optional(T_SQBRCLOSE) == null) {
                        contents.add(readAssignExpression(parser, environment));
                        if (parser.optional(T_COMMA) == null) {
                            parser.required(T_SQBRCLOSE, "] or , expected");
                            break;
                        }
                    }
                }
                return new ParsedExpressionArray(position, contents);
            }
        case T_AOPEN:
            {
                parser.next();
                List<ParsedExpression> keys = new ArrayList<>();
                List<ParsedExpression> values = new ArrayList<>();
                if (parser.optional(T_ACLOSE) == null) {
                    while (parser.optional(T_ACLOSE) == null) {
                        keys.add(readAssignExpression(parser, environment));
                        parser.required(T_COLON, ": expected");
                        values.add(readAssignExpression(parser, environment));
                        if (parser.optional(T_COMMA) == null) {
                            parser.required(T_ACLOSE, "} or , expected");
                            break;
                        }
                    }
                }
                return new ParsedExpressionMap(position, keys, values);
            }
        case T_TRUE:
            parser.next();
            return new ParsedExpressionBool(position, true);
        case T_FALSE:
            parser.next();
            return new ParsedExpressionBool(position, false);
        case T_NULL:
            parser.next();
            return new ParsedExpressionNull(position);
        case T_BROPEN:
            parser.next();
            ParsedExpression result = readAssignExpression(parser, environment);
            parser.required(T_BRCLOSE, ") expected");
            return result;
        default:
            Token last = parser.next();
            throw new ParseException(last, "Invalid expression, last token: " + last.getValue());
    }
}