public override ParseTree Parse(Lexer lexer, ParserState state)
{
lexer.Whitespace(state.RuntimeState);
int start = lexer.Position;
state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(), "[]");
char character = lexer.Peek();
if (character == '\0')
{
state.RuntimeState.Runtime.ParseTrace.No(this, lexer.SourceFrom(start), "End of source");
return(ParseTree.No);
}
lexer.Read();
state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start), TextEscape.Quote(character));
if (state.BuildTextNodes)
{
return(new ParseTree(Convert.ToString(character)));
}
else
{
return(ParseTree.Yes);
}
}
public override ParseTree Parse(Lexer lexer, ParserState state)
{
lexer.Whitespace(state.RuntimeState);
int start = lexer.Position;
state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(), range.ToString());
char character = lexer.Peek();
if (!range.Contains(character))
{
lexer.ErrorStrings[start].Add(range.ToString());
state.RuntimeState.Runtime.ParseTrace.No(this,
lexer.SourceFrom(start), TextEscape.Quote(character));
return(ParseTree.No);
}
lexer.Read();
state.RuntimeState.Runtime.ParseTrace.Yes(this,
lexer.SourceFrom(start), TextEscape.Quote(character));
if (state.BuildTextNodes)
{
return(new ParseTree(Convert.ToString(character)));
}
else
{
return(ParseTree.Yes);
}
}
public static object GetMember(object obj, string member,
object[] parametersHint, bool throwIfUndefined)
{
if (obj is IScope)
{
// FIXME - shouldn't be using exceptions for this
try
{
return(((IScope)obj).GetName(member));
}
catch
{
}
}
MemberInfo memberInfo = FindMember(obj, member,
parametersHint);
if (memberInfo == null)
{
if (throwIfUndefined)
{
throw new Exception("can't find getable member "
+ TextEscape.Quote(member) + " in "
+ TypeNames.GetName(obj.GetType()));
}
else
{
return(null);
}
}
if (memberInfo is MethodInfo)
{
return(new ClrObjectMethodBinding(obj, (MethodInfo)memberInfo));
}
else if (memberInfo is PropertyInfo)
{
return(((PropertyInfo)memberInfo).GetValue(obj, null));
}
else if (memberInfo is FieldInfo)
{
object fieldValue = ((FieldInfo)memberInfo).GetValue(obj);
if (fieldValue is Method)
{
fieldValue = new ObjectMethodBinding(obj,
(Method)fieldValue);
}
return(fieldValue);
}
else
{
throw new Exception("can't get "
+ TypeNames.GetName(memberInfo.GetType()));
}
}
public override string ToString()
{
if (min == max)
{
return(TextEscape.Quote(min));
}
else
{
return(TextEscape.Quote(min) + ".." + TextEscape.Quote(max));
}
}
public RuntimeObject Parse(Lexer lexer, RuntimeState runtimeState)
{
runtimeState.Runtime.ParseTrace.Enter(this, null, lexer.FileName);
while (true)
{
ParserState state = new ParserState(runtimeState);
ParseTree tree;
if (runtimeState.Runtime.CompileParser)
{
tree = RootPattern.ParseUsingCompiler(lexer, state);
}
else
{
tree = RootPattern.Parse(lexer, state);
}
RuntimeObject obj = (RuntimeObject)tree.Value;
if (!lexer.Finished)
{
string got;
if (lexer.MaxPosition < lexer.Text.Length)
{
got = TextEscape.Quote(lexer.Text[lexer.MaxPosition]);
}
else
{
got = "end of source code";
}
throw new ParseException(
lexer.SourceAt(lexer.MaxPosition),
lexer.ErrorStrings[lexer.MaxPosition],
got);
}
runtimeState.Runtime.ParseTrace.Parsed(lexer.FileName, obj);
if (lexer.ChangingRoots)
{
lexer.Restart();
continue;
}
runtimeState.Runtime.ParseTrace.Yes(this, null);
return(obj);
}
}
public override string ToString()
{
if (parameter == null)
{
return(" " + op.ToString());
}
else if (parameter is string)
{
return(" " + op + " " + TextEscape.Quote((string)parameter));
}
else if (parameter is Type)
{
return(" " + op + " " + TypeNames.GetName((Type)parameter));
}
else if (parameter is FieldInfo)
{
FieldInfo field = (FieldInfo)parameter;
return(" " + op + " " + TypeNames.GetName(field.DeclaringType) + "::" + field.Name);
}
else if (parameter is MethodInfo)
{
MethodInfo method = (MethodInfo)parameter;
return(" " + op + " " + TypeNames.GetName(method.DeclaringType) + "::" + method.Name);
}
else if (parameter is ConstructorInfo)
{
ConstructorInfo constructor = (ConstructorInfo)parameter;
return(" " + op + " " + TypeNames.GetName(constructor.DeclaringType));
}
else if (parameter is BlockLocal)
{
return(" " + op + " " + TypeNames.GetName(((BlockLocal)parameter).Type));
}
else
{
return(" " + op + " " + parameter);
}
}
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 override ParseTree Parse(Lexer lexer, ParserState state)
{
lexer.Whitespace(state.RuntimeState);
int start = lexer.Position;
state.RuntimeState.Runtime.ParseTrace.Enter(
this,
lexer.CurrentSource(),
TextEscape.Quote(text));
for (int n = 0; n < text.Length; n++)
{
char character = lexer.Peek(n);
if (character != text[n])
{
string stoppedString;
if (character == '\0')
{
stoppedString = "end";
}
else
{
stoppedString = TextEscape.Quote(character);
}
lexer.ErrorStrings[start + n].Add(TextEscape.Quote(text));
if (n > 0)
{
state.RuntimeState.Runtime.ParseTrace.No(
this,
lexer.SourceFrom(start),
TextEscape.Quote(lexer.Text.Substring(start, n))
+ "..." + stoppedString);
}
else
{
state.RuntimeState.Runtime.ParseTrace.No(
this,
lexer.SourceFrom(start),
stoppedString);
}
return(ParseTree.No);
}
}
lexer.Skip(text.Length);
state.RuntimeState.Runtime.ParseTrace.Yes(this,
lexer.SourceFrom(start));
if (state.BuildTextNodes)
{
return(new ParseTree(text));
}
else
{
return(ParseTree.Yes);
}
}
public ObjectViewHeader GetHeader(object obj)
{
return(new ObjectViewHeader(TextEscape.Quote((string)obj), false, false));
}
private void AddNode(TreeIter parent, TextNode textNode)
{
store.AppendValues(parent, TextEscape.Quote(textNode.Text), textNode);
}
private void Add(TreeIter parent, string prefix, string node)
{
store.AppendValues(parent, prefix + TextEscape.Quote(node), GtkProofBox.Box(node));
}
