Beispiel #1
0
 private static ParseResult Match_Eol(InputStream input)
 {
     return(ParseBuilder.FirstOf(
                ParseBuilder.Match("\r\n"),
                ParseBuilder.Match('\r'),
                ParseBuilder.Match('\n'))(input));
 }
Beispiel #2
0
        private static ParseResult Match_PublicKeyValue(InputStream input)
        {
            var seq = Enumerable.Repeat <Func <InputStream, ParseResult> >(Match_HexDigit, 16)
                      .Concat(new Func <InputStream, ParseResult>[] { Match_Spacing });

            return(ParseBuilder.Sequence(seq.ToArray())(input));
        }
Beispiel #3
0
 private static ParseResult Match_Space(InputStream input)
 {
     return(ParseBuilder.FirstOf(
                ParseBuilder.Match(' '),
                ParseBuilder.Match('\t'),
                Match_Eol)(input));
 }
Beispiel #4
0
        private static ParseResult Match_LangTagPart(InputStream input)
        {
            var isAlpha  = ParseBuilder.Match(ch => "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".Contains(ch));
            var optAlpha = ParseBuilder.ZeroOrOne(isAlpha);

            return(ParseBuilder.Sequence(isAlpha, optAlpha, optAlpha, optAlpha, optAlpha, optAlpha, optAlpha, optAlpha,
                                         optAlpha, optAlpha, optAlpha, optAlpha, optAlpha, optAlpha, optAlpha, optAlpha)(input));
        }
Beispiel #5
0
 private static ParseResult Match_QuotedChar(InputStream input)
 {
     return(ParseBuilder.WithAction(
                ParseBuilder.Sequence(Match_Backslash, ParseBuilder.Any),
                result =>
     {
         string ch = new SequenceResult(result)[1].MatchedString;
         return new ParseResult(ch);
     })(input));
 }
Beispiel #6
0
 private static ParseResult Match_GenericTypeParameter(InputStream input)
 {
     return(ParseBuilder.FirstOf(
                ParseBuilder.WithAction(Match_UnqualifiedName, r =>
     {
         var result = new TypeNameInfo();
         InitializeTypeNameInfo((ParsedUnqualifiedName)r.ResultData, result);
         return new ParseResult(r.MatchedString, result);
     }),
                ParseBuilder.WithAction(
                    ParseBuilder.Sequence(Match_LeftBracket, Match_TypeName, Match_RightBracket),
                    r => new SequenceResult(r)[1]))(
                input));
 }
Beispiel #7
0
        private static ParseResult Match_CLRSyntax(InputStream input)
        {
            var         resultData = new GenericParameters();
            ParseResult result     = ParseBuilder.Sequence(Match_Backquote,
                                                           WithAction(OneOrMore(Match_Digit),
                                                                      r =>
            {
                resultData.IsOpenGeneric = true;
                int numParameters        = int.Parse(r.MatchedString, CultureInfo.InvariantCulture);
                for (int i = 0; i < numParameters; ++i)
                {
                    resultData.Parameters.Add(null);
                }
            }))(input);

            if (result.Matched)
            {
                return(new ParseResult(result.MatchedString, resultData));
            }
            return(result);
        }
Beispiel #8
0
 private static ParseResult Match_Int(InputStream input)
 {
     return(ParseBuilder.WithAction(ParseBuilder.Sequence(Match_Digit, ParseBuilder.ZeroOrMore(Match_Digit)),
                                    r => new ParseResult(r.MatchedString, int.Parse(r.MatchedString, CultureInfo.InvariantCulture)))(input));
 }
Beispiel #9
0
 private static ParseResult Match_RightBracket(InputStream input)
 {
     return(ParseBuilder.Sequence(ParseBuilder.Match(']'), Match_Spacing)(input));
 }
Beispiel #10
0
 private static ParseResult Match_Digit(InputStream input)
 {
     return(ParseBuilder.Match(ch => char.IsDigit(ch))(input));
 }
Beispiel #11
0
 private static ParseResult Match_HexDigit(InputStream input)
 {
     return(ParseBuilder.Match(ch => "0123456789ABCDEFabcdef".Contains(ch))(input));
 }
Beispiel #12
0
 private static ParseResult Match_Spacing(InputStream input)
 {
     return(ParseBuilder.ZeroOrOne(Match_Space)(input));
 }
