public void Unescape()
{
Assert.AreEqual("abc", TextEscape.Unescape("abc"));
Assert.AreEqual("\"", TextEscape.Unescape("\\\""));
Assert.AreEqual("\n", TextEscape.Unescape("\\n"));
Assert.AreEqual("\\", TextEscape.Unescape("\\\\"));
}
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 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 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 ParseGraphNode BuildParseGraph(RuntimeState state)
{
string text = (string)((String)this.text).text;
text = TextEscape.Unquote(text);
if (text.Length == 1)
{
return(new CharNode(Source, text[0]));
}
else
{
return(new TextNode(Source, text));
}
}
public override ParseGraphNode BuildParseGraph(RuntimeState state)
{
string min = (string)((Base.String) this.min).text;
string max = (string)((Base.String) this.max).text;
min = TextEscape.Unquote(min);
max = TextEscape.Unquote(max);
if ((min.Length != 1) || (max.Length != 1))
{
throw new Exception();
}
CharRange range = new CharRange(min[0], max[0]);
return(new CharNode(Source, range));
}
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);
}
}
private ParseGraphNode ParseNode()
{
string token = Read();
if ((token == "s") || (token == "a"))
{
Read("(");
List <ParseGraphNode> nodes = new List <ParseGraphNode>();
while (Peek() != ")")
{
nodes.Add(ParseNode());
}
Read(")");
if (token == "s")
{
return(new SeqNode(null, nodes));
}
else if (token == "a")
{
return(new AltNode(null, nodes, false));
}
}
else if ((token == "?") || (token == "*") || (token == "+"))
{
Read("(");
ParseGraphNode body = ParseNode();
Read(")");
return(new RepNode(null, body, Reps.ForName(token[0])));
}
else if (token == "&")
{
Read("(");
ParseGraphNode body = ParseNode();
Read(")");
return(new AndNode(null, body));
}
else if (token == "!")
{
Read("(");
ParseGraphNode body = ParseNode();
Read(")");
return(new NotNode(null, body));
}
else if (token == "r")
{
Read("(");
char min = TextEscape.Unquote(Read())[0];
char max = TextEscape.Unquote(Read())[0];
Read(")");
return(new CharNode(null, new CharRange(min, max)));
}
else if (token == "l")
{
Read("(");
string label = Read();
ParseGraphNode body = ParseNode();
Read(")");
return(new LabelNode(null, label, body));
}
else if (token == "t")
{
Read("(");
ParseGraphNode body = ParseNode();
Read(")");
return(new TokenNode(null, body));
}
else if (token == "o")
{
Read("(");
Dictionary <string, object> options = new Dictionary <string, object>();
while (Peek() == "(")
{
Read();
string optionName = Read();
object optionValue = ReadValue();
options[optionName] = optionValue;
Read(")");
}
ParseGraphNode body = ParseNode();
Read(")");
OptionsNode optionsNode = new OptionsNode(null, body);
foreach (string key in options.Keys)
{
switch (key)
{
case "buildTextNodes":
optionsNode.BuildTextNodes.Value = (bool)options[key];
break;
case "dropPrecedence":
optionsNode.DropPrecedence.Value = (bool)options[key];
break;
case "recursive":
{
if ((bool)options[key])
{
optionsNode.RecursionBehaviour.Value = RecursionBehaviour.Recursive;
}
else
{
optionsNode.RecursionBehaviour.Value = RecursionBehaviour.None;
}
} break;
case "leftRecursive":
optionsNode.RecursionBehaviour.Value = RecursionBehaviour.LeftRecursive;
break;
case "rightRecursive":
optionsNode.RecursionBehaviour.Value = RecursionBehaviour.RightRecursive;
break;
case "whitespace":
{
object value = options[key];
if (value == null)
{
optionsNode.Whitespace.Value = null;
}
else
{
optionsNode.Whitespace.Value = Pattern.PatternForType((Type)value);
}
} break;
case "exclude":
optionsNode.Exclude.Value = Pattern.PatternForType((Type)options[key]);
break;
}
}
return(optionsNode);
}
else if (token == "any")
{
return(new AnyNode(null));
}
else if ((token[0] >= '0') && (token[0] <= '9'))
{
return(new PatternNode(null, patterns[Convert.ToInt32(token)], false));
}
else if (token[0] == '\'')
{
string text = TextEscape.Unquote(token);
if (text.Length == 1)
{
return(new CharNode(null, text[0]));
}
else
{
return(new TextNode(null, text));
}
}
throw new Exception(token);
}
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));
}
