C# Lexer.SourceFrom方法代码示例

        public override ParseTree Parse(Lexer lexer, ParserState state)
        {
            state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(), "Pattern " + Type.Name);
            
            int start = lexer.Position;
            
            if (state.Excluded.Contains(this))
            {
                state.RuntimeState.Runtime.ParseTrace.No(this, lexer.CurrentSource(), "Excluded");
                return ParseTree.No;
            }
            
		    Precedence oldCurrentPrecedence = state.CurrentPrecedence;
		    
		    if (Precedence.Overwrites(state.CurrentPrecedence))
		        state.CurrentPrecedence = Precedence;

            ParseTree tree = ParseGraph.Parse(lexer, state);
            
            state.CurrentPrecedence = oldCurrentPrecedence;

            if (tree == ParseTree.No)
            {
                state.RuntimeState.Runtime.ParseTrace.No(this, lexer.SourceFrom(start));
                return ParseTree.No;
            }

            state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start));
            
            return tree;
        }

 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 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 override ParseTree Parse(Lexer lexer, ParserState state)
 {
     int start = lexer.Position;
     
     if (type == null)
         throw new Exception();
     
     if (state.RuntimeState.Runtime.TraceParser)
         state.RuntimeState.Runtime.ParseTrace.Enter(this,
             lexer.CurrentSource(),
             "User defined node " + TypeNames.GetName(type));
     
     object instance = NewNode.New(state.RuntimeState, type, null);
     object parseMethod = MemberNode.GetMember(instance, "Parse", true);
     object result = CallNode.Call(state.RuntimeState, parseMethod,
         new object[]{lexer});
     
     if (result == null)
         result = ParseTree.Yes;
     else if (result is bool)
     {
         if ((bool) result)
             result = ParseTree.Yes;
         else
             result = ParseTree.No;
     }
     
     if (state.RuntimeState.Runtime.TraceParser)
     {
         if (result == ParseTree.No)
             state.RuntimeState.Runtime.ParseTrace.No(this,
                 lexer.SourceFrom(start));
         else
             state.RuntimeState.Runtime.ParseTrace.Yes(this,
                 lexer.SourceFrom(start));
     }
     
     return (ParseTree) result;
 }

 public override ParseTree Parse(Lexer lexer, ParserState state)
 {
     state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(), "token");
     
     int start = lexer.Position;
     
     ParseTree bodyTree = body.Parse(lexer, state);
     
     if (bodyTree == ParseTree.No)
     {
         state.RuntimeState.Runtime.ParseTrace.No(this, lexer.SourceFrom(start));
         return ParseTree.No;
     }
     
     state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start));
     
     ParseTree tokenTree = new ParseTree(
         lexer.Text.Substring(start, lexer.Position - start));
     
     tokenTree = tokenTree.ExtendFields(bodyTree);
     
     return tokenTree;
 }

 public override ParseTree Parse(Lexer lexer, ParserState state)
 {
     state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(), Reps.Name);
     
     int start = lexer.Position;
     bool matched = false;
     
     ParseTree tree = ParseTree.Yes;
     
     while (true)
     {
         ParseTree repTree = body.Parse(lexer, state);
         
         if (repTree == ParseTree.No)
             break;
         
         tree = tree.Extend(repTree);
         
         if (reps.MaximumOfOne)
             break;
         
         matched = true;
     }
     
     if ((reps.Minimum > 0) && !matched)
     {
         state.RuntimeState.Runtime.ParseTrace.No(this, lexer.SourceFrom(start), "Not enough reps");
         
         lexer.Position = start;
         return ParseTree.No;
     }
     
     state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start));
     
     return tree;
 }

        public override ParseTree Parse(Lexer lexer, ParserState state)
        {
            state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(),
                "precedence alt, current = " + state.CurrentPrecedence
                + ", can equal current = " + state.PrecedenceCanEqualCurrent);

            int start = lexer.Position;
            
            ParseGraphNode oldLeftRecursiveAlts = state.LeftRecursiveAlts;
            
			foreach (PrecedenceAltGroup group in groups)
			{
			    if (state.CurrentPrecedence != null)
			    {
			        if (group.Precedence != null)
			        {
    			        if (state.CurrentPrecedence.Group == group.Precedence.Group)
    			        {
    			            if (group.Precedence.IsLowerThan(state.CurrentPrecedence,
    			                !state.PrecedenceCanEqualCurrent))
    			                    continue;
    			        }
		            }
			    }
			    
			    state.LeftRecursiveAlts = group.LeftRecursiveParseGraph;
			    
				ParseTree tree = group.ParseGraph.Parse(lexer, state);

				if (tree != ParseTree.No)
				{
			        state.LeftRecursiveAlts = oldLeftRecursiveAlts;
                    
				    state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start));
					return tree;
				}
			}
			
	        state.LeftRecursiveAlts = oldLeftRecursiveAlts;

			state.RuntimeState.Runtime.ParseTrace.No(this, lexer.CurrentSource(), "No alts matched");
            
			return ParseTree.No;
        }

        public override ParseTree Parse(Lexer lexer, ParserState state)
        {
            state.RuntimeState.Runtime.ParseTrace.Enter(this,
                lexer.CurrentSource(), "longest alt");

            int start = lexer.Position;
            
            ParseTree longestTree = null;
            int longestTreeEnd = -1;
            
			foreach (IParseable alt in alts)
			{
				ParseTree tree = alt.Parse(lexer, state);
				
				if (tree != ParseTree.No)
				{
					if (lexer.Position > longestTreeEnd)
					{
					    longestTree = tree;
					    longestTreeEnd = lexer.Position;
					}
				}
				
				lexer.Position = start;
			}
            
            if (longestTree == null)
            {
			    state.RuntimeState.Runtime.ParseTrace.No(this,
			        lexer.CurrentSource(), "No alts matched");
			    
			    return ParseTree.No;
			}
			
			lexer.Position = longestTreeEnd;
			
			state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start));
			return longestTree;
        }

        public override ParseTree Parse(Lexer lexer, ParserState state)
        {
            int start = lexer.Position;
            
            state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(), "Pattern " + Type.Name);
            
            /*state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(), "Excluded:");
            
            foreach (Pattern excluded in state.Excluded)
                state.RuntimeState.Runtime.ParseTrace.Single(excluded.Type.Name);
            
            state.RuntimeState.Runtime.ParseTrace.Leave(this);*/
            
            if (state.Excluded.Contains(this))
            {
                state.RuntimeState.Runtime.ParseTrace.No(this, lexer.CurrentSource(), "Excluded");
                return ParseTree.No;
            }
            
            ParserMemoryKey key = new ParserMemoryKey(this, start);
            
            bool oldSkipMemoryForLeftRecursion = state.SkipMemoryForLeftRecursion;
            
            if (state.SkipMemoryForLeftRecursion)
            {
                state.SkipMemoryForLeftRecursion = false;
            }
            else
            {
                ParserMemoryEntry entry;
                
                if (state.Memory.TryGetValue(key, out entry))
                {
                    state.RuntimeState.Runtime.ParseTrace.LinkNext(entry.Tag);

                    if (entry.Tree == ParseTree.No)
                    {
                        state.RuntimeState.Runtime.ParseTrace.No(this, lexer.SourceFrom(start), "From memory");
                    }
                    else
                    {
                        state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start), "From memory");
                        lexer.Position = entry.End;
                    }

                    return entry.Tree;
                }
            }
            
            ConcretePattern oldRecursionExclude = state.RecursionExclude;
            
            if (RecursionBehaviour != RecursionBehaviour.Recursive)
            {
                if (state.RecursionExclude != null)
                    state.Excluded.Remove(state.RecursionExclude);
                
                state.RecursionExclude = this;
                
                state.Excluded.Add(this);
            }
            
            RecursionBehaviour oldRecursionBehaviour = state.RecursionBehaviour;
            state.RecursionBehaviour = RecursionBehaviour;
            
            Precedence oldCurrentPrecedence = state.CurrentPrecedence;
            
            if (Precedence.Overwrites(state.CurrentPrecedence))
                state.CurrentPrecedence = Precedence;

            bool oldPrecedenceCanEqualCurrent = state.PrecedenceCanEqualCurrent;
            state.PrecedenceCanEqualCurrent = RecursionBehaviour == RecursionBehaviour.Recursive;
            
            ParseTree tree = ParseGraph.Parse(lexer, state);
            
            state.CurrentPrecedence = oldCurrentPrecedence;
            state.PrecedenceCanEqualCurrent = oldPrecedenceCanEqualCurrent;
            state.RecursionBehaviour = oldRecursionBehaviour;
            state.RecursionExclude = oldRecursionExclude;
            state.SkipMemoryForLeftRecursion = oldSkipMemoryForLeftRecursion;
            
            if (RecursionBehaviour != RecursionBehaviour.Recursive)
            {
                if (oldRecursionExclude != null)
                    state.Excluded.Add(oldRecursionExclude);
                
                state.Excluded.Remove(this);
            }
            
            if (tree != ParseTree.No)
            {
                lexer.Whitespace(state.RuntimeState);
                tree = Instantiate(lexer, state, start, tree);
            }
            
            object nextTag = new object();
        
            state.RuntimeState.Runtime.ParseTrace.TagNext(nextTag);
            
            if (tree == ParseTree.No)
            {
//.........这里部分代码省略.........

        public ParseTree LeftRecurse(Lexer lexer, ParserState state,
            int start, ParseTree leftHandSide)
        {
            state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.SourceFrom(start), "Left recursion");
            
            int finished = lexer.Position;
            
            state.LeftHandSide = leftHandSide;
            state.LeftHandSideEndPos = finished;
            state.SkipMemoryForLeftRecursion = true;
            
            lexer.Position = start;
            
            ParseGraphNode node;
            
            if (state.LeftRecursiveAlts != null)
                node = state.LeftRecursiveAlts;
            else
                node = recurseNode;
            
            ParseTree recursedTree = node.Parse(lexer, state);
            
            state.SkipMemoryForLeftRecursion = false;
            state.LeftHandSide = null;

            if (recursedTree == ParseTree.No)
            {
                state.RuntimeState.Runtime.ParseTrace.No(this, lexer.SourceFrom(start));
                lexer.Position = finished;
                
                return leftHandSide;
            }
            
            state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start));
            
            return recursedTree;
        }

        public ParseTree Instantiate(Lexer lexer, ParserState state,
            int start, ParseTree tree)
        {
            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);
        
            object[] parameterValues = new object[parameterTypes.Length];
        
            parameterValues[0] = lexer.SourceFrom(start);
    
            for (int n = 0; n < Fields.Count; n++)
            {
                object fieldValue = null;
                tree.Fields.TryGetValue(Fields[n], out fieldValue);
                    
                parameterValues[n + 1] = fieldValue;
            }
        
            RuntimeObject instance =
                (RuntimeObject) constructor.Invoke(parameterValues);
        
            object[] parsedParameters = {};
            
            object parsedMethod = MemberNode.GetMember(instance, "Parsed",
                parsedParameters, false);
            
            if (parsedMethod != null)
            {
                CallNode.Call(state.RuntimeState, parsedMethod,
                    parsedParameters);
            }
            
            return new ParseTree(instance);
        }

 public override ParseTree Parse(Lexer lexer, ParserState state)
 {
     int start = lexer.Position;
     
     state.RuntimeState.Runtime.ParseTrace.Enter(this, lexer.CurrentSource(), "options");
     
     bool oldBuildTextNodes = state.BuildTextNodes;
     Pattern oldWhitespace = lexer.WhitespacePattern;
     Precedence oldCurrentPrecedence = state.CurrentPrecedence;
     bool oldPrecedenceCanEqualCurrent = state.PrecedenceCanEqualCurrent;
     
     if (buildTextNodes.HasValue)
         state.BuildTextNodes = buildTextNodes.Value;
     
     if (whitespace.HasValue)
     {
         lexer.Whitespace(state.RuntimeState);
         lexer.WhitespacePattern = whitespace.Value;
     }
     
     if (exclude.HasValue)
         state.Excluded.Add(exclude.Value);
     
     if (dropPrecedence.HasValue && dropPrecedence.Value)
     {
         state.CurrentPrecedence = null;
         state.PrecedenceCanEqualCurrent = false;
     }
     
     ParseTree tree = body.Parse(lexer, state);
     
     state.BuildTextNodes = oldBuildTextNodes;
     lexer.WhitespacePattern = oldWhitespace;
 
     if (exclude.HasValue)
         state.Excluded.Remove(exclude.Value);
     
     state.CurrentPrecedence = oldCurrentPrecedence;
     state.PrecedenceCanEqualCurrent = oldPrecedenceCanEqualCurrent;
     
     if (tree == ParseTree.No)
     {
         state.RuntimeState.Runtime.ParseTrace.No(this, lexer.SourceFrom(start));
         return ParseTree.No;
     }
     
     state.RuntimeState.Runtime.ParseTrace.Yes(this, lexer.SourceFrom(start));
     
     return tree;
 }