Beispiel #13
0
 private static ParseResult Match_PublicKeyToken(InputStream input)
 {
     return(ParseBuilder.Sequence(ParseBuilder.Match("PublicKeyToken"), Match_Spacing, Match_Equals, Match_PublicKeyValue)(input));
 }
Beispiel #14
0
 private static ParseResult Match_Version(InputStream input)
 {
     return(ParseBuilder.Sequence(ParseBuilder.Match("Version"), Match_Spacing, Match_Equals, Match_VersionNumber, Match_Spacing)(input));
 }
Beispiel #15
0
 private static ParseResult Match_Backslash(InputStream input)
 {
     return(ParseBuilder.Match('\\')(input));
 }
Beispiel #16
0
 private static ParseResult Match_Id(InputStream input)
 {
     return(ParseBuilder.Sequence(Match_IdStart, ParseBuilder.ZeroOrMore(Match_IdContinuation))(input));
 }
Beispiel #17
0
 private static ParseResult Match_IdStart(InputStream input)
 {
     return(ParseBuilder.FirstOf(Match_IdNonAlpha, Match_IdAlpha)(input));
 }
Beispiel #18
0
 private static ParseResult Match_AssemblyNameChar(InputStream input)
 {
     return(ParseBuilder.FirstOf(Match_QuotedChar, ParseBuilder.Match(ch => !"^/\\:?\"<>|,[]".Contains(ch)))(input));
 }
Beispiel #19
0
 private static ParseResult Match_AssemblyNameStart(InputStream input)
 {
     return(ParseBuilder.Sequence(ParseBuilder.Not(Match_Dot), Match_AssemblyNameChar)(input));
 }
Beispiel #20
0
 private static ParseResult Match_VersionNumber(InputStream input)
 {
     return
         (ParseBuilder.Sequence(Match_Int, Match_Dot, Match_Int, Match_Dot, Match_Int, Match_Dot, Match_Int)(input));
 }
Beispiel #21
0
 private static ParseResult Match_Backquote(InputStream input)
 {
     return(ParseBuilder.Match('`')(input));
 }
Beispiel #22
0
 private static ParseResult Match_LanguageTag(InputStream input)
 {
     return(ParseBuilder.Sequence(Match_LangTagPart, ParseBuilder.ZeroOrOne(ParseBuilder.Sequence(ParseBuilder.Match('-'), Match_LangTagPart)), Match_Spacing)(input));
 }
Beispiel #23
0
 private static ParseResult Match_Plus(InputStream input)
 {
     return(ParseBuilder.Match('+')(input));
 }
Beispiel #24
0
 private static ParseResult Match_Culture(InputStream input)
 {
     return(ParseBuilder.Sequence(ParseBuilder.Match("Culture"), Match_Spacing, Match_Equals, Match_LanguageTag)(input));
 }
Beispiel #25
0
 private static ParseResult Match_Equals(InputStream input)
 {
     return(ParseBuilder.Sequence(ParseBuilder.Match('='), Match_Spacing)(input));
 }
Beispiel #26
0
 private static ParseResult Match_IdNonAlpha(InputStream input)
 {
     return(ParseBuilder.Match(ch => "_$@?".Contains(ch))(input));
 }
Beispiel #27
0
 private static ParseResult Match_IdContinuation(InputStream input)
 {
     return(ParseBuilder.FirstOf(Match_IdNonAlpha, Match_IdAlphanumeric)(input));
 }
Beispiel #28
0
 private static ParseResult Match_PublicKey(InputStream input)
 {
     return
         (ParseBuilder.Sequence(ParseBuilder.Match("PublicKey"), Match_Spacing, Match_Equals, ParseBuilder.OneOrMore(Match_HexDigit), Match_Spacing)(
              input));
 }
Beispiel #29
0
 private static ParseResult Match_AssemblyName(InputStream input)
 {
     return(ParseBuilder.Sequence(Match_SimpleName, ParseBuilder.ZeroOrMore(ParseBuilder.Sequence(Match_Comma, Match_AssemblyNamePart)))(input));
 }
Beispiel #30
0
 private static ParseResult Match_IdAlphanumeric(InputStream input)
 {
     return(ParseBuilder.FirstOf(Match_QuotedChar, ParseBuilder.Match(ch => char.IsLetterOrDigit(ch)))(input));
 }