private DotVar ParseDotVar(PrefixExp prefixExp = null)
{
var node = DotVar.CreateBuilder();
node.Kind = SyntaxKind.DotVar;
node.StartPosition = this.textPosition;
if (prefixExp == null)
{
node.PrefixExp = ParsePrefixExp().ToBuilder();
}
else
{
node.PrefixExp = prefixExp.ToBuilder();
}
node.DotOperator = GetExpectedToken(SyntaxKind.Dot);
node.NameIdentifier = GetExpectedToken(SyntaxKind.Identifier);
node.Length = this.textPosition - node.StartPosition;
return node.ToImmutable();
}
private SquareBracketVar ParseSquareBracketVar(PrefixExp prefixExp = null)
{
var node = SquareBracketVar.CreateBuilder();
node.Kind = SyntaxKind.SquareBracketVar;
node.StartPosition = this.textPosition;
if (prefixExp == null)
{
node.PrefixExp = ParsePrefixExp().ToBuilder();
}
else
{
node.PrefixExp = prefixExp.ToBuilder();
}
node.OpenBracket = GetExpectedToken(SyntaxKind.OpenBracket);
node.Exp = ParseExpression().ToBuilder();
node.CloseBracket = GetExpectedToken(SyntaxKind.CloseBracket);
node.Length = this.textPosition - node.StartPosition;
return node.ToImmutable();
}
private FunctionCallPrefixexp ParseFunctionCallPrefixp(PrefixExp prefixExp = null)
{
var node = FunctionCallPrefixexp.CreateBuilder();
node.Kind = SyntaxKind.FunctionCallExp;
node.StartPosition = this.textPosition;
if (prefixExp != null)
{
node.PrefixExp = prefixExp.ToBuilder();
}
else
{
node.PrefixExp = ParsePrefixExp().ToBuilder();
}
if (ParseExpected(SyntaxKind.Colon))
{
node.Colon = currentToken;
node.Name = GetExpectedToken(SyntaxKind.Identifier);
}
node.Args = ParseArgs().ToBuilder();
node.Length = this.textPosition - node.StartPosition;
return node.ToImmutable();
}
private PrefixExp ParsePrefixExp(PrefixExp prefixExp = null, bool parsingFunctionCallStatement = false)
{
if (prefixExp == null)
{
switch (Peek().Kind)
{
case SyntaxKind.Identifier:
prefixExp = ParseNameVar();
break;
case SyntaxKind.OpenParen:
prefixExp = ParseParenPrefixExp();
break;
default:
throw new InvalidOperationException();
}
}
int tempPosition = 0;
while (ContinueParsingPrefixExp(Peek().Kind))
{
switch (Peek().Kind)
{
case SyntaxKind.Dot:
prefixExp = ParseDotVar(prefixExp);
break;
case SyntaxKind.OpenBracket:
prefixExp = ParseSquareBracketVar(prefixExp);
break;
case SyntaxKind.String:
case SyntaxKind.OpenParen:
case SyntaxKind.OpenCurlyBrace:
case SyntaxKind.Colon:
tempPosition = positionInTokenList;
prefixExp = ParseFunctionCallPrefixp(prefixExp);
break;
default:
return prefixExp;
}
}
if (parsingFunctionCallStatement)
{
if (prefixExp is FunctionCallPrefixexp)
{
this.SetPositionInTokenList(tempPosition);
return (prefixExp as FunctionCallPrefixexp).PrefixExp;
}
else
{
return prefixExp;
}
}
return prefixExp;
}
private Var ParsePotentialVarWithPrefixExp(PrefixExp prefixExp)
{
if (Peek().Kind == SyntaxKind.OpenBracket)
{
return ParseSquareBracketVar(prefixExp);
}
else
{
//Arbitrarily assuming it's a dot var as that is the only valid alternative
//when there is no open bracket... will log errors, if the requirements for dot var are not found
return ParseDotVar(prefixExp);
}
}
