private static TopLevelEntity ParseIndexProperty(
ParserContext context,
ClassLikeDefinition parent,
Token firstToken,
Dictionary <string, Token> modifiers,
CSharpType type,
TokenStream tokens)
{
tokens.PopExpected("[");
CSharpType indexType = CSharpType.Parse(tokens);
Token indexVariableName = tokens.PopWord();
tokens.PopExpected("]");
tokens.PopExpected("{");
PropertyDefinition indexProperty = new PropertyDefinition(firstToken, modifiers, type, null, parent);
PropertyBody getter = null;
PropertyBody setter = null;
while (tokens.IsNext("get") || tokens.IsNext("set"))
{
Token getOrSetToken = tokens.Peek();
bool isGet = getOrSetToken.Value == "get";
if (!isGet && setter != null)
{
tokens.PopExpected("}"); // intentionally throw
}
if (isGet && getter != null)
{
tokens.PopExpected("set"); //intentionally throw
}
tokens.Pop(); // get/set already fetched with Peek() above.
PropertyBody body = new PropertyBody(getOrSetToken, new Dictionary <string, Token>(), isGet, indexProperty);
Executable[] code = ExecutableParser.ParseCodeBlock(context, tokens, body, true);
body.Code = code;
if (isGet)
{
getter = body;
}
else
{
setter = body;
}
}
indexProperty.IndexType = indexType;
indexProperty.IndexVariableName = indexVariableName;
indexProperty.Getter = getter;
indexProperty.Setter = setter;
return(indexProperty);
}
private static TopLevelEntity ParseClassProperty(
ParserContext context,
ClassLikeDefinition parent,
Token firstToken,
Dictionary <string, Token> modifiers,
CSharpType type,
Token propertyName,
TokenStream tokens)
{
tokens.PopExpected("{");
PropertyDefinition propertyDefinition = new PropertyDefinition(firstToken, modifiers, type, propertyName, parent);
PropertyBody getter = null;
PropertyBody setter = null;
while (!tokens.IsNext("}") && (getter == null || setter == null))
{
Token bodyFirstToken = tokens.Peek();
Dictionary <string, Token> bodyModifiers = ParseModifiers(context, tokens);
if (tokens.IsNext("get") && getter == null)
{
Token getToken = tokens.Pop();
getter = new PropertyBody(bodyFirstToken, bodyModifiers, true, propertyDefinition);
if (!tokens.PopIfPresent(";"))
{
getter.Code = ExecutableParser.ParseCodeBlock(context, tokens, getter, true);
}
}
else if (tokens.IsNext("set") && setter == null)
{
Token setToken = tokens.Pop();
setter = new PropertyBody(bodyFirstToken, bodyModifiers, false, propertyDefinition);
if (!tokens.PopIfPresent(";"))
{
setter.Code = ExecutableParser.ParseCodeBlock(context, tokens, setter, true);
}
}
else if (getter == null)
{
tokens.PopExpected("get"); // intentionally throw
}
else
{
tokens.PopExpected("set"); // intentionally throw
}
}
tokens.PopExpected("}");
propertyDefinition.Getter = getter;
propertyDefinition.Setter = setter;
return(propertyDefinition);
}
private static Executable ParseTryStatement(ParserContext context, TokenStream tokens, TopLevelEntity parent)
{
Token tryToken = tokens.PopExpected("try");
Executable[] tryCode = ExecutableParser.ParseCodeBlock(context, tokens, parent, true);
List <Token> catchTokens = new List <Token>();
List <CSharpType> catchBlockTypes = new List <CSharpType>();
List <Token> catchBlockVariables = new List <Token>();
List <Executable[]> catchBlockCode = new List <Executable[]>();
Token finallyToken = null;
Executable[] finallyCode = null;
while (tokens.IsNext("catch"))
{
catchTokens.Add(tokens.Pop());
tokens.PopExpected("(");
catchBlockTypes.Add(CSharpType.Parse(tokens));
if (!tokens.PopIfPresent(")"))
{
catchBlockVariables.Add(tokens.PopWord());
tokens.PopExpected(")");
}
else
{
catchBlockVariables.Add(null);
}
catchBlockCode.Add(ParseCodeBlock(context, tokens, parent, true));
}
if (tokens.IsNext("finally"))
{
finallyToken = tokens.Pop();
finallyCode = ParseCodeBlock(context, tokens, parent, true);
}
return(new TryStatement(
tryToken,
tryCode,
catchTokens,
catchBlockTypes,
catchBlockVariables,
catchBlockCode,
finallyToken,
finallyCode,
parent));
}
private static TopLevelEntity ParseClassConstructor(
ParserContext context,
ClassLikeDefinition classDef,
Token firstToken,
Dictionary <string, Token> modifiers,
CSharpType type,
TokenStream tokens)
{
List <CSharpType> argTypes = new List <CSharpType>();
List <Token> argNames = new List <Token>();
List <Token> argModifiers = new List <Token>();
ParseArgList(argTypes, argNames, argModifiers, tokens);
ConstructorDefinition constructorDef = new ConstructorDefinition(
firstToken,
modifiers,
argTypes,
argNames,
argModifiers,
classDef);
if (tokens.PopIfPresent(":"))
{
if (!tokens.IsNext("base") && !tokens.IsNext("this"))
{
tokens.PopExpected("base"); // intentionally throw
}
constructorDef.BaseConstructorInvocation = tokens.Pop();
tokens.PopExpected("(");
List <Expression> baseConstructorArgs = new List <Expression>();
while (!tokens.PopIfPresent(")"))
{
if (baseConstructorArgs.Count > 0)
{
tokens.PopExpected(",");
}
baseConstructorArgs.Add(ExpressionParser.Parse(context, tokens, constructorDef));
}
constructorDef.BaseConstructorArgs = baseConstructorArgs.ToArray();
}
constructorDef.Code = ExecutableParser.ParseCodeBlock(context, tokens, constructorDef, true);
return(constructorDef);
}
private static Executable ParseUsingStatement(ParserContext context, TokenStream tokens, TopLevelEntity parent)
{
Token usingToken = tokens.PopExpected("using");
tokens.PopExpected("(");
CSharpType type = null;
Token variable = null;
Token equalsToken = null;
if (!tokens.IsNext("new"))
{
type = CSharpType.Parse(tokens);
variable = tokens.PopWord();
equalsToken = tokens.PopExpected("=");
}
Expression expression = ExpressionParser.Parse(context, tokens, parent);
tokens.PopExpected(")");
Executable[] code = ExecutableParser.ParseCodeBlock(context, tokens, parent, false);
return(new UsingStatement(usingToken, type, variable, expression, code, parent));
}
private static TopLevelEntity ParseClassMethod(
ClassLikeDefinition classDef,
ParserContext context,
Token firstToken,
Dictionary <string, Token> modifiers,
CSharpType returnType,
Token methodName,
TokenStream tokens)
{
List <CSharpType> argTypes = new List <CSharpType>();
List <Token> argNames = new List <Token>();
List <Token> argModifiers = new List <Token>();
ParseArgList(argTypes, argNames, argModifiers, tokens);
MethodDefinition methodDef = new MethodDefinition(
firstToken,
modifiers,
returnType,
methodName,
argNames,
argTypes,
argModifiers,
classDef);
if (methodDef.IsAbstract || classDef is InterfaceDefinition)
{
tokens.PopExpected(";");
}
else
{
methodDef.Code = ExecutableParser.ParseCodeBlock(context, tokens, methodDef, true);
}
return(methodDef);
}
private static Expression ParseAtom(ParserContext context, TokenStream tokens, TopLevelEntity parent)
{
string next = tokens.PeekValue();
switch (next)
{
case "true":
case "false":
Token booleanToken = tokens.Pop();
return(new BooleanConstant(booleanToken, booleanToken.Value == "true", parent));
case "null":
Token nullToken = tokens.Pop();
return(new NullConstant(nullToken, parent));
case "new":
Token newToken = tokens.Pop();
CSharpType className = CSharpType.TryParse(tokens);
if (className == null)
{
throw new ParserException(newToken, "'new' keyword must be followed by a className");
}
if (!tokens.IsNext("("))
{
// could be a new array of which there are two ways to define it...
if (className.IsArray && tokens.IsNext("{"))
{
List <Expression> arrayItems = new List <Expression>();
tokens.PopExpected("{");
bool nextAllowed = true;
while (!tokens.PopIfPresent("}"))
{
if (!nextAllowed)
{
tokens.PopExpected("}");
}
arrayItems.Add(ExpressionParser.Parse(context, tokens, parent));
nextAllowed = tokens.PopIfPresent(",");
}
return(new ArrayInitialization(newToken, className.Generics[0], null, arrayItems, parent));
}
if (tokens.IsNext("["))
{
// a new array with specified length
tokens.PopExpected("[");
Expression arrayLength = ExpressionParser.Parse(context, tokens, parent);
tokens.PopExpected("]");
return(new ArrayInitialization(newToken, className, arrayLength, null, parent));
}
// if this isn't an array construction, then give a reasonable error message...
tokens.PopExpected("(");
}
return(new ConstructorInvocationFragment(newToken, className, parent));
case "@":
// raw string
Token rawStringAt = tokens.Pop();
Token stringValue = tokens.Pop();
string stringValueActual = stringValue.Value;
if (stringValueActual[0] != '"')
{
throw new ParserException(stringValue, "Expected a string value");
}
return(new StringConstant(rawStringAt, stringValueActual.Substring(1, stringValueActual.Length - 2), parent));
default: break;
}
Token token = tokens.Pop();
char c = next[0];
if (c == '"' || c == '\'')
{
string stringValue = StringUtil.ConvertStringTokenToValue(token);
if (c == '"')
{
return(new StringConstant(token, stringValue, parent));
}
else
{
return(new CharConstant(token, stringValue, parent));
}
}
if (c == '0' && next.Length > 2 && next[1] == 'x')
{
string hex = next.Substring(2);
int parsedValue = 0;
for (int i = 0; i < hex.Length; ++i)
{
c = hex[i];
if (c >= '0' && c <= '9')
{
parsedValue = parsedValue * 16 + (c - '0');
}
else if (c >= 'a' && c <= 'f')
{
parsedValue = parsedValue * 16 + (10 + c - 'a');
}
else if (c >= 'A' && c <= 'F')
{
parsedValue = parsedValue * 16 + (10 + c - 'A');
}
else
{
throw new ParserException(token, "Invalid hexidecimal value: '" + hex + "'");
}
}
return(new IntegerConstant(token, parsedValue, parent));
}
if (c == '.' && next.Length > 1)
{
double value;
if (!double.TryParse(next, out value))
{
throw new ParserException(token, "Invalid double constant: '" + next + "'");
}
return(new DoubleConstant(token, value, parent));
}
if (c >= '0' && c <= '9')
{
if (next.Contains('.'))
{
if (next.EndsWith("f") || next.EndsWith("F"))
{
throw new NotImplementedException();
}
double floatValue;
if (!double.TryParse(next, out floatValue))
{
throw new ParserException(token, "Invalid number: '" + next + "'");
}
return(new DoubleConstant(token, floatValue, parent));
}
else
{
if (next.EndsWith("f") || next.EndsWith("F"))
{
throw new NotImplementedException();
}
int intValue;
if (!int.TryParse(next, out intValue))
{
throw new ParserException(token, "Invalid number: '" + next + "'");
}
return(new IntegerConstant(token, intValue, parent));
}
}
if ((c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
c == '_')
{
if (tokens.IsNext("=>"))
{
List <Token> args = new List <Token>()
{
token
};
Token arrowToken = tokens.Pop();
Executable[] lambdaBody;
if (tokens.IsNext("{"))
{
lambdaBody = ExecutableParser.ParseCodeBlock(context, tokens, parent, true);
}
else
{
Expression lambdaBodyExpr = Parse(context, tokens, parent);
lambdaBody = new Executable[] {
new ReturnStatement(lambdaBodyExpr.FirstToken, lambdaBodyExpr, parent),
};
}
return(new Lambda(token, args, arrowToken, lambdaBody, parent));
}
return(new Variable(token, parent));
}
throw new ParserException(token, "Unexpected token: '" + token.Value + "'");
}
private static Expression ParseAtomWithSuffix(ParserContext context, TokenStream tokens, TopLevelEntity parent)
{
Expression root;
if (tokens.IsNext("("))
{
Token openParen = tokens.Pop();
switch (IdentifyParenthesisSituation(tokens))
{
case ParenthesisSituation.CAST:
CSharpType castType = CSharpType.Parse(tokens);
tokens.PopExpected(")");
Expression castValue = ParseAtomWithSuffix(context, tokens, parent);
return(new CastExpression(openParen, castType, castValue, parent));
case ParenthesisSituation.LAMBDA_ARG:
List <Token> lambdaArgs = new List <Token>()
{
tokens.PopWord()
};
while (tokens.PopIfPresent(","))
{
lambdaArgs.Add(tokens.PopWord());
}
tokens.PopExpected(")");
Token arrowToken = tokens.PopExpected("=>");
Executable[] lambdaBody;
if (tokens.IsNext("{"))
{
lambdaBody = ExecutableParser.ParseCodeBlock(context, tokens, parent, true);
}
else
{
Expression expr = Parse(context, tokens, parent);
lambdaBody = new Executable[] {
new ReturnStatement(expr.FirstToken, expr, parent)
};
}
return(new Lambda(openParen, lambdaArgs, arrowToken, lambdaBody, parent));
case ParenthesisSituation.WRAPPED_EXPRESSION:
root = Parse(context, tokens, parent);
tokens.PopExpected(")");
break;
default:
throw new Exception(); // not valid
}
}
else
{
root = ParseAtom(context, tokens, parent);
}
bool anythingInteresting = true;
string next = tokens.PeekValue();
while (anythingInteresting)
{
switch (next)
{
case ".":
Token dotToken = tokens.Pop();
Token fieldName = tokens.PopWord();
root = new DotField(root.FirstToken, root, dotToken, fieldName, parent);
break;
case "[":
Token openBracket = tokens.Pop();
Expression index = Parse(context, tokens, parent);
tokens.PopExpected("]");
root = new BracketIndex(root, openBracket, index, parent);
break;
case "<":
if (root is DotField)
{
CSharpType[] functionInvocationTypeSpecification = MaybeParseOutOneOfThoseInlineTypeSpecificationsForFunctionInvocations(tokens);
if (functionInvocationTypeSpecification != null)
{
((DotField)root).InlineTypeSpecification = functionInvocationTypeSpecification;
}
else
{
anythingInteresting = false;
}
}
else
{
anythingInteresting = false;
}
break;
case "(":
Token openParen = tokens.Pop();
List <Expression> args = new List <Expression>();
List <Token> outTokens = new List <Token>();
while (!tokens.PopIfPresent(")"))
{
if (args.Count > 0)
{
tokens.PopExpected(",");
}
if (tokens.IsNext("out"))
{
outTokens.Add(tokens.Pop());
}
else
{
outTokens.Add(null);
}
args.Add(Parse(context, tokens, parent));
}
root = new FunctionInvocation(root.FirstToken, root, openParen, args, outTokens, parent);
break;
case "{": // e.g. new List<int>() { 1, 2, 3 }. This only follows a constructor.
FunctionInvocation fi = root as FunctionInvocation;
ConstructorInvocationFragment cif = fi == null ? null : (ConstructorInvocationFragment)fi.Root;
if (root is FunctionInvocation && ((FunctionInvocation)root).Root is ConstructorInvocationFragment)
{
tokens.Pop(); // {
ConstructorSuffixData format = DetermineConstructorSuffixDataFormat(tokens);
bool nextAllowed = true;
List <Expression> values = new List <Expression>();
List <Expression> kvpKeys = new List <Expression>();
List <Token> propertyNames = new List <Token>();
while (!tokens.PopIfPresent("}"))
{
if (!nextAllowed)
{
tokens.PopExpected("}"); // intentionally throw
}
switch (format)
{
case ConstructorSuffixData.KVP_ENTRIES:
tokens.PopExpected("{");
kvpKeys.Add(Parse(context, tokens, parent));
tokens.PopExpected(",");
values.Add(Parse(context, tokens, parent));
tokens.PopExpected("}");
break;
case ConstructorSuffixData.PROPERTIES:
propertyNames.Add(tokens.PopWord());
tokens.PopExpected("=");
values.Add(Parse(context, tokens, parent));
break;
case ConstructorSuffixData.SEQUENTIAL_ITEMS:
values.Add(Parse(context, tokens, parent));
break;
}
nextAllowed = tokens.PopIfPresent(",");
}
cif.InitialDataValues = values.ToArray();
int t = cif.InitialDataValues.Length;
if (kvpKeys.Count == t)
{
cif.InitialDataKeys = kvpKeys.ToArray();
}
if (propertyNames.Count == t)
{
cif.InitialDataPropertyNames = propertyNames.ToArray();
}
}
else
{
throw new ParserException(tokens.Peek(), "Unexpected '{'");
}
break;
default:
anythingInteresting = false;
break;
}
next = tokens.PeekValue();
}
if (next == "++" || next == "--")
{
Token incrementToken = tokens.Pop();
root = new InlineIncrement(root.FirstToken, incrementToken, false, root, parent);
}
return(root);
}
