C# ISourceStream.MatchSymbol方法代码示例

    public override TokenAst TryMatch(CompilerContext context, ISourceStream source)
    {
      if (!source.MatchSymbol(_startSymbol, false)) return null;
      source.Position += _startSymbol.Length;

      while (!source.EOF())
      {
        int firstCharPos = source.Text.IndexOf(_endSymbol, source.Position);

        if (firstCharPos < 0)
        {
          source.Position = source.Text.Length;

          if (_isLineComment)
            return TokenAst.Create(this, context, source.TokenStart, source.GetLexeme());
          else
            return Grammar.CreateSyntaxErrorToken(context, source.TokenStart, "Unclosed comment block");
        }
      
        source.Position = firstCharPos;
        if (source.MatchSymbol(_endSymbol, false))
        {
          source.Position += _endSymbol.Length;
          return TokenAst.Create(this, context, source.TokenStart, source.GetLexeme());
        }
        
        source.Position++; 
      }

      throw new NotSupportedException();
    }

        public override Token TryMatch(CompilerContext context, ISourceStream source)
        {
            bool ignoreCase = !Grammar.CaseSensitive;
              //Check starting symbol
              if (!source.MatchSymbol(StartSymbol, ignoreCase)) return null;
              //Find end symbol
              source.Position += StartSymbol.Length;

              while(!source.EOF()) {
            int firstCharPos;
            if (EndSymbols.Count == 1)
              firstCharPos = source.Text.IndexOf(EndSymbols[0], source.Position);
            else
              firstCharPos = source.Text.IndexOfAny(_endSymbolsFirsts, source.Position);
            if (firstCharPos < 0) {
              source.Position = source.Text.Length;
              if (_isLineComment) //if it is LineComment, it is ok to hit EOF without final line-break; just return all until end.
            return Token.Create(this, context, source.TokenStart, source.GetLexeme());
              else
            return Grammar.CreateSyntaxErrorToken(context, source.TokenStart, "Unclosed comment block");
            }
            //We found a character that might start an end symbol; let's see if it is true.
            source.Position = firstCharPos;
            foreach (string endSymbol in EndSymbols)
              if (source.MatchSymbol(endSymbol, ignoreCase)) {
            //We found end symbol
            source.Position += endSymbol.Length;
            return Token.Create(this, context, source.TokenStart, source.GetLexeme());
              }//if
            source.Position++; //move to the next char and try again
              }//while
              return null; //never happens
        }

 private bool BeginMatch(ParsingContext context, ISourceStream source)
 {
     //Check starting symbol
     if (!source.MatchSymbol(StartSymbol)) return false;
     source.PreviewPosition += StartSymbol.Length;
     return true;
 }

 protected override string ReadBody(ParsingContext context, ISourceStream source) {
   if (!source.MatchSymbol(StartSymbol)) return null; //this will result in null returned from TryMatch, no token
   var start = source.Location.Position + StartSymbol.Length;
   var end = source.Text.IndexOf(EndSymbol, start);
   if (end < 0) return null;
   var body = source.Text.Substring(start, end - start);
   source.PreviewPosition = end + EndSymbol.Length; //move beyond the end of EndSymbol
   return body; 
 }

 private bool TryMatchPrefixes(ParsingContext context, ISourceStream source) {
   if (Firsts.Count == 0) 
     return true;  
   foreach (var first in Firsts)
     if (source.MatchSymbol(first)) {
       source.PreviewPosition += first.Length;
       return true;
     }
   return false; 
 }

 private bool CheckEscape(ISourceStream source, ref string tokenText) {
   foreach (var dictEntry in Escapes) {
     if (source.MatchSymbol(dictEntry.Key, !Grammar.CaseSensitive)) {
       source.PreviewPosition += dictEntry.Key.Length;
       tokenText += dictEntry.Value;
       return true; 
     }
   }//foreach
   return false; 
 }

    public override TokenAst TryMatch(CompilerContext context, ISourceStream source)
    {
      if (!source.MatchSymbol(Symbol, false))
        return null;
    
      source.Position += Symbol.Length;
      TokenAst tokenAst = TokenAst.Create(this, context, source.TokenStart, Symbol);

      return tokenAst;
    }

 private bool BeginMatch(ISourceStream source, int startFrom, char lookAhead) {
   foreach (var startSymbol in StartSymbols.Skip(startFrom)) {
     if (startSymbol[0] != lookAhead)
       continue;
     if (source.MatchSymbol(startSymbol, !Grammar.CaseSensitive)) {
       source.PreviewPosition += startSymbol.Length;
       return true;
     }
   }
   return false;
 }

        private bool BeginMatch(ParsingContext context, ISourceStream source, ref byte level)
        {
            if (!source.MatchSymbol(StartSymbol)) 
                return false;

            string text = source.Text.Substring(source.PreviewPosition + StartSymbol.Length);
            var match = Regex.Match(text, @"^(=*)\[");
            if(match.Value != string.Empty)
            {
                level = (byte)match.Groups[1].Value.Length;
                return true;
            }
           
            return false; 
        }

 public override Token TryMatch(ParsingContext context, ISourceStream source) {
   if (!source.MatchSymbol(OpenTag, true)) return null;
   source.PreviewPosition += OpenTag.Length;
   var endPos = source.Text.IndexOf(CloseTag, source.PreviewPosition);
   string content; 
   if(endPos > 0) {
     content = source.Text.Substring(source.PreviewPosition, endPos - source.PreviewPosition); 
     source.PreviewPosition = endPos + CloseTag.Length;
   } else {
     content = source.Text.Substring(source.PreviewPosition, source.Text.Length - source.PreviewPosition); 
     source.PreviewPosition = source.Text.Length;
   }
   var token = source.CreateToken(this.OutputTerminal, content); 
   return token;      
 }

 public override Token TryMatch(ParsingContext context, ISourceStream source) {
   bool isHeadingOrList = TermType == WikiTermType.Heading || TermType == WikiTermType.List;
   if(isHeadingOrList) {
       bool isAfterNewLine = (context.PreviousToken == null || context.PreviousToken.Terminal == Grammar.NewLine);
       if(!isAfterNewLine)  return null;
   }
   if(!source.MatchSymbol(OpenTag)) return null;
   source.PreviewPosition += OpenTag.Length;
   //For headings and lists require space after
   if(TermType == WikiTermType.Heading || TermType == WikiTermType.List) {
     const string whitespaces = " \t\r\n\v";
     if (!whitespaces.Contains(source.PreviewChar)) return null; 
   }
   var token = source.CreateToken(this.OutputTerminal);
   return token; 
 }

        private bool BeginMatch(ParsingContext context, ISourceStream source, ref byte level)
        {
            //Check starting symbol
            if (!source.MatchSymbol(StartSymbol, !Grammar.CaseSensitive))
                return false;

            //Found starting --, now determine whether this is a long comment.
            string text = source.Text.Substring(source.PreviewPosition + StartSymbol.Length);
            var match = Regex.Match(text, @"^(=*)\[");
            if(match.Value != string.Empty)
            {
                level = (byte)match.Groups[1].Value.Length;
                return true;
            }

            return false;
        }

 Token Match_compile_end_tag(Terminal terminal, ParsingContext context, ISourceStream source) {
   if (source.MatchSymbol("__End")) {
     var p = source.Location.Position; 
     var lineEnd = source.Text.IndexOf("\n", p); 
     var text = source.Text.Substring(p, lineEnd - p + 1);
     return new Token(_comment, source.Location, text, text);
   }
   //otherwise return null
   return null; 
 }

 private bool ReadStartSymbol(ISourceStream source, ScanDetails details)
 {
     if (_startEndFirsts.IndexOf(source.CurrentChar) < 0)
     return false;
       bool ignoreCase = IsSet(TermOptions.SpecialIgnoreCase);
       foreach (string startEnd in _startEndSymbols) {
     if (!source.MatchSymbol(startEnd, ignoreCase))
       continue;
     //We found start symbol
     details.ControlSymbol = startEnd;
     details.Flags |= StartEndSymbolTable[startEnd];
     source.Position += startEnd.Length;
     return true;
       }//foreach
       return false;
 }

 private bool CheckTerminators(ISourceStream source, ref string tokenText) {
   foreach(var term in Terminators)
     if(source.MatchSymbol(term, !Grammar.CaseSensitive)) {
       if (IsSet(FreeTextOptions.IncludeTerminator))
         tokenText += term; 
       if (IsSet(FreeTextOptions.ConsumeTerminator | FreeTextOptions.IncludeTerminator))
         source.PreviewPosition += term.Length;
       return true;
     }
   return false; 
 }