internal override IList <Executable> Resolve(Parser parser)
{
this.Target = this.Target.Resolve(parser);
if (this.Target is Variable)
{
this.Target = this.Target.Resolve(parser);
}
else if (this.Target is BracketIndex)
{
BracketIndex bi = this.Target as BracketIndex;
bi.Root = bi.Root.Resolve(parser);
bi.Index = bi.Index.Resolve(parser);
}
else if (this.Target is DotStep)
{
DotStep ds = this.Target as DotStep;
ds.Root = ds.Root.Resolve(parser);
}
this.Value = this.Value.Resolve(parser);
return(Listify(this));
}
protected override void TranslateBracketIndex(List<string> output, BracketIndex bracketIndex)
{
TranslateExpression(output, bracketIndex.Root);
output.Add("[");
TranslateExpression(output, bracketIndex.Index);
output.Add("]");
}
private static Expression ParseEntity(TokenStream tokens, Executable owner)
{
Expression root;
if (tokens.PopIfPresent("("))
{
root = Parse(tokens, owner);
tokens.PopExpected(")");
}
else
{
root = ParseEntityWithoutSuffixChain(tokens, owner);
}
bool anySuffixes = true;
while (anySuffixes)
{
if (tokens.IsNext("."))
{
Token dotToken = tokens.Pop();
Token stepToken = tokens.Pop();
Parser.VerifyIdentifier(stepToken);
root = new DotStep(root, dotToken, stepToken, owner);
}
else if (tokens.IsNext("["))
{
Token openBracket = tokens.Pop();
List<Expression> sliceComponents = new List<Expression>();
if (tokens.IsNext(":"))
{
sliceComponents.Add(null);
}
else
{
sliceComponents.Add(Parse(tokens, owner));
}
for (int i = 0; i < 2; ++i)
{
if (tokens.PopIfPresent(":"))
{
if (tokens.IsNext(":") || tokens.IsNext("]"))
{
sliceComponents.Add(null);
}
else
{
sliceComponents.Add(Parse(tokens, owner));
}
}
}
tokens.PopExpected("]");
if (sliceComponents.Count == 1)
{
Expression index = sliceComponents[0];
root = new BracketIndex(root, openBracket, index, owner);
}
else
{
root = new ListSlice(root, sliceComponents, openBracket, owner);
}
}
else if (tokens.IsNext("("))
{
Token openParen = tokens.Pop();
List<Expression> args = new List<Expression>();
while (!tokens.PopIfPresent(")"))
{
if (args.Count > 0)
{
tokens.PopExpected(",");
}
args.Add(Parse(tokens, owner));
}
root = new FunctionCall(root, openParen, args, owner);
}
else
{
anySuffixes = false;
}
}
return root;
}
private void CompileBracketIndex(Parser parser, ByteBuffer buffer, BracketIndex bracketIndex, bool outputUsed)
{
// TODO: do a bunch of optimizations here:
// bracket index of integer, bracket index of string, bracket index of simple variable name, then bracket index of complex expression
if (!outputUsed) throw new ParserException(bracketIndex.FirstToken, "This expression does nothing.");
this.CompileExpression(parser, buffer, bracketIndex.Root, true);
this.CompileExpression(parser, buffer, bracketIndex.Index, true);
buffer.Add(bracketIndex.BracketToken, OpCode.INDEX);
}
protected abstract void TranslateBracketIndex(List<string> output, BracketIndex bracketIndex);
