/// <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 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)); }