private static Parser <Param> param()
{
return(from q in Parse.Char('$')
from first in Parse.Chars("123456789")
from rest in Parse.Optional(Parse.Number)
select new Param(first + rest.GetOrElse("")));
}
public void Parser_OfChars_UsingString_AcceptsAnyOfThoseChars()
{
var parser = Parse.Chars("abc").Once();
AssertParser.SucceedsWithOne(parser, "a", 'a');
AssertParser.SucceedsWithOne(parser, "b", 'b');
AssertParser.SucceedsWithOne(parser, "c", 'c');
}
private static Parser <IEnumerable <string> > IdentifierListParse() =>
(from identifier in Parse.CharExcept(new[]
{
',',
'\n'
}).AtLeastOnce().Text()
from separator in Parse.Chars(',').Optional()
select identifier.Trim()).Many();
static Parser <ESOperator> SimpleOperator(string op, string not, ESOSimpleType opType)
{
return
(from begin in
SimpleOperator(op, opType)
from end in
Parse.Chars(not).Not()
select begin);
}
internal static Parser <DslOrderBlock> OrderExprParse() =>
from orderTitle in Parse.String(DslKeywords.Order).Token()
from identifiers in
(from item in OrderExprItemParse().Token()
from delimiter in Parse.Chars(',').Optional()
select item).Many()
select new DslOrderBlock
{
Items = identifiers.ToArray()
};
public static Parser <T> LineToken <T>(this Parser <T> parser)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
return(from leading in Parse.Chars(' ', '\t').Many()
from item in parser
from trailing in Parse.Chars(' ', '\t').Many()
select item);
}
// creates dummy generic parser for expressions with matching braces allowing commas and semicolons by default
protected internal virtual Parser <string> GenericExpressionCore(string forbidden = null) =>
from subExpressions in
GenericNewExpression.Select(x => $" {x}")
.Or(Parse.CharExcept("'/(){}[]" + forbidden).Except(GenericNewExpression).Many().Text().Token())
.Or(Parse.Char('/').Then(_ => Parse.Not(Parse.Chars('/', '*'))).Once().Return("/"))
.Or(CommentParser.AnyComment.Return(string.Empty))
.Or(StringLiteral)
.Or(GenericExpressionInBraces('(', ')').Select(x => $"({x})"))
.Or(GenericExpressionInBraces('{', '}').Select(x => $"{{{x}}}"))
.Or(GenericExpressionInBraces('[', ']').Select(x => $"[{x}]"))
.Many()
let expr = string.Join(string.Empty, subExpressions)
where !string.IsNullOrWhiteSpace(expr)
select expr;
static SimpleTypeNameSerializer()
{
var typeCharParser = Parse.LetterOrDigit.Or(Parse.Chars("."));
var typeNameParser = typeCharParser.AtLeastOnce().Text();
var nameDelimiterParser = Parse.Char(':');
var genericDelimeterParser = Parse.Char(',');
var simpleTypeParser =
from typeName in typeNameParser
from nameDelimeter in nameDelimiterParser
from assemblyName in typeNameParser
select typeName + "," + assemblyName;
var emptyGenericTypeParser =
from typeName in typeNameParser
from genericMarker in Parse.Char('`')
from numberOfGenerics in Parse.Number
from nameDelimeter in nameDelimiterParser
from assemblyName in typeNameParser
select typeName + genericMarker + numberOfGenerics + "," + assemblyName;
typeParser = null;
var genericParameterParser =
from genericBegin in Parse.Char('[')
from nestedType in Parse.Ref(() => typeParser)
from genericEnd in Parse.Char(']')
from genericDelimeter in genericDelimeterParser.Optional()
select nestedType;
var genericParametersParser =
from genericMarker in Parse.Char('`')
from numberOfGenerics in Parse.Number
from genericBegin in Parse.Char('[')
from genericParameters in genericParameterParser.Repeat(int.Parse(numberOfGenerics))
from genericEnd in Parse.Char(']')
select Tuple.Create(numberOfGenerics, string.Join(",", genericParameters.Select(x => "[" + x + "]")));
var genericTypeParser =
from typeName in typeNameParser
from genericParameters in genericParametersParser
from nameDelimiter in nameDelimiterParser
from assemblyName in typeNameParser
select typeName + "`" + genericParameters.Item1 + "[" + genericParameters.Item2 + "]" + "," + assemblyName;
typeParser = simpleTypeParser.Or(genericTypeParser).Or(emptyGenericTypeParser);
}
private Parser <VariableDefinition> GetVariableDefinitionParser(Scope.Builder scopeBuilder, ErrorContext errorContext)
{
var variableDefinitionParser =
from mutableMarker in Parse.Char('$').Once().Optional()
from first in Parse.Letter.Once()
from rest in Parse.LetterOrDigit.Or(Parse.Chars('_', '-')).Many()
let name = new string(
mutableMarker.GetOrElse(Enumerable.Empty <char>())
.Concat(first)
.Concat(rest).ToArray())
select new VariableDefinition
{
Index = GetVariableIndex(name, scopeBuilder, errorContext),
Name = name,
Mutable = mutableMarker.IsDefined
};
return(variableDefinitionParser);
}
/// <summary>
/// コマンド用のパーサーを取得する
/// </summary>
/// <param name="cmdTxt">コマンドテキスト</param>
/// <returns>コマンド用パーサー</returns>
private static Parser <Command> GetCommandParser(string cmdTxt)
{
Parser <Command> cmdHas2ArgParser =
from cmd in Parse.Chars("rs".ToCharArray())
from d1 in DelimiterParser(cmdTxt)
from txt1 in TextParser(cmdTxt)
from d2 in DelimiterParser(cmdTxt)
from txt2 in TextParser(cmdTxt).XOr(Parse.Return("")).End()
select new Command(cmd, txt1, txt2);
Parser <Command> cmdHas1ArgParser =
from cmd in Parse.Chars("aic".ToCharArray())
from d1 in DelimiterParser(cmdTxt)
from txt in TextParser(cmdTxt).XOr(Parse.Return("")).End()
select new Command(cmd, txt);
Parser <Command> commandParser =
NoArgumentCommand.XOr(
cmdHas1ArgParser).XOr(
cmdHas2ArgParser);
return(commandParser);
}
// creates dummy generic parser for expressions with matching braces allowing commas and semicolons by default
protected internal virtual Parser <string> GenericExpressionCore(string forbidden = null, bool allowCurlyBraces = true)
{
var subExpressionParser = GenericNewExpression.Select(x => $" {x}")
.Or(Parse.CharExcept("'/(){}[]" + forbidden).Except(GenericNewExpression).Many().Text().Token())
.Or(Parse.Char('/').Then(_ => Parse.Not(Parse.Chars('/', '*'))).Once().Return("/"))
.Or(CommentParser.AnyComment.Return(string.Empty))
.Or(StringLiteral)
.Or(GenericExpressionInBraces('(', ')').Select(x => $"({x})"))
.Or(GenericExpressionInBraces('[', ']').Select(x => $"[{x}]"));
// optionally include support for curly braces
if (allowCurlyBraces)
{
subExpressionParser = subExpressionParser
.Or(GenericExpressionInBraces('{', '}').Select(x => $"{{{x}}}"));
}
return
(from subExpressions in subExpressionParser.Many()
let expr = string.Join(string.Empty, subExpressions)
where !string.IsNullOrWhiteSpace(expr)
select expr);
}
Parser <IEnumerable <IContentSegment> > BuildParser()
{
// This is easiest to read from the bottom (most generic) to the top (most specific).
Parser <string> double_quoted_text =
from open in Parse.Char('"')
from content in Parse.CharExcept('"').Many().Text()
from close in Parse.Char('"')
select content;
Parser <string> single_quoted_text =
from open in Parse.Char('\'')
from content in Parse.CharExcept('\'').Many().Text()
from close in Parse.Char('\'')
select content;
Parser <string> quoted_text =
double_quoted_text.Or(single_quoted_text);
Parser <string> token_attribute_value =
quoted_text;
Parser <string> token_attribute_key =
Parse.LetterOrDigit.Or(Parse.Chars('_', '-')).AtLeastOnce().Text().Token();
Parser <KeyValuePair <string, string> > token_attribute =
from key in token_attribute_key
from eq in Parse.Char('=').Token()
from value in token_attribute_value
select new KeyValuePair <string, string>(key, value);
Parser <string> token_open =
from tag in Parse.String("(!").Text()
from ws in Parse.WhiteSpace.Many()
select tag;
Parser <string> token_close =
from ws in Parse.WhiteSpace.Many()
from tag in Parse.String("!)").Text()
select tag;
Parser <Token> token =
from open in token_open
from name in Parse.LetterOrDigit.Or(Parse.Chars('_', '-')).AtLeastOnce().Text().Token().Named("token name")
from attributes in token_attribute.Many().Named("token attributes")
from close in token_close
select new Token(name, attributes);
Parser <KeyValuePair <string, string> > registered_script_attribute =
from name in Parse.AnyChar.Except(Parse.WhiteSpace.Or(Parse.Char('=')).Or(Parse.Char('>'))).AtLeastOnce().Text().Token().Named("token attribute name")
from eq in Parse.Char('=').Token()
from value in quoted_text.Or(Parse.AnyChar.Except(Parse.WhiteSpace).AtLeastOnce().Text()).Token().Named("token attribute value")
select new KeyValuePair <string, string>(name, value);
Parser <string> script_open =
Parse.String("<script").Text();
Parser <string> script_close =
Parse.String("</script>").Text();
Parser <Literal> script_content_literal =
from content in Parse.AnyChar.Except(token_open.Or(script_close)).AtLeastOnce().Text()
select new Literal(content);
Parser <IContentSegment> script_content =
((Parser <IContentSegment>)token)
.Or(script_content_literal);
Parser <IContentSegment> registered_script =
from tagOpen in script_open
from attributes in registered_script_attribute.Many()
from tagClose in Parse.Char('>')
from content in script_content.Many()
from scriptClose in script_close
let registered = attributes
.Where(kvp => StringComparer.OrdinalIgnoreCase.Equals(kvp.Key, "aspdnsf-registered"))
.Select(kvp => kvp.Value)
.LastOrDefault()
let bundle = attributes
.Where(kvp => StringComparer.OrdinalIgnoreCase.Equals(kvp.Key, "aspdnsf-registered-bundle"))
.Select(kvp => kvp.Value)
.LastOrDefault()
let name = attributes
.Where(kvp => StringComparer.OrdinalIgnoreCase.Equals(kvp.Key, "aspdnsf-registered-name"))
.Select(kvp => kvp.Value)
.LastOrDefault()
let dependencies = attributes
.Where(kvp => StringComparer.OrdinalIgnoreCase.Equals(kvp.Key, "aspdnsf-registered-dependencies"))
.Select(kvp => kvp.Value.Split(','))
.LastOrDefault()
let source = attributes
.Where(kvp => StringComparer.OrdinalIgnoreCase.Equals(kvp.Key, "src"))
.Select(kvp => kvp.Value)
.LastOrDefault()
let async = attributes
.Where(kvp => StringComparer.OrdinalIgnoreCase.Equals(kvp.Key, "async"))
.Select(kvp => StringComparer.OrdinalIgnoreCase.Equals(bool.TrueString, kvp.Value))
.LastOrDefault()
where StringComparer.OrdinalIgnoreCase.Equals(registered, bool.TrueString)
select string.IsNullOrWhiteSpace(source)
? (IContentSegment) new RegisteredInlineScript(name, new NestedContentSegment(content), dependencies)
: string.IsNullOrWhiteSpace(bundle)
? (IContentSegment) new RegisteredScriptReference(source, async, dependencies)
: (IContentSegment) new RegisteredBundledScript(bundle, source, dependencies);
Parser <NestedContentSegment> unregistered_script =
from tagOpen in script_open
from content in script_content.Many()
from tagClose in script_close
select new NestedContentSegment(new IContentSegment[] { new Literal(tagOpen) }.Concat(content).Concat(new IContentSegment[] { new Literal(tagClose) }));
Parser <Literal> literal =
from content in Parse.AnyChar.Except(token_open.Or(script_open)).AtLeastOnce().Text()
select new Literal(content);
Parser <IContentSegment> content_segment =
((Parser <IContentSegment>)token)
.Or(registered_script)
.Or(unregistered_script)
.Or(literal);
return(content_segment.Many());
}
public static Parser <IEnumerable <IProfileEntry> > GetProfile(int fileNumber, string fileName)
{
var nameChar = Parse.Char('\\')
.Then(_ => Parse.Chars("\\*.}"))
.Or(Parse.CharExcept("*.=}")
.Except(Parse.LineTerminator));
var textNameToken = nameChar
.AtLeastOnce()
.Text()
.Select(parsedName =>
(INameToken) new TextNameToken(parsedName));
var substituteNameToken = Parse.Char('*')
.Return((INameToken) new SubstituteNameToken())
.Named("name substitute");
var namePart = substituteNameToken
.Or(textNameToken)
.AtLeastOnce()
.Select(tokens => new NamePart(tokens))
.Named("name part");
var qualifiedName = namePart
.DelimitedBy(Parse.Char('.'))
.Select(parsedName => new QualifiedName(parsedName))
.Named("qualified name");
var textValueToken = Parse.CharExcept("*")
.Except(Parse.LineTerminator)
.Except(Parse.String("${"))
.AtLeastOnce()
.Text()
.Select(text =>
(IValueToken) new TextValueToken(text))
.Named("text value");
var referenceValueToken = Parse.String("${")
.Then(_ => qualifiedName)
.Then(parsedName => Parse.Char('}')
.Return((IValueToken) new ReferenceValueToken(parsedName)))
.Named("reference");
var substituteValueToken = Parse.Char('*')
.Return((IValueToken) new SubstituteValueToken())
.Named("* substitute value");
var value = referenceValueToken
.Or(substituteValueToken)
.Or(textValueToken)
.Many()
.Named("value");
var comment = Parse.Char('#').Token()
.Then(_ => Parse.AnyChar
.Except(Parse.LineTerminator)
.Many()
.Text()
.Select(parsedComment =>
(IProfileEntry) new Comment(parsedComment)))
.Named("comment");
var payload = from parsedName in qualifiedName
from parsedValue in Parse.Char('=').Then(_ => value)
select new { parsedName, parsedValue };
var payloadSpan = payload
.Named("payload")
.Span()
.Select(span =>
(IProfileEntry) new Payload(
span.Value.parsedName,
span.Value.parsedValue,
new SourceMark(fileNumber, fileName, span.Start.Line)));
return(comment
.Or(payloadSpan)
.DelimitedBy(Parse.LineTerminator.AtLeastOnce())
.Contained(
Parse.LineTerminator.Many(),
Parse.LineTerminator.Many())
.End());
}
public Identifier(params char[] allowed)
: base(Parse.Identifier(Parse.Letter, Parse.LetterOrDigit.XOr(Parse.Chars(allowed))))
{
}
private static Parser <char, KeyPath> PKeyPath(ISigningRepository?repo) =>
(from x in (Parse.Digit.Or(Parse.Chars("/\'h")).XMany()).Text()
.Then(s => Parse.TryConvert(s, KeyPath.Parse))
select x).InjectRepository(repo);
private static Parser <string> QuotedIdentifierParse() =>
from quote in Parse.Char('#')
from identifier in Parse.Letter.Or(Parse.Chars('_')).AtLeastOnce().Text()
from quoteEnd in Parse.Char('#')
select identifier;
private static Parser <IEnumerable <string> > QuotedIdentifierListParse() =>
(from identifier in QuotedIdentifierParse()
from separator in Parse.Chars(',', ' ', '\t').Optional()
select identifier).Many();
private static Parser <Operator> op()
{
return(from op in Parse.Chars("+-*/%").Token()
select Operator.fromSymbol(op));
}
public static Parser <string> CreatePhraseParser(char startPhraseDelimiter, char endPhraseDelimiter)
{
var StartPhraseDelimiter = Parse.Char(startPhraseDelimiter);
var EndPhraseDelimiter = Parse.Char(endPhraseDelimiter);
var PhraseDelimiters = StartPhraseDelimiter.Or(EndPhraseDelimiter);
return(Parse.XOr(
Parse.AnyChar.Except(PhraseDelimiters).AtLeastOnce().Contained(StartPhraseDelimiter, EndPhraseDelimiter).Named("phrase"),
Parse.AnyChar.Except(PhraseDelimiters).Except(Parse.WhiteSpace).Except(Parse.Chars("()")).AtLeastOnce().Named("word")
).Text());
}
