/// <summary>
/// Feed this method with a visitor implementing IParserVisitor to visit all the parsed items
/// </summary>
/// <param name="visitor"></param>
public void Accept(IParserVisitor visitor)
{
visitor.PreVisit(this);
foreach (var item in _parsedItemList)
{
item.Accept(visitor);
}
visitor.PostVisit();
}
/// <summary>Accept the visitor. *
/// </summary>
public Object ChildrenAccept(IParserVisitor visitor, Object data)
{
if (children != null)
{
for (int i = 0; i < children.Length; ++i)
{
children[i].Accept(visitor, data);
}
}
return(data);
}
public object ChildrenAccept(IParserVisitor visitor, object data)
{
if (this.children != null)
{
for (int i = 0; i < this.children.Length; i++)
{
this.children[i].Accept(visitor, data);
}
}
return(data);
}
TReturn ParseStruct(IEnumerator <DType> tokens, IParserVisitor <TReturn> visitor)
{
IEnumerable <TReturn> result = Parse(tokens, visitor);
IEnumerable <TReturn> temp = null;
while ((temp = Parse(tokens, visitor)) != null)
{
result = Enumerable.Concat(result, temp);
}
return(visitor.ParseStructDefinition(result));
}
TReturn ParseDict(IEnumerator <DType> tokens, IParserVisitor <TReturn> visitor)
{
if (!tokens.MoveNext())
{
throw new ParseException("A dictionary type is malformed");
}
IEnumerable <TReturn> type1 = Parse(tokens, visitor);
IEnumerable <TReturn> type2 = Parse(tokens, visitor);
tokens.MoveNext();
return(visitor.ParseDictDefinition(type1.First(), type2.First()));
}
public IEnumerable <TReturn> Parse(IEnumerator <DType> tokens, IParserVisitor <TReturn> visitor)
{
DType current = tokens.Current;
if (current == DType.DictEntryEnd || current == DType.StructEnd)
{
tokens.MoveNext();
return(null);
}
// May be an array or a dict
if (current == DType.Array)
{
if (!tokens.MoveNext())
{
throw new ParseException("An array type is malformed");
}
if (tokens.Current == DType.DictEntryBegin)
{
return(Wrap(ParseDict(tokens, visitor)));
}
else
{
return(Wrap(visitor.ParseArrayDefinition(Parse(tokens, visitor).First())));
}
}
if (current == DType.StructBegin)
{
if (!tokens.MoveNext())
{
throw new ParseException("A structure is malformed");
}
return(Wrap(ParseStruct(tokens, visitor)));
}
IEnumerable <TReturn> result = Wrap(visitor.ParseBaseTypeDefinition(current));
tokens.MoveNext();
return(result);
}
public TReturn ParseDBusTypeExpression(string expression, IParserVisitor <TReturn> visitor)
{
if (string.IsNullOrEmpty(expression))
{
return(visitor.Default);
}
// Assume it's a base type and thus directly return the corresponding type
if (expression.Length == 1)
{
return(visitor.ParseBaseTypeDefinition((DType)(byte)expression[0]));
}
TReturn temp;
IEnumerable <DType> expressionList = expression.Select((c) => (DType)(byte)c);
IEnumerator <DType> enumerator = expressionList.GetEnumerator();
enumerator.MoveNext();
try {
temp = Parse(enumerator, visitor).First();
} catch {
temp = visitor.Error;
}
return(temp);
}
public virtual object JjtAccept(IParserVisitor visitor, object data)
{
throw new JepException("Illegal node type encountered");
}
/// <summary>Accept the visitor. *
/// </summary>
public Object ChildrenAccept(IParserVisitor visitor, Object data)
{
if (children != null)
{
for(int i = 0; i < children.Length; ++i)
{
children[i].Accept(visitor, data);
}
}
return data;
}
/// <summary>
/// Accept the visitor.
/// </summary>
public override Object Accept(IParserVisitor visitor, Object data)
{
return visitor.Visit(this, data);
}
/// <summary>
/// Feed this method with a visitor implementing IParserVisitor to visit all the parsed items
/// </summary>
/// <param name="visitor"></param>
public void Accept(IParserVisitor visitor)
{
visitor.PreVisit();
foreach (var item in _parsedItemList) {
item.Accept(visitor);
}
visitor.PostVisit();
}
public void Process(IInternalContextAdapter context, IParserVisitor visitor)
{
}
public void Process(IInternalContextAdapter context, IParserVisitor visitor)
{
}
public abstract void Accept(IParserVisitor visitor);
/*static IParserVisitor<string> visitor = new CSharpVisitor(realParser);*/
/*public static string ParseDBusTypeExpression(string expression)
{
return realParser.ParseDBusTypeExpression(expression, visitor);
}*/
public static string ParseDBusTypeExpression(string expression, IParserVisitor<string> visitor)
{
return realParser.ParseDBusTypeExpression(expression, visitor);
}
public override void Accept(IParserVisitor visitor)
{
// no visits
}
/// <inheritdoc />
public override void Accept(IParserVisitor visitor)
{
visitor.VisitBlock(this);
}
/// <summary>Accept the visitor. *
/// </summary>
public virtual Object Accept(IParserVisitor visitor, Object data)
{
return(visitor.Visit(this, data));
}
/// <summary> /// Accepts a parser visitor to walk the syntax tree. /// </summary> /// <param name="visitor">The parser visitor</param> public abstract void Accept(IParserVisitor visitor);
/// <summary>
/// Accept the visitor.
/// </summary>
public override Object Accept(IParserVisitor visitor, Object data)
{
return(visitor.Visit(this, data));
}
/// <summary>Accept the visitor. *
/// </summary>
public virtual Object Accept(IParserVisitor visitor, Object data)
{
return visitor.Visit(this, data);
}
/// <inheritdoc />
public override void Accept(IParserVisitor visitor)
{
visitor.VisitSpan(this);
}
/*static IParserVisitor<string> visitor = new CSharpVisitor(realParser);*/
/*public static string ParseDBusTypeExpression(string expression)
* {
* return realParser.ParseDBusTypeExpression(expression, visitor);
* }*/
public static string ParseDBusTypeExpression(string expression, IParserVisitor <string> visitor)
{
return(realParser.ParseDBusTypeExpression(expression, visitor));
}
