public override Block CompileNewState(Runtime runtime,
StateForCompiler state)
{
ParserBlock block = new ParserBlock();
block.Comment("start of token --------------------");
// todo enter
block.BeginScope();
BlockLocal start = block.SavePosition();
block.Emit(body.Compile(runtime, state));
BlockLocal bodyTree = new BlockLocal(typeof(ParseTree));
block.DeclareLocal(bodyTree);
block.Dup();
block.StoreLocal(bodyTree);
BlockLabel yes = new BlockLabel("yes");
block.BranchIfNotNo(yes);
// todo no
block.LoadNo();
BlockLabel returnLabel = new BlockLabel("return");
block.Branch(returnLabel);
block.MarkLabel(yes);
// todo yes
block.LoadLexer();
block.GetProperty(typeof(Lexer).GetProperty("Text"));
block.LoadLocal(start);
block.LoadLexer();
block.GetProperty(typeof(Lexer).GetProperty("Position"));
block.LoadLocal(start);
block.Sub();
block.Call(typeof(string).GetMethod("Substring", new Type[]{typeof(int), typeof(int)}));
block.New(typeof(ParseTree).GetConstructor(new Type[]{typeof(object)}));
block.LoadLocal(bodyTree);
block.Call(typeof(ParseTree).GetMethod("ExtendFields"));
block.MarkLabel(returnLabel);
block.EndScope();
block.Comment("end of token --------------------");
return block;
}
public override Block CompileNewState(Runtime runtime,
StateForCompiler state)
{
ParserBlock block = new ParserBlock();
block.Comment("start of any --------------------");
BlockLabel returnLabel = new BlockLabel("return");
// todo enter
block.BeginScope();
block.LoadLexer();
block.Call(typeof(Lexer).GetMethod("Peek", new Type[]{}));
BlockLabel failed = new BlockLabel("failed");
block.BranchIfFalse(failed);
block.LoadLexer();
block.Call(typeof(Lexer).GetMethod("Read"));
// todo yes
if (state.BuildTextNodes)
{
block.Call(typeof(Convert).GetMethod("ToString", new Type[]{typeof(char)}));
block.New(typeof(ParseTree).GetConstructor(new Type[]{typeof(object)}));
}
else
{
block.Pop();
block.LoadYes();
}
block.Branch(returnLabel);
block.MarkLabel(failed);
// todo no
block.LoadNo();
block.MarkLabel(returnLabel);
block.EndScope();
block.Comment("end of any --------------------");
return block;
}
public override Block CompileNewState(Runtime runtime,
StateForCompiler state)
{
ParserBlock block = new ParserBlock();
block.Comment("start of label --------------------");
BlockLabel returnLabel = new BlockLabel("returnLabel");
block.Emit(body.Compile(runtime, state));
block.Dup();
block.BranchIfNo(returnLabel);
block.BeginScope();
BlockLocal bodyTree = new BlockLocal(typeof(ParseTree));
block.DeclareLocal(bodyTree);
block.StoreLocal(bodyTree);
block.NewParseTree();
block.LoadLocal(bodyTree);
block.Call(typeof(ParseTree).GetMethod("ExtendFields"));
block.Dup();
block.GetProperty(typeof(ParseTree).GetProperty("Fields"));
block.Load(label);
block.LoadLocal(bodyTree);
block.GetProperty(typeof(ParseTree).GetProperty("Value"));
block.SetProperty(typeof(Dictionary<string, object>).GetProperty("Item"));
block.EndScope();
block.MarkLabel(returnLabel);
block.Comment("end of label --------------------");
return block;
}
public override Block CompileNewState(Runtime runtime,
StateForCompiler state)
{
ParserBlock block = new ParserBlock();
block.Comment("start of not --------------------");
BlockLabel returnLabel = new BlockLabel("return");
block.BeginScope();
BlockLocal start = block.SavePosition();
// todo enter
block.Emit(body.Compile(runtime, state));
BlockLabel yes = new BlockLabel("yes");
block.BranchIfNotNo(yes);
// todo yes
block.LoadYes();
block.Branch(returnLabel);
block.MarkLabel(yes);
// todo no
block.RestorePosition(start);
block.LoadNo();
block.MarkLabel(returnLabel);
block.EndScope();
block.Comment("end of not --------------------");
return block;
}
public void BranchIfNotNo(BlockLabel label)
{
LoadNo();
BranchIfNotEqual(label);
}
public void BranchIfNotNo(BlockLabel label)
{
LoadNo();
BranchIfNotEqual(label);
}
public void MarkLabel(BlockLabel label)
{
Emit(new BlockInstruction(BlockOperation.MarkLabel, label));
}
public override Block CompileNewState(Runtime runtime,
StateForCompiler state)
{
ParserBlock block = new ParserBlock(runtime);
block.Comment("start of text --------------------");
block.Enter(this, TextEscape.Quote(text));
block.BeginScope();
block.Whitespace(runtime, state);
BlockLocal start = block.SavePosition();
BlockLocal n = new BlockLocal(typeof(int));
block.DeclareLocal(n);
BlockLabel reitterate = new BlockLabel("reitterate");
block.MarkLabel(reitterate);
block.Comment("itteration");
BlockLocal character = new BlockLocal(typeof(char));
block.DeclareLocal(character);
block.LoadLexer();
block.LoadLocal(n);
block.Call(typeof(Lexer).GetMethod("Peek",
new Type[]{typeof(int)}));
block.Dup();
block.StoreLocal(character);
block.Load(text);
block.LoadLocal(n);
block.GetProperty(typeof(string).GetProperty("Chars"));
BlockLabel matched = new BlockLabel("matched");
block.BranchIfEqual(matched);
block.Comment("handle the failure");
// todo error string
// todo specifics
block.No(this, start);
block.LoadNo();
BlockLabel returnLabel = new BlockLabel("return");
block.Branch(returnLabel);
block.MarkLabel(matched);
block.Comment("increment and check the loop variable");
block.LoadLocal(n);
block.Increment();
block.Dup();
block.StoreLocal(n);
block.Load(text.Length);
block.BranchIfLess(reitterate);
block.Comment("skip over the text");
block.LoadLexer();
block.Load(text.Length);
block.Call(typeof(Lexer).GetMethod("Skip"));
// todo specifics
block.Yes(this, start);
block.Comment("create the parse tree");
if (state.BuildTextNodes)
{
block.Load(text);
block.New(typeof(ParseTree).GetConstructor(
new Type[]{typeof(object)}));
}
else
{
block.LoadYes();
}
block.EndScope();
block.MarkLabel(returnLabel);
block.Comment("end of text --------------------");
return block;
}
public void BranchIfGreater(BlockLabel label)
{
Emit(OpCodes.Bgt, label);
}
public void BranchIfEqual(BlockLabel label)
{
Emit(OpCodes.Beq, label);
}
private void CompileInstantiate(ParserBlock block, BlockLocal start, BlockLocal tree)
{
block.BeginScope();
Type[] parameterTypes = new Type[1 + Fields.Count];
parameterTypes[0] = typeof(Source);
for (int n = 1; n < parameterTypes.Length; n++)
parameterTypes[n] = typeof(object);
ConstructorInfo constructor = Type.GetConstructor(parameterTypes);
if (constructor == null)
throw new Exception("Couldn't find constructor for " + Type.FullName);
block.LoadLexer();
block.LoadLocal(start);
block.Call(typeof(Lexer).GetMethod("SourceFrom"));
BlockLocal fields = new BlockLocal(typeof(Dictionary<string, object>));
block.DeclareLocal(fields);
block.LoadLocal(tree);
block.GetProperty(typeof(ParseTree).GetProperty("Fields"));
block.StoreLocal(fields);
for (int n = 0; n < Fields.Count; n++)
{
block.BeginScope();
BlockLocal fieldValue = new BlockLocal(typeof(object));
block.DeclareLocal(fieldValue);
block.LoadLocal(fields);
block.Load(Fields[n]);
block.LoadLocalAddress(fieldValue);
block.Call(fields.Type.GetMethod("TryGetValue"));
block.Pop();
block.LoadLocal(fieldValue);
block.EndScope();
}
block.New(constructor);
BlockLocal instance = new BlockLocal(typeof(RuntimeObject));
block.DeclareLocal(instance);
block.StoreLocal(instance);
// Call Parsed
block.Load(0);
block.NewArray(typeof(object));
block.BeginScope();
BlockLocal parsedParameters = new BlockLocal(typeof(object[]));
block.DeclareLocal(parsedParameters);
block.StoreLocal(parsedParameters);
block.LoadLocal(instance);
block.Load("Parsed");
block.LoadLocal(parsedParameters);
block.Load(false);
block.Call(typeof(MemberNode).GetMethod("GetMember", new Type[]{
typeof(object), typeof(string), typeof(object[]),
typeof(bool)}));
BlockLabel noParsedMethod = new BlockLabel("noParsedMethod");
block.Dup();
block.BranchIfNull(noParsedMethod);
BlockLocal parsedMethod = new BlockLocal(typeof(object));
block.DeclareLocal(parsedMethod);
block.StoreLocal(parsedMethod);
block.LoadRuntimeState();
block.LoadLocal(parsedMethod);
block.LoadLocal(parsedParameters);
block.Call(typeof(CallNode).GetMethod("Call", new Type[]{
typeof(RuntimeState), typeof(object), typeof(object[])}));
block.Pop();
BlockLabel finishedParsedCall = new BlockLabel("finishedParsedCall");
block.Branch(finishedParsedCall);
block.MarkLabel(noParsedMethod);
block.Pop();
block.MarkLabel(finishedParsedCall);
block.EndScope();
block.LoadLocal(instance);
block.New(typeof(ParseTree).GetConstructor(new Type[]{typeof(object)}));
block.StoreLocal(tree);
block.EndScope();
}
public override Block CompileNew(Runtime runtime, StateForCompiler state)
{
ParserBlock block = new ParserBlock(runtime);
block.Comment("start of concrete pattern -------------");
BlockLabel returnLabel = new BlockLabel("return");
block.BeginScope();
block.Enter(this, Type.Name);
BlockLocal start = block.SavePosition();
BlockLabel notExcluded = new BlockLabel("notExcluded");
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Excluded"));
block.Load(this);
block.Call(typeof(Multiset<Pattern>).GetMethod("Contains"));
block.BranchIfFalse(notExcluded);
block.No(this, "Excluded");
block.LoadNo();
block.Branch(returnLabel);
block.MarkLabel(notExcluded);
BlockLocal key = new BlockLocal(typeof(ParserMemoryKey));
block.DeclareLocal(key);
block.Load(this);
block.LoadLocal(start);
block.New(typeof(ParserMemoryKey).GetConstructor(new Type[]{typeof(ConcretePattern), typeof(int)}));
block.StoreLocal(key);
BlockLocal oldSkipMemoryForLeftRecursion = new BlockLocal(typeof(bool));
block.DeclareLocal(oldSkipMemoryForLeftRecursion);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("SkipMemoryForLeftRecursion"));
block.Dup();
block.StoreLocal(oldSkipMemoryForLeftRecursion);
BlockLabel checkMemory = new BlockLabel("checkMemory");
block.BranchIfFalse(checkMemory);
block.LoadState();
block.Load(false);
block.SetProperty(typeof(ParserState).GetProperty("SkipMemoryForLeftRecursion"));
BlockLabel setRecursion = new BlockLabel("setRecursion");
block.Branch(setRecursion);
block.MarkLabel(checkMemory);
block.BeginScope();
BlockLocal entry = new BlockLocal(typeof(ParserMemoryEntry));
block.DeclareLocal(entry);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Memory"));
block.LoadLocal(key);
block.LoadLocalAddress(entry);
block.Call(typeof(Dictionary<ParserMemoryKey, ParserMemoryEntry>).GetMethod("TryGetValue"));
block.BranchIfFalse(setRecursion);
// todo link next
BlockLabel memoryYes = new BlockLabel("memoryYes");
block.LoadLocal(entry);
block.GetProperty(typeof(ParserMemoryEntry).GetProperty("Tree"));
BlockLabel returnTree = new BlockLabel("returnTree");
block.BranchIfNotNo(memoryYes);
block.No(this, start, "from memory");
block.Branch(returnTree);
block.MarkLabel(memoryYes);
block.Yes(this, start, "from memory");
block.LoadLexer();
block.LoadLocal(entry);
block.GetProperty(typeof(ParserMemoryEntry).GetProperty("End"));
block.SetProperty(typeof(Lexer).GetProperty("Position"));
block.MarkLabel(returnTree);
block.LoadLocal(entry);
block.GetProperty(typeof(ParserMemoryEntry).GetProperty("Tree"));
block.Branch(returnLabel);
block.MarkLabel(setRecursion);
BlockLocal oldRecursionExclude = new BlockLocal(typeof(ConcretePattern));
block.DeclareLocal(oldRecursionExclude);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("RecursionExclude"));
block.StoreLocal(oldRecursionExclude);
if (RecursionBehaviour != RecursionBehaviour.Recursive)
{
BlockLabel recursionExcludeSaveNull = new BlockLabel("recursionExcludeSaveNull");
block.LoadLocal(oldRecursionExclude);
block.BranchIfNull(recursionExcludeSaveNull);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Excluded"));
block.LoadLocal(oldRecursionExclude);
block.Call(typeof(Multiset<Pattern>).GetMethod("Remove", new Type[]{typeof(Pattern)}));
block.MarkLabel(recursionExcludeSaveNull);
block.LoadState();
block.Load(this);
block.SetProperty(typeof(ParserState).GetProperty("RecursionExclude"));
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Excluded"));
block.Load(this);
block.Call(typeof(Multiset<Pattern>).GetMethod("Add", new Type[]{typeof(Pattern)}));
}
BlockLocal oldRecursionBehaviour = new BlockLocal(typeof(RecursionBehaviour));
block.DeclareLocal(oldRecursionBehaviour);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("RecursionBehaviour"));
block.StoreLocal(oldRecursionBehaviour);
block.LoadState();
block.Load(Convert.ToInt32(RecursionBehaviour));
block.SetProperty(typeof(ParserState).GetProperty("RecursionBehaviour"));
RecursionBehaviour oldRecursionBehaviourState = state.RecursionBehaviour;
state.RecursionBehaviour = RecursionBehaviour;
BlockLocal oldCurrentPrecedence = new BlockLocal(typeof(Precedence));
block.DeclareLocal(oldCurrentPrecedence);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("CurrentPrecedence"));
block.StoreLocal(oldCurrentPrecedence);
BlockLabel doesntOverwrite = new BlockLabel("doesntOverwrite");
block.Load(Precedence);
block.LoadLocal(oldCurrentPrecedence);
block.Call(typeof(Precedence).GetMethod("Overwrites"));
block.BranchIfFalse(doesntOverwrite);
block.LoadState();
block.Load(Precedence);
block.SetProperty(typeof(ParserState).GetProperty("CurrentPrecedence"));
block.MarkLabel(doesntOverwrite);
BlockLocal oldPrecedenceCanEqualCurrent = new BlockLocal(typeof(bool));
block.DeclareLocal(oldPrecedenceCanEqualCurrent);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("PrecedenceCanEqualCurrent"));
block.StoreLocal(oldPrecedenceCanEqualCurrent);
block.LoadState();
block.Load(RecursionBehaviour == RecursionBehaviour.Recursive);
block.SetProperty(typeof(ParserState).GetProperty("PrecedenceCanEqualCurrent"));
BlockLocal tree = new BlockLocal(typeof(ParseTree));
block.DeclareLocal(tree);
block.Emit(ParseGraph.Compile(runtime, state));
block.StoreLocal(tree);
block.LoadState();
block.LoadLocal(oldCurrentPrecedence);
block.SetProperty(typeof(ParserState).GetProperty("CurrentPrecedence"));
block.LoadState();
block.LoadLocal(oldPrecedenceCanEqualCurrent);
block.SetProperty(typeof(ParserState).GetProperty("PrecedenceCanEqualCurrent"));
block.LoadState();
block.LoadLocal(oldRecursionBehaviour);
block.SetProperty(typeof(ParserState).GetProperty("RecursionBehaviour"));
state.RecursionBehaviour = oldRecursionBehaviourState;
block.LoadState();
block.LoadLocal(oldRecursionExclude);
block.SetProperty(typeof(ParserState).GetProperty("RecursionExclude"));
block.LoadState();
block.LoadLocal(oldSkipMemoryForLeftRecursion);
block.SetProperty(typeof(ParserState).GetProperty("SkipMemoryForLeftRecursion"));
if (RecursionBehaviour != RecursionBehaviour.Recursive)
{
BlockLabel recursionExcludeRestoreNull = new BlockLabel("recursionExcludeRestoreNull");
block.LoadLocal(oldRecursionExclude);
block.BranchIfNull(recursionExcludeRestoreNull);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Excluded"));
block.LoadLocal(oldRecursionExclude);
block.Call(typeof(Multiset<Pattern>).GetMethod("Add", new Type[]{typeof(Pattern)}));
block.MarkLabel(recursionExcludeRestoreNull);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Excluded"));
block.Load(this);
block.Call(typeof(Multiset<Pattern>).GetMethod("Remove", new Type[]{typeof(Pattern)}));
}
BlockLabel no = new BlockLabel("yes1");
block.LoadLocal(tree);
block.BranchIfNo(no);
block.Whitespace(runtime, state);
CompileInstantiate(block, start, tree);
block.MarkLabel(no);
BlockLocal nextTag = new BlockLocal(typeof(object));
block.DeclareLocal(nextTag);
block.New(typeof(object));
block.StoreLocal(nextTag);
// todo tag next
BlockLabel yes = new BlockLabel("yes");
block.LoadLocal(tree);
block.BranchIfNotNo(yes);
block.No(this, start, "a");
BlockLabel finish = new BlockLabel("finish");
block.Branch(finish);
block.MarkLabel(yes);
block.Yes(this, start);
if (RecursionBehaviour == RecursionBehaviour.LeftRecursive)
CompileLeftRecurse(runtime, state, block, start, tree);
block.MarkLabel(finish);
if (ShouldRemember)
{
// TODO - can remove some other code if not remembering
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Memory"));
block.LoadLocal(key);
block.LoadLocal(tree);
block.LoadLexer();
block.GetProperty(typeof(Lexer).GetProperty("Position"));
block.LoadLocal(nextTag);
block.New(typeof(ParserMemoryEntry).GetConstructor(new Type[]{typeof(ParseTree), typeof(int), typeof(object)}));
block.SetProperty(typeof(Dictionary<ParserMemoryKey, ParserMemoryEntry>).GetProperty("Item"));
}
block.LoadLocal(tree);
block.EndScope();
block.MarkLabel(returnLabel);
block.Comment("end of concrete pattern -------------");
return block;
}
public override Block CompileNew(Runtime runtime, StateForCompiler state)
{
ParserBlock block = new ParserBlock(runtime);
block.Comment("start of abstract pattern -------------");
BlockLabel returnLabel = new BlockLabel("return");
block.Enter(this, Type.Name);
block.BeginScope();
BlockLocal start = block.SavePosition();
BlockLabel notExcluded = new BlockLabel("notExcluded");
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Excluded"));
block.Load(this);
block.Call(typeof(Multiset<Pattern>).GetMethod("Contains"));
block.BranchIfFalse(notExcluded);
block.No(this);
block.LoadNo();
block.Branch(returnLabel);
block.MarkLabel(notExcluded);
BlockLocal oldCurrentPrecedence = new BlockLocal(typeof(Precedence));
block.DeclareLocal(oldCurrentPrecedence);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("CurrentPrecedence"));
block.StoreLocal(oldCurrentPrecedence);
BlockLabel doesntOverwrite = new BlockLabel("doesntOverwrite");
block.Load(Precedence);
block.LoadLocal(oldCurrentPrecedence);
block.Call(typeof(Precedence).GetMethod("Overwrites"));
block.BranchIfFalse(doesntOverwrite);
block.LoadState();
block.Load(Precedence);
block.SetProperty(typeof(ParserState).GetProperty("CurrentPrecedence"));
block.MarkLabel(doesntOverwrite);
block.Emit(ParseGraph.Compile(runtime, state));
block.LoadState();
block.LoadLocal(oldCurrentPrecedence);
block.SetProperty(typeof(ParserState).GetProperty("CurrentPrecedence"));
block.Dup();
BlockLabel yes = new BlockLabel("yes");
block.BranchIfNotNo(yes);
block.No(this, start);
block.Branch(returnLabel);
block.MarkLabel(yes);
block.Yes(this, start);
block.EndScope();
block.MarkLabel(returnLabel);
block.Comment("end of abstract pattern -------------");
return block;
}
public override Block CompileNewState(Runtime runtime,
StateForCompiler state)
{
ParserBlock block = new ParserBlock(runtime);
block.Comment("start of pattern --------------------");
if (simple)
{
block.Emit(pattern.CompileCall(runtime, state));
}
else
{
BlockLabel returnLabel = new BlockLabel("return");
block.BeginScope();
BlockLocal patternLocal = new BlockLocal(typeof(Pattern));
block.DeclareLocal(patternLocal);
block.Load(pattern);
block.StoreLocal(patternLocal);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("LeftHandSide"));
BlockLabel parseNew = new BlockLabel("parseNew");
block.BranchIfNull(parseNew);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("LeftHandSide"));
block.GetProperty(typeof(ParseTree).GetProperty("Value"));
block.Call(typeof(object).GetMethod("GetType"));
BlockLocal leftType = new BlockLocal(typeof(Type));
block.DeclareLocal(leftType);
block.Dup();
block.StoreLocal(leftType);
block.LoadLocal(patternLocal);
block.GetProperty(typeof(Pattern).GetProperty("Type"));
BlockLocal patternType = new BlockLocal(typeof(Type));
block.DeclareLocal(patternType);
block.Dup();
block.StoreLocal(patternType);
BlockLabel recurse = new BlockLabel("recurse");
block.BranchIfEqual(recurse);
block.LoadLocal(leftType);
block.LoadLocal(patternType);
block.Call(typeof(Type).GetMethod("IsSubclassOf"));
block.BranchIfTrue(recurse);
block.Branch(parseNew);
block.MarkLabel(recurse);
block.Single("left hand side from recursion");
block.LoadLexer();
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("LeftHandSideEndPos"));
block.SetProperty(typeof(Lexer).GetProperty("Position"));
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("LeftHandSide"));
block.Branch(returnLabel);
block.MarkLabel(parseNew);
block.Emit(pattern.CompileCall(runtime, state));
block.MarkLabel(returnLabel);
block.EndScope();
}
block.Comment("end of pattern ---------------------");
return block;
}
public override Block CompileNewState(Runtime runtime,
StateForCompiler state)
{
ParserBlock block = new ParserBlock(runtime);
block.Comment("start of char --------------------");
block.BeginScope();
block.Whitespace(runtime, state);
BlockLocal start = block.SavePosition();
block.Enter(this, range.ToString());
block.LoadLexer();
block.Call(typeof(Lexer).GetMethod("Peek", new Type[]{}));
BlockLabel failed = new BlockLabel("failed");
BlockLocal character = null;
if (range.Min == range.Max)
{
if (runtime.TraceParser)
{
block.Dup();
character = new BlockLocal(typeof(char));
block.DeclareLocal(character);
block.StoreLocal(character);
}
block.Load(range.Min);
block.BranchIfNotEqual(failed);
}
else
{
character = new BlockLocal(typeof(char));
block.DeclareLocal(character);
block.StoreLocal(character);
block.LoadLocal(character);
block.Load(range.Min);
block.BranchIfLess(failed);
block.LoadLocal(character);
block.Load(range.Max);
block.BranchIfGreater(failed);
}
block.LoadLexer();
block.Call(typeof(Lexer).GetMethod("Read"));
if (runtime.TraceParser)
{
block.LoadParseTrace();
block.Load(this);
block.LoadLexer();
block.LoadLocal(start);
block.Call(typeof(Lexer).GetMethod("SourceFrom"));
block.LoadLocal(character);
block.Call(typeof(TextEscape).GetMethod("Quote", new Type[]{typeof(char)}));
block.Call(typeof(ParseTrace).GetMethod("Yes", new Type[]{typeof(object), typeof(Source), typeof(string)}));
}
if (state.BuildTextNodes)
{
if (range.Min == range.Max)
{
block.Pop();
block.Load(Convert.ToString(range.Min));
}
else
{
block.Call(typeof(Convert).GetMethod("ToString", new Type[]{typeof(char)}));
}
block.New(typeof(ParseTree).GetConstructor(new Type[]{typeof(object)}));
}
else
{
block.Pop();
block.LoadYes();
}
BlockLabel returnLabel = new BlockLabel("return");
block.Branch(returnLabel);
block.MarkLabel(failed);
if (runtime.TraceParser)
{
block.LoadParseTrace();
block.Load(this);
block.LoadLexer();
block.LoadLocal(start);
block.Call(typeof(Lexer).GetMethod("SourceFrom"));
block.LoadLocal(character);
block.Call(typeof(TextEscape).GetMethod("Quote", new Type[]{typeof(char)}));
block.Call(typeof(ParseTrace).GetMethod("No", new Type[]{typeof(object), typeof(Source), typeof(string)}));
}
// todo error string
block.LoadNo();
block.EndScope();
block.MarkLabel(returnLabel);
block.Comment("end of char --------------------");
return block;
}
public void BranchIfTrue(BlockLabel label)
{
Emit(OpCodes.Brtrue, label);
}
private void CompileLeftRecurse(Runtime runtime,
StateForCompiler state, ParserBlock block, BlockLocal start,
BlockLocal tree)
{
block.BeginScope();
block.Enter(this, "left recurse");
BlockLocal finished = block.SavePosition();
block.LoadState();
block.LoadLocal(tree);
block.SetProperty(typeof(ParserState).GetProperty("LeftHandSide"));
block.LoadState();
block.LoadLocal(finished);
block.SetProperty(typeof(ParserState).GetProperty("LeftHandSideEndPos"));
block.LoadState();
block.Load(true);
block.SetProperty(typeof(ParserState).GetProperty("SkipMemoryForLeftRecursion"));
block.LoadLexer();
block.LoadLocal(start);
block.SetProperty(typeof(Lexer).GetProperty("Position"));
ParseGraphNode node;
if (state.LeftRecursiveAlts != null)
node = state.LeftRecursiveAlts;
else
node = recurseNode;
block.Emit(node.Compile(runtime, state));
block.LoadState();
block.Load(false);
block.SetProperty(typeof(ParserState).GetProperty("SkipMemoryForLeftRecursion"));
block.LoadState();
block.LoadNull();
block.SetProperty(typeof(ParserState).GetProperty("LeftHandSide"));
BlockLabel yes = new BlockLabel("yes");
block.Dup();
block.BranchIfNotNo(yes);
block.No(this, start);
block.Pop();
block.RestorePosition(finished);
BlockLabel returnLabel = new BlockLabel("return");
block.Branch(returnLabel);
block.MarkLabel(yes);
block.Yes(this, start);
block.StoreLocal(tree);
block.MarkLabel(returnLabel);
block.EndScope();
}
public void BranchIfLess(BlockLabel label)
{
Emit(OpCodes.Blt, label);
}
public override Block CompileNewState(Runtime runtime, StateForCompiler state)
{
ParserBlock block = new ParserBlock();
block.Comment("begin precedence alt -----------");
// todo enter
block.BeginScope();
BlockLabel returnLabel = new BlockLabel("return");
BlockLocal oldLeftRecursiveAlts = new BlockLocal(typeof(IParseable));
block.DeclareLocal(oldLeftRecursiveAlts);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("LeftRecursiveAlts"));
block.StoreLocal(oldLeftRecursiveAlts);
ParseGraphNode oldLeftRecursiveAltsForCompiler = state.LeftRecursiveAlts;
foreach (PrecedenceAltGroup group in groups)
{
block.BeginScope();
BlockLocal groupLocal = new BlockLocal(typeof(PrecedenceAltGroup));
block.DeclareLocal(groupLocal);
block.Load(group);
block.StoreLocal(groupLocal);
BlockLabel apply = new BlockLabel("apply");
BlockLabel continueLabel = new BlockLabel("continue");
BlockLocal currentPrecedence = new BlockLocal(typeof(Precedence));
block.DeclareLocal(currentPrecedence);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("CurrentPrecedence"));
block.Dup();
block.StoreLocal(currentPrecedence);
block.BranchIfNull(apply);
BlockLocal groupPrecedence = new BlockLocal(typeof(Precedence));
block.DeclareLocal(groupPrecedence);
block.LoadLocal(groupLocal);
block.GetProperty(groupLocal.Type.GetProperty("Precedence"));
block.Dup();
block.StoreLocal(groupPrecedence);
block.BranchIfNull(apply);
block.LoadLocal(currentPrecedence);
block.GetProperty(currentPrecedence.Type.GetProperty("Group"));
block.LoadLocal(groupPrecedence);
block.GetProperty(groupPrecedence.Type.GetProperty("Group"));
block.BranchIfNotEqual(apply);
block.LoadLocal(groupPrecedence);
block.LoadLocal(currentPrecedence);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("PrecedenceCanEqualCurrent"));
block.LogicalNot();
block.Call(groupPrecedence.Type.GetMethod("IsLowerThan"));
block.BranchIfTrue(continueLabel);
block.MarkLabel(apply);
block.LoadState();
block.LoadLocal(groupLocal);
block.GetProperty(groupLocal.Type.GetProperty("LeftRecursiveParseGraph"));
block.SetProperty(typeof(ParserState).GetProperty("LeftRecursiveAlts"));
state.LeftRecursiveAlts = group.LeftRecursiveParseGraph;
block.Emit(group.ParseGraph.Compile(runtime, state));
block.Dup();
BlockLabel no = new BlockLabel("no");
block.BranchIfNo(no);
block.LoadState();
block.LoadLocal(oldLeftRecursiveAlts);
block.SetProperty(typeof(ParserState).GetProperty("LeftRecursiveAlts"));
// todo yes
block.Branch(returnLabel);
block.MarkLabel(no);
block.Pop();
block.MarkLabel(continueLabel);
block.EndScope();
}
block.LoadState();
block.LoadLocal(oldLeftRecursiveAlts);
block.SetProperty(typeof(ParserState).GetProperty("LeftRecursiveAlts"));
state.LeftRecursiveAlts = oldLeftRecursiveAltsForCompiler;
block.EndScope();
// todo no
block.LoadNo();
block.MarkLabel(returnLabel);
block.Comment("end precedence alt -----------");
return block;
}
public void BranchIfNotNull(BlockLabel label)
{
BranchIfTrue(label);
}
public override Block CompileNewState(Runtime runtime,
StateForCompiler state)
{
ParserBlock block = new ParserBlock();
BlockLabel returnLabel = new BlockLabel("return");
block.Comment("start of seq --------------------");
block.BeginScope();
// Save
BlockLocal start = block.SavePosition();
BlockLocal oldLeftHandSide = new BlockLocal(typeof(RuntimeObject));
BlockLocal oldPrecedenceCanEqualCurrent = new BlockLocal(typeof(bool));
BlockLocal oldRecursionExclude = new BlockLocal(typeof(Pattern));
block.DeclareLocal(oldRecursionExclude);
if (state.RecursionBehaviour == RecursionBehaviour.RightRecursive)
{
block.DeclareLocal(oldPrecedenceCanEqualCurrent);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("PrecedenceCanEqualCurrent"));
block.StoreLocal(oldPrecedenceCanEqualCurrent);
}
if (state.RecursionBehaviour == RecursionBehaviour.LeftRecursive)
{
block.DeclareLocal(oldLeftHandSide);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("LeftHandSide"));
block.StoreLocal(oldLeftHandSide);
}
block.LoadYes();
for (int n = 0; n < nodes.Count; n++)
{
ParseGraphNode node = nodes[n];
// Parse the node
block.Emit(node.Compile(runtime, state));
// If no
BlockLabel yes = new BlockLabel("yes");
block.Dup(); // dup the body tree
block.BranchIfNotNo(yes);
block.Pop(); // pop body tree
block.Pop(); // pop new tree
Restore(state, block, oldLeftHandSide,
oldPrecedenceCanEqualCurrent, oldRecursionExclude);
block.RestorePosition(start);
block.LoadNo();
block.Branch(returnLabel);
block.MarkLabel(yes);
// Extend
block.Call(typeof(ParseTree).GetMethod("Extend"));
if (n == 0)
{
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("RecursionExclude"));
block.LoadNull();
BlockLabel recursionExcludeNull = new BlockLabel("recursionExcludeNull");
block.BranchIfEqual(recursionExcludeNull);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("RecursionExclude"));
block.StoreLocal(oldRecursionExclude);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Excluded"));
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("RecursionExclude"));
block.Call(typeof(Multiset<Pattern>).GetMethod("Remove", new Type[]{typeof(Pattern)}));
block.LoadState();
block.LoadNull();
block.SetProperty(typeof(ParserState).GetProperty("RecursionExclude"));
block.MarkLabel(recursionExcludeNull);
if (state.RecursionBehaviour == RecursionBehaviour.RightRecursive)
{
block.Comment("right recursion");
block.LoadState();
block.Load(1);
block.SetProperty(typeof(ParserState).GetProperty("PrecedenceCanEqualCurrent"));
}
else if (state.RecursionBehaviour == RecursionBehaviour.LeftRecursive)
{
block.Comment("left recursion");
block.LoadState();
block.LoadNull();
block.SetProperty(typeof(ParserState).GetProperty("LeftHandSide"));
}
}
}
Restore(state, block, oldLeftHandSide,
oldPrecedenceCanEqualCurrent, oldRecursionExclude);
block.EndScope();
block.MarkLabel(returnLabel);
block.Comment("end of seq --------------------");
return block;
}
public void BranchIfNotNull(BlockLabel label)
{
BranchIfTrue(label);
}
private void Restore(StateForCompiler state, ParserBlock block,
BlockLocal oldLeftHandSide,
BlockLocal oldPrecedenceCanEqualCurrent,
BlockLocal oldRecursionExclude)
{
block.LoadState();
block.LoadLocal(oldRecursionExclude);
block.SetProperty(typeof(ParserState).GetProperty("RecursionExclude"));
BlockLabel nullLabel = new BlockLabel("null");
block.LoadLocal(oldRecursionExclude);
block.LoadNull();
block.BranchIfEqual(nullLabel);
block.LoadState();
block.GetProperty(typeof(ParserState).GetProperty("Excluded"));
block.LoadLocal(oldRecursionExclude);
block.Call(typeof(Multiset<Pattern>).GetMethod("Add"));
block.MarkLabel(nullLabel);
if (state.RecursionBehaviour == RecursionBehaviour.RightRecursive)
{
block.LoadState();
block.LoadLocal(oldPrecedenceCanEqualCurrent);
block.SetProperty(typeof(ParserState).GetProperty("PrecedenceCanEqualCurrent"));
}
else if (state.RecursionBehaviour == RecursionBehaviour.LeftRecursive)
{
block.LoadState();
block.LoadLocal(oldLeftHandSide);
block.SetProperty(typeof(ParserState).GetProperty("LeftHandSide"));
}
}
public void Build(IMethodBuilder builder)
{
//Dump();
ILGenerator il = builder.GetILGenerator();
Dictionary <BlockLabel, Label> labels
= new Dictionary <BlockLabel, Label>();
Dictionary <BlockLocal, LocalBuilder> locals
= new Dictionary <BlockLocal, LocalBuilder>();
foreach (IBlockLine line in (IEnumerable <IBlockLine>)lines)
{
BlockInstruction instruction = line as BlockInstruction;
if ((instruction != null) && (instruction.Operation == BlockOperation.MarkLabel))
{
labels[(BlockLabel)instruction.Parameter] = il.DefineLabel();
}
}
foreach (IBlockLine line in (IEnumerable <IBlockLine>)lines)
{
if (line is Instruction)
{
Instruction instruction = line as Instruction;
if (instruction.Parameter == null)
{
il.Emit(instruction.Op);
}
else if (instruction.Parameter is int)
{
il.Emit(instruction.Op, (int)instruction.Parameter);
}
else if (instruction.Parameter is string)
{
il.Emit(instruction.Op, (string)instruction.Parameter);
}
else if (instruction.Parameter is Type)
{
il.Emit(instruction.Op, (Type)instruction.Parameter);
}
else if (instruction.Parameter is FieldInfo)
{
il.Emit(instruction.Op, (FieldInfo)instruction.Parameter);
}
else if (instruction.Parameter is MethodInfo)
{
il.Emit(instruction.Op, (MethodInfo)instruction.Parameter);
}
else if (instruction.Parameter is ConstructorInfo)
{
il.Emit(instruction.Op, (ConstructorInfo)instruction.Parameter);
}
else if (instruction.Parameter is BlockLabel)
{
BlockLabel blockLabel = (BlockLabel)instruction.Parameter;
Label label;
if (!labels.TryGetValue(blockLabel, out label))
{
throw new Exception("Label " + blockLabel.Name + " not marked");
}
il.Emit(instruction.Op, label);
}
else if (instruction.Parameter is BlockLocal)
{
il.Emit(instruction.Op, locals[(BlockLocal)instruction.Parameter]);
}
else
{
throw new NotImplementedException(instruction.Op.Value + " " + TypeNames.GetName(instruction.Parameter.GetType()));
}
}
else if (line is BlockInstruction)
{
BlockInstruction instruction = line as BlockInstruction;
if (instruction.Operation == BlockOperation.Comment)
{
}
else if (instruction.Operation == BlockOperation.MarkLabel)
{
il.MarkLabel(labels[(BlockLabel)instruction.Parameter]);
}
else if (instruction.Operation == BlockOperation.DeclareLocal)
{
BlockLocal local = (BlockLocal)instruction.Parameter;
locals[local] = il.DeclareLocal(local.Type);
}
else if (instruction.Operation == BlockOperation.BeginScope)
{
il.BeginScope();
}
else if (instruction.Operation == BlockOperation.EndScope)
{
il.EndScope();
}
else
{
throw new Exception();
}
}
else
{
throw new Exception();
}
}
}
public override Block CompileNewState(Runtime runtime,
StateForCompiler state)
{
ParserBlock block = new ParserBlock();
block.Comment("start of rep " + reps.Name + " --------------------");
// todo enter
block.BeginScope();
BlockLabel returnLabel = new BlockLabel("return");
BlockLocal start = block.SavePosition();
block.NewParseTree();
BlockLabel reiterate = null;
BlockLocal matched = null;
if (!reps.MaximumOfOne)
{
reiterate = new BlockLabel("reiterate");
block.MarkLabel(reiterate);
matched = new BlockLocal(typeof(bool));
block.DeclareLocal(matched);
}
BlockLabel breakLabel = new BlockLabel("break");
block.Emit(body.Compile(runtime, state));
BlockLabel yes = new BlockLabel("yes");
block.Dup();
block.BranchIfNotNo(yes);
block.Pop();
block.Branch(breakLabel);
block.MarkLabel(yes);
block.Call(typeof(ParseTree).GetMethod("Extend"));
if (!reps.MaximumOfOne)
{
block.Load(true);
block.StoreLocal(matched);
block.Branch(reiterate);
}
block.MarkLabel(breakLabel);
if (reps.Minimum > 0)
{
BlockLabel enough = new BlockLabel("enough");
block.LoadLocal(matched);
block.BranchIfTrue(enough);
// todo no
block.RestorePosition(start);
block.Pop();
block.LoadNo();
block.Branch(returnLabel);
block.MarkLabel(enough);
}
// todo yes
block.MarkLabel(returnLabel);
block.EndScope();
block.Comment("end of rep --------------------");
return block;
}
public void BranchIfNo(BlockLabel label)
{
GetProperty(typeof(ParseTree).GetProperty("No"));
BranchIfEqual(label);
}
public void Branch(BlockLabel label)
{
Emit(OpCodes.Br, label);
}
public void BranchIfNo(BlockLabel label)
{
GetProperty(typeof(ParseTree).GetProperty("No"));
BranchIfEqual(label);
}
public void BranchIfTrue(BlockLabel label)
{
Emit(OpCodes.Brtrue, label);
}
public override Block CompileNewState(Runtime runtime, StateForCompiler state)
{
ParserBlock block = new ParserBlock(runtime);
block.Comment("begin longest alt -----------");
block.Enter(this, "longest alt");
block.BeginScope();
BlockLocal start = block.SavePosition();
BlockLocal longestTree = new BlockLocal(typeof(ParseTree));
block.DeclareLocal(longestTree);
block.LoadNull();
block.StoreLocal(longestTree);
BlockLocal longestTreeEnd = new BlockLocal(typeof(int));
block.DeclareLocal(longestTreeEnd);
block.Load(-1);
block.StoreLocal(longestTreeEnd);
foreach (IParseable alt in alts)
{
block.Emit(alt.Compile(runtime, state));
BlockLabel no = new BlockLabel("no");
block.Dup();
block.BranchIfNo(no);
block.LoadLexer();
block.GetProperty(typeof(Lexer).GetProperty("Position"));
block.LoadLocal(longestTreeEnd);
block.BranchIfLessOrEqual(no);
block.StoreLocal(longestTree);
block.LoadLexer();
block.GetProperty(typeof(Lexer).GetProperty("Position"));
block.StoreLocal(longestTreeEnd);
BlockLabel continueLabel = new BlockLabel("continue");
block.Branch(continueLabel);
block.MarkLabel(no);
block.Pop();
block.MarkLabel(continueLabel);
block.RestorePosition(start);
}
BlockLabel yes = new BlockLabel("null");
block.LoadLocal(longestTree);
block.BranchIfNotNull(yes);
block.Comment("no");
block.No(this, start, "No alts matched");
block.LoadNo();
BlockLabel returnLabel = new BlockLabel("return");
block.Branch(returnLabel);
block.Comment("yes");
block.MarkLabel(yes);
block.Yes(this, start);
block.RestorePosition(longestTreeEnd);
block.LoadLocal(longestTree);
block.MarkLabel(returnLabel);
block.Comment("end longest alt -----------");
return block;
}
public void BranchIfFalse(BlockLabel label)
{
Emit(OpCodes.Brfalse, label);
}
public void Branch(BlockLabel label)
{
Emit(OpCodes.Br, label);
}
public void BranchIfEqual(BlockLabel label)
{
Emit(OpCodes.Beq, label);
}
public void BranchIfFalse(BlockLabel label)
{
Emit(OpCodes.Brfalse, label);
}
public void BranchIfNotEqual(BlockLabel label)
{
Emit(OpCodes.Bne_Un, label);
}
public void BranchIfNotEqual(BlockLabel label)
{
Emit(OpCodes.Bne_Un, label);
}
public void BranchIfLess(BlockLabel label)
{
Emit(OpCodes.Blt, label);
}
public void BranchIfLessOrEqual(BlockLabel label)
{
Emit(OpCodes.Ble, label);
}
public void BranchIfLessOrEqual(BlockLabel label)
{
Emit(OpCodes.Ble, label);
}
public void BranchIfNull(BlockLabel label)
{
BranchIfFalse(label);
}
public void BranchIfGreater(BlockLabel label)
{
Emit(OpCodes.Bgt, label);
}
public void MarkLabel(BlockLabel label)
{
Emit(new BlockInstruction(BlockOperation.MarkLabel, label));
}
public void BranchIfNull(BlockLabel label)
{
BranchIfFalse(label);
}
