use of stanhebben.zenscript.symbols.IZenSymbol 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());
}
}
Aggregations