public ContainedExpression(params char[] delimiters) : base(Parse.CharExcept(delimiters)
.AtLeastOnce()
.Text()
.Token()
.Select(x => new GeneralExpression(x)))
{
}
static CommandParser()
{
var add = Parse.String("ADD").Text();
var rem = Parse.String("REM").Text();
var get = Parse.String("GET").Text();
var setSym = new[] { add, rem }
.Aggregate(Parse.Or);
var str =
(from open in Parse.Char('\'')
from content in Parse.CharExcept('\'').Many().Text()
from close in Parse.Char('\'')
select content).Token();
var setCmd =
(from symbol in setSym
from key in str
from value in str
select(IExpr) new SetExpr(
symbol: (Symbol)Enum.Parse(typeof(Symbol), symbol),
key: key,
value: value));
var query =
(from symbol in get
from key in str
select(IExpr) new QueryExpr(
symbol: (Symbol)Enum.Parse(typeof(Symbol), symbol),
key: key));
_expr = Parse.Or(setCmd, query);
}
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();
public EscapedLiteral(char containingCharacter)
: base(Parse.String("{}")
.Then(Parse.CharExcept(containingCharacter)
.Many()
.Text()
.Accept))
{
}
public static Parser <LiteralTokenExpression> LiteralTokenExpression()
{
return(from startQuote in Quote()
from content in Parse.CharExcept('"').Many().Text()
from endQuote in Quote()
select new LiteralTokenExpression {
Literal = content
});
}
private static Parser <StringLiteral> MakeString(char quote)
{
return((from str in Parse.CharExcept(quote).Many().Contained(Parse.Char(quote), Parse.Char(quote))
select new StringLiteral(new string(str.ToArray())))
.Or(from colon in Parse.Char(':')
from id in Parse.Ref(() => Symbol)
select new StringLiteral(":" + id.Value)
).PlasticToken());
}
public static Parser <Node <TContext, TRequest, TResponse> > GetParser(RoutableOptions <TContext, TRequest, TResponse> options, SimpleViewOptions <TContext, TRequest, TResponse> viewOptions)
{
var atSymbols = from at in Parse.Char('@').Many().Text()
select(Node <TContext, TRequest, TResponse>) new ContentNode <TContext, TRequest, TResponse>(options, viewOptions, at);
var contentSymbols = from before in Parse.CharExcept('@').Or(Parse.Char('\n')).Or(Parse.Char('\r')).Many().Text()
select(Node <TContext, TRequest, TResponse>) new ContentNode <TContext, TRequest, TResponse>(options, viewOptions, before);
return(atSymbols.Or(contentSymbols));
}
static Parser <ParticipantOrLine> CreateActorParser(string actorName)
{
return(from a in Parse.String(actorName).Text()
from w in Parse.WhiteSpace
from name in Parse.CharExcept(Environment.NewLine).Many().Text()
from e in NewLine
select new ParticipantOrLine {
Participant = new Participant {
Name = name, Type = a
}
});
}
private static IEnumerable <Project> ReadProjects(string slnFile)
{
// Setup parsers
Parser <Guid> guidParser =
from open in Parse.String("\"{")
from guid in Parse.LetterOrDigit.Or(e => Parse.Char('-').Invoke(e)).Many()
from close in Parse.String("}\"")
select Guid.Parse(string.Join("", guid));
Parser <string> nameParser =
from open in Parse.Char('\"')
from name in Parse.CharExcept('\"').Many()
from close in Parse.Char('\"')
select string.Join("", name);
Parser <Project> projectParser =
from beginProject in Parse.String("(")
from guid in guidParser.Token()
from endProject in Parse.String(")")
from whiteSpace in Parse.WhiteSpace.Many()
from equal in Parse.Char('=')
from whitespace2 in Parse.WhiteSpace.Many()
from name in nameParser.Token()
from whitespace3 in Parse.WhiteSpace.Many()
from comma1 in Parse.Char(',')
from whitespace4 in Parse.WhiteSpace.Many()
from projectFile in nameParser.Token()
from whitespace5 in Parse.WhiteSpace.Many()
from comma2 in Parse.Char(',')
from whitespace6 in Parse.WhiteSpace.Many()
from buildConfiguration in guidParser.Token()
from whitespace7 in Parse.WhiteSpace.Many()
select new Project(guid, name, projectFile, buildConfiguration);
var slnParser =
from whitespace1 in Parse.WhiteSpace.Or(Parse.AnyChar.Except(Parse.String("Project"))).Many()
from parsedProjects in Parse.Many(
// from ignored in Parse.Until((Parse.WhiteSpace.Or(Parse.AnyChar)).Many(), Parse.String("Project"))
from _1 in Parse.WhiteSpace.Many()
from beginProject in Parse.String("Project")
from project in projectParser.Token()
from endProject in Parse.String("EndProject")
from _2 in Parse.WhiteSpace.Many()
select project
)
from whitespace2 in (Parse.WhiteSpace.Or(Parse.AnyChar)).Many()
select parsedProjects;
return(slnParser.Parse(slnFile));
}
private Parser <Value> GetStringLiteralParser()
{
var stringParser =
from openQuote in Parse.Char('"')
from value in
(from q1 in Parse.Char('"') from q2 in Parse.Char('"') select '"')
.Or(Parse.CharExcept('"'))
.Many().Text()
from closeQuote in Parse.Char('"')
select AllocateExpression(Types.@string, GetStringLiteralRetreivalInstructions(value));
return(stringParser);
}
// 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;
public TextLiteral(CharacterParser containingCharacter, Parser <char> container) : base(
new EscapedLiteral(containingCharacter.Character).ToParser()
.XOr(
Parse.CharExcept(
$"{containingCharacter.Character}{Slash}")
.Or(EscapedCharacter)
.Many()
.Text()
).Contained(container, container)
.Token()
.Select(x => new LiteralExpression(x))
)
{
}
private static Parser <DataParameterExpr> DataParameterExprParse() =>
from next in Parse.String("conditions").Not()
// stops parsing conditions
from name in Parse.LetterOrDigit.Many().Text().Token()
from equation in Parse.Char('=')
from queryTitle in Parse.String("query").Token()
from query in Parse.CharExcept(';').Many().Text()
from finish in Parse.Char(';')
select new DataParameterExpr
{
Name = name,
Value = query
};
internal static Parser <DslFormatItem> SelectItemExprParse() =>
from endTitle in Parse.String(DslKeywords.SelectEnd).Not()
from name in (from name in Parse.LetterOrDigit.Many().Text().Token()
from equation in Parse.Char('=')
select name).Optional()
from value in Parse.CharExcept(new[] { DslKeywords.DisplayNameDelimiter, '\n' }).Many().Text().Token()
from displayName in (
from delimeter in Parse.Char(DslKeywords.DisplayNameDelimiter)
from displayName in Parse.CharExcept('\n').Many().Text().Token()
select displayName.Trim()).Optional()
select new DslFormatItem
{
Name = name.GetOrDefault(),
Value = value.Trim(),
DisplayName = displayName.GetOrDefault()
};
public Parser <string> CreateFormatFunctionParser()
{
//String.Format(" (SWH.KjWarehouseFlag = '{0}')", FLAG_ON)
var formatFunctionParser
= from _a in Parse.String("String.Format(").Text().Token()
from _b in Parse.Char('"').Token()
from first in _strParser.AtLeastOnce()
from replaced in Parse.String("{0}").Text()
from rest in _strParser.AtLeastOnce()
from _d in Parse.Char('"').Token()
from _e in Parse.Char(',').Token()
from arg in Parse.CharExcept(')').AtLeastOnce().Token()
from _f in Parse.Char(')').Token()
select MyFormat(first, replaced, rest, arg);
return(formatFunctionParser);
}
private static Parser <RoleExpr> RoleExprParse() =>
from token in Parse.String("role").Token()
from roleTitle in Parse.CharExcept(new[]
{
';',
'\n'
}).AtLeastOnce().Text().Token()
from excludes in (
from delimeter in Parse.Char(';')
from notToken in Parse.String("not").Token()
from persons in IdentifierListParse()
select persons).Optional()
select new RoleExpr
{
RoleName = roleTitle.Trim(),
ExcludedPersons = (excludes.GetOrDefault() ?? new string[0]).ToArray()
};
private static Parser <CharacterLiteral> CreateCharacterLiteralParser(bool ignoreCase)
{
var simpleCharacter =
Parse.CharExcept(c => SpecialCharacters.Any(escape => c == escape), "Special Characters")
.ToRegexNode(
(value, index, pattern) => Parse.Return(new CharacterLiteral(value, ignoreCase, index, pattern)));
var escapedSpecialCharacter =
(from backslash in Parse.Char('\\')
from escapedCharacter in
Parse.Char(c => SpecialCharacters.Any(escape => c == escape), "Special Characters")
select new string(new[] { backslash, escapedCharacter }))
.ToRegexNode(
(value, index, pattern) => Parse.Return(new CharacterLiteral(value, ignoreCase, index, pattern)));
return(escapedSpecialCharacter.Or(simpleCharacter));
}
public int Add(string numbers)
{
if (numbers == null)
{
throw new ArgumentNullException(nameof(numbers));
}
if (numbers == string.Empty)
{
return(0);
}
var newline = Parse.String("\n");
var multiCharDelimiter =
from delimiters in
(from delimiter in Parse.Contained(Parse.CharExcept(']').AtLeastOnce(), Parse.Char('['), Parse.Char(']'))
select string.Concat(delimiter)).AtLeastOnce()
select delimiters.Select(Parse.String).Aggregate(Parse.Or);
var customDelimiters =
from _ in Parse.String("//")
from mc in multiCharDelimiter.Or(
from c in Parse.AnyChar
select Parse.String(c.ToString()))
from __ in newline
select mc;
var numberParser =
(from minus in Parse.Char('-')
from num in Parse.Number
select minus + num).Or(Parse.Number);
var optionalDelimiterLineAndDelimitedNumbers =
from cd in customDelimiters.Optional()
from nums in numberParser.DelimitedBy(cd.GetOrElse(Parse.String(",")).Or(newline))
select nums.Select(int.Parse);
var parsedNumbers = optionalDelimiterLineAndDelimitedNumbers.Parse(numbers);
var negatives = parsedNumbers.Where(n => n < 0);
if (negatives.Any())
{
throw new ArgumentException("negatives not allowed: " + string.Join(", ", negatives));
}
return(parsedNumbers.Where(x => x <= 1000).Sum());
}
private static Parser <string> GetStringParser()
{
var escapedQuoteParser =
from backslash in Parse.Char('\\')
from quote in Parse.Char('"')
select quote;
var escapedBackslashParser =
from backslash in Parse.Char('\\')
from secondBackslash in Parse.Char('\\')
select backslash;
return
(from openQuote in Parse.Char('"')
from value in escapedBackslashParser.Or(escapedQuoteParser).Or(Parse.CharExcept('"')).Many().Text()
from closeQuote in Parse.Char('"')
select value);
}
public static IEnumerable <NetworkModel> ParseUserBlockList(string source)
{
var title = "Block list on the system (user)";
var token = Parse.CharExcept(new char[] { '"', ',' }).Except(Parse.LineEnd).AtLeastOnce();
var header = from head in Parse.AnyChar.Until(Parse.String(title)).Token()
from line in Parse.Char('-').AtLeastOnce()
from space in Parse.WhiteSpace.Once()
from end in Parse.LineEnd
select head;
var networkModel = from id_ssid in Parse.String("SSID:").Token()
from ssid in token.Contained(Parse.Char('"'), Parse.Char('"')).Token().Text()
from comma in Parse.Char(',')
from id_networktype in Parse.String("Type:").Token()
from networktype in token.Token().Text()
select new NetworkModel
{
Ssid = ssid, NetworkType = (NetworkType)Enum.Parse(typeof(NetworkType), networktype)
};
var parser = from head in header
from models in networkModel.Many()
select models;
try
{
var networkModels = parser.Parse(source);
return(networkModels);
}
catch (Exception)
{
throw;
}
}
// 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);
}
private static Parser <char, RootedKeyPath> PRootedKeyPath(ISigningRepository?repo) =>
(from _l in Parse.Char('[')
from x in (Parse.CharExcept(']').XMany().Text())
.Then(inner => Parse.TryConvert(inner, RootedKeyPath.Parse))
from _r in Parse.Char(']')
select x).InjectRepository(repo);
public static RocketPackDefinition ParseV1(string text)
{
var notWhiteSpace = Sprache.Parse.Char(x => !char.IsWhiteSpace(x), "not whitespace");
// 「"」で囲まれた文字列を抽出するパーサー
var stringLiteralParser =
from leading in Parse.WhiteSpace.Many()
from openQuote in Parse.Char('\"')
from fragments in Parse.Char('\\').Then(_ => Parse.AnyChar.Select(c => $"\\{c}")).Or(Parse.CharExcept("\\\"").Many().Text()).Many()
from closeQuote in Parse.Char('\"')
from trailing in Parse.WhiteSpace.Many()
select $"{string.Join(string.Empty, fragments)}";
// 英数字と'_'の文字列を抽出するパーサー
var nameParser =
from name in Parse.Char(x => ('0' <= x && x <= '9') || ('A' <= x && x <= 'Z') || ('a' <= x && x <= 'z') || x == '_', "Name").AtLeastOnce().Text()
select name;
// example: syntax = v1
var syntaxParser =
from keyword in Parse.String("syntax").TokenWithSkipComment()
from equal in Parse.Char('=').TokenWithSkipComment()
from type in Parse.String("v1").TokenWithSkipComment()
from semicolon in Parse.Char(';').Or(Parse.Return(';')).TokenWithSkipComment()
select type;
// example: option csharp_namespace = "RocketPack.Messages";
var optionParser =
from keyword in Parse.String("option").TokenWithSkipComment()
from name in nameParser.TokenWithSkipComment().Text()
from equal in Parse.Char('=').TokenWithSkipComment()
from value in stringLiteralParser.TokenWithSkipComment()
from semicolon in Parse.Char(';').Or(Parse.Return(';')).TokenWithSkipComment()
select new OptionDefinition(name, value);
// example: using "RocketPack.Messages";
var usingParser =
from keyword in Parse.String("using").TokenWithSkipComment()
from value in stringLiteralParser.TokenWithSkipComment()
from semicolon in Parse.Char(';').Or(Parse.Return(';')).TokenWithSkipComment()
select new UsingDefinition(value);
// example: [Recyclable]
var attributeParser =
from beginTag in Parse.Char('[').TokenWithSkipComment()
from name in Parse.CharExcept(']').AtLeastOnce().TokenWithSkipComment().Text()
from endTag in Parse.Char(']').TokenWithSkipComment()
select name;
var intTypeParser =
from isSigned in Parse.Char('u').Then(n => Parse.Return(false)).Or(Parse.Return(true))
from type in Parse.String("int")
from size in Parse.Decimal
from isOptional in Parse.Char('?').Then(n => Parse.Return(true)).Or(Parse.Return(false)).TokenWithSkipComment()
select new IntType(isSigned, int.Parse(size), isOptional);
var boolTypeParser =
from type in Parse.String("bool").TokenWithSkipComment()
from isOptional in Parse.Char('?').Then(n => Parse.Return(true)).Or(Parse.Return(false)).TokenWithSkipComment()
select new BoolType(isOptional);
var floatTypeParser =
from type in Parse.String("float").TokenWithSkipComment()
from size in Parse.Decimal.TokenWithSkipComment()
from isOptional in Parse.Char('?').Then(n => Parse.Return(true)).Or(Parse.Return(false)).TokenWithSkipComment()
select new FloatType(int.Parse(size), isOptional);
var stringTypeParser =
from type in Parse.String("string").TokenWithSkipComment()
from beginParam in Parse.String("(").TokenWithSkipComment()
from maxLength in Parse.Decimal.TokenWithSkipComment()
from endParam in Parse.String(")").TokenWithSkipComment()
from isOptional in Parse.Char('?').Then(n => Parse.Return(true)).Or(Parse.Return(false)).TokenWithSkipComment()
select new StringType(int.Parse(maxLength), isOptional);
var timestampTypeParser =
from type in Parse.String("timestamp")
from isOptional in Parse.Char('?').Then(n => Parse.Return(true)).Or(Parse.Return(false)).TokenWithSkipComment()
select new TimestampType(isOptional);
var memoryTypeParser =
from type in Parse.String("memory").TokenWithSkipComment()
from beginParam in Parse.String("(").TokenWithSkipComment()
from maxLength in Parse.Decimal.TokenWithSkipComment()
from endParam in Parse.String(")").TokenWithSkipComment()
from isOptional in Parse.Char('?').Then(n => Parse.Return(true)).Or(Parse.Return(false)).TokenWithSkipComment()
select new MemoryType(int.Parse(maxLength), isOptional);
var customTypeParser =
from type in nameParser.Text()
from isOptional in Parse.Char('?').Then(n => Parse.Return(true)).Or(Parse.Return(false)).TokenWithSkipComment()
select new CustomType(type, isOptional);
var vectorTypeParser =
from type in Parse.String("vector").TokenWithSkipComment()
from beginType in Parse.String("<").TokenWithSkipComment()
from elementType in boolTypeParser
.Or <TypeBase>(intTypeParser)
.Or(floatTypeParser)
.Or(stringTypeParser)
.Or(timestampTypeParser)
.Or(memoryTypeParser)
.Or(customTypeParser).TokenWithSkipComment()
from endType in Parse.String(">").TokenWithSkipComment()
from beginParam in Parse.String("(").TokenWithSkipComment()
from maxLength in Parse.Decimal.TokenWithSkipComment()
from endParam in Parse.String(")").TokenWithSkipComment()
from isOptional in Parse.Char('?').Then(n => Parse.Return(true)).Or(Parse.Return(false)).TokenWithSkipComment()
select new ListType(elementType, int.Parse(maxLength), isOptional);
var mapTypeParser =
from type in Parse.String("map").TokenWithSkipComment()
from beginType in Parse.String("<").TokenWithSkipComment()
from keyType in boolTypeParser
.Or <TypeBase>(intTypeParser)
.Or(floatTypeParser)
.Or(stringTypeParser)
.Or(timestampTypeParser)
.Or(memoryTypeParser)
.Or(customTypeParser).TokenWithSkipComment()
from comma_1 in Parse.Char(',').Or(Parse.Return(',')).TokenWithSkipComment()
from valueType in boolTypeParser
.Or <TypeBase>(intTypeParser)
.Or(floatTypeParser)
.Or(stringTypeParser)
.Or(timestampTypeParser)
.Or(memoryTypeParser)
.Or(customTypeParser).TokenWithSkipComment()
from endType in Parse.String(">").TokenWithSkipComment()
from beginParam in Parse.String("(").TokenWithSkipComment()
from maxLength in Parse.Decimal.TokenWithSkipComment()
from endParam in Parse.String(")").TokenWithSkipComment()
from isOptional in Parse.Char('?').Then(n => Parse.Return(true)).Or(Parse.Return(false)).TokenWithSkipComment()
select new MapType(keyType, valueType, int.Parse(maxLength), isOptional);
var enumElementParser =
from attributes in attributeParser.Many().TokenWithSkipComment()
from name in nameParser.TokenWithSkipComment().Text()
from equal in Parse.Char('=').TokenWithSkipComment()
from id in Parse.Decimal.TokenWithSkipComment()
from comma in Parse.Char(',').TokenWithSkipComment()
select new EnumElement(attributes.ToList(), name, int.Parse(id));
var enumParser =
from attributes in attributeParser.Many().TokenWithSkipComment()
from keyword in Parse.String("enum").TokenWithSkipComment()
from name in nameParser.TokenWithSkipComment().Text()
from colon in Parse.Char(':').TokenWithSkipComment()
from type in intTypeParser
from beginTag in Parse.Char('{').TokenWithSkipComment()
from enumProperties in enumElementParser.Except(Parse.Char('}')).Many().TokenWithSkipComment()
from endTag in Parse.Char('}').TokenWithSkipComment()
select new EnumDefinition(attributes.ToList(), name, type, enumProperties.ToList());
var smallMessageElementParser =
from attributes in attributeParser.Many().TokenWithSkipComment()
from name in nameParser.TokenWithSkipComment().Text()
from colon in Parse.Char(':').Or(Parse.Return(':')).TokenWithSkipComment()
from type in boolTypeParser
.Or <TypeBase>(intTypeParser)
.Or(floatTypeParser)
.Or(stringTypeParser)
.Or(timestampTypeParser)
.Or(memoryTypeParser)
.Or(vectorTypeParser)
.Or(mapTypeParser)
.Or(customTypeParser).TokenWithSkipComment()
from comma in Parse.Char(',').TokenWithSkipComment()
select new MessageElement(attributes.ToList(), name, type, null);
var smallMessageParser =
from attributes in attributeParser.Many().TokenWithSkipComment()
from formatType in Parse.String("small").Then(n => Parse.Return(MessageFormatType.Small)).TokenWithSkipComment()
from keyword in Parse.String("message").TokenWithSkipComment()
from name in nameParser.TokenWithSkipComment().Text()
from beginTag in Parse.Char('{').TokenWithSkipComment()
from elements in smallMessageElementParser.Except(Parse.Char('}')).Many().TokenWithSkipComment()
from endTag in Parse.Char('}').TokenWithSkipComment()
select new MessageDefinition(attributes.ToList(), formatType, name, elements.ToList());
var mediumMessageElementParser =
from attributes in attributeParser.Many().TokenWithSkipComment()
from name in nameParser.TokenWithSkipComment().Text()
from colon in Parse.Char(':').Or(Parse.Return(':')).TokenWithSkipComment()
from type in boolTypeParser
.Or <TypeBase>(intTypeParser)
.Or(floatTypeParser)
.Or(stringTypeParser)
.Or(timestampTypeParser)
.Or(memoryTypeParser)
.Or(vectorTypeParser)
.Or(mapTypeParser)
.Or(customTypeParser).TokenWithSkipComment()
from equal in Parse.Char('=').Or(Parse.Return('=')).TokenWithSkipComment()
from id in Parse.Decimal.TokenWithSkipComment()
from comma in Parse.Char(',').TokenWithSkipComment()
select new MessageElement(attributes.ToList(), name, type, int.Parse(id));
var mediumMessageParser =
from attributes in attributeParser.Many().TokenWithSkipComment()
from formatType in Parse.String("medium").Then(n => Parse.Return(MessageFormatType.Medium)).Or(Parse.Return(MessageFormatType.Medium))
from keyword in Parse.String("message").TokenWithSkipComment()
from name in nameParser.TokenWithSkipComment().Text()
from beginTag in Parse.Char('{').TokenWithSkipComment()
from elements in mediumMessageElementParser.Except(Parse.Char('}')).Many().TokenWithSkipComment()
from endTag in Parse.Char('}').TokenWithSkipComment()
select new MessageDefinition(attributes.ToList(), formatType, name, elements.ToList());
var formatParser =
from syntax in syntaxParser.AtLeastOnce().TokenWithSkipComment()
from headers in usingParser.Or <object>(optionParser).TokenWithSkipComment().Many()
from contents in enumParser.Or <object>(smallMessageParser).Or(mediumMessageParser).TokenWithSkipComment().Many()
select new RocketPackDefinition(
headers.OfType <UsingDefinition>().ToList(),
headers.OfType <OptionDefinition>().ToList(),
contents.OfType <EnumDefinition>().ToList(),
contents.OfType <MessageDefinition>().ToList()
);
var result = formatParser.Parse(text);
// Medium形式のメッセージのMemoryタイプの属性に[Recyclable]が設定されている場合は、IsUseMemoryPoolフラグを立てる。
foreach (var messageInfo in result.Messages.Where(n => n.FormatType == MessageFormatType.Medium))
{
foreach (var elementInfo in messageInfo.Elements)
{
if (elementInfo.Type is MemoryType memoryTypeInfo && elementInfo.Attributes.Contains("Recyclable"))
{
memoryTypeInfo.IsUseMemoryPool = true;
}
}
}
return(result);
}
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());
}
/// <summary>
/// コマンド文字列からテキスト（デリミタ以外の文字）のパーサーを取得する。
/// </summary>
/// <param name="cs">コマンド文字列</param>
/// <returns>テキストのパーサー</returns>
static Parser <string> TextParser(string cs)
{
return(Parse.CharExcept(cs[1]).AtLeastOnce().Text());
}
private static Parser <CharacterClass> CreateCharacterClassParser(bool ignoreCase)
{
var characterClassAlwaysLegalCharacter = Parse.CharExcept(c => c == ']' || c == '-' || c == '\\',
"Right Bracket or Backslash or Dash");
var characterClassEscapedCharacters =
from backslash in Parse.Char('\\')
from escapedCharacter in Parse.Char(']').Or(Parse.Char('^')).Or(Parse.Char('-')).Or(Parse.Char('\\'))
select new[] { backslash, escapedCharacter };
var characterClassCharacter =
characterClassAlwaysLegalCharacter.Once().Text().Or(characterClassEscapedCharacters.Text());
// FYI: this is an example of non-consuming look-ahead
var safeCharacterClassCharacter =
from character in
characterClassCharacter.Except(
from x in characterClassCharacter
from y in Parse.Char('-')
from z in Parse.CharExcept(']')
select x)
select character;
var characterClassLiteralCharacters =
from characters in safeCharacterClassCharacter.AtLeastOnce()
select new CharacterClassLiteralCharacters(characters.Aggregate("", (s, c) => s + c), ignoreCase);
var characterClassRange =
from min in characterClassEscapedCharacters.Or(characterClassAlwaysLegalCharacter.Once()).Text()
from dash in Parse.Char('-')
from max in characterClassEscapedCharacters.Or(characterClassAlwaysLegalCharacter.Once()).Text()
select new CharacterClassRange(min, max, ignoreCase);
var optionalDash =
Parse.Char('-').Once().Text().Select(x => new CharacterClassLiteralCharacters(x, ignoreCase)).XOr(
Parse.Return((CharacterClassLiteralCharacters)null));
return
((from openBracket in
Parse.Char('[')
.Except( // Look ahead to make sure we don't have an empty character class or negated character class
from x in Parse.Char('[')
from y in Parse.Char('^').XOr(Parse.Return('_'))
// (this matches caret if its there, but doesn't fail the match if it isn't)
from z in Parse.Char(']')
select x)
from negate in Parse.Char('^').Once().Text().XOr(Parse.Return((string)null))
from beginningDash in optionalDash
from internals in
characterClassRange.Select(x => (ICharacterClassPart)x).Or(characterClassLiteralCharacters).Many()
from endDash in optionalDash
from closeBracket in Parse.Char(']')
select new
{
Internals = GetInternals(beginningDash, internals, endDash),
Negated = negate == "^"
})
.ToRegexNode(
(value, index, pattern) =>
Parse.Return(new CharacterClass(value.Internals, value.Negated, ignoreCase, index, pattern))));
}
// ReSharper restore PrivateFieldCanBeConvertedToLocalVariable
// ReSharper restore InconsistentNaming
#endregion
public ExpressionParser(ScriptEngine engine)
{
_engine = engine;
Identifier =
from name in Variable
select new AliasEvaluator(_engine, name);
Ret =
from name in Parse.String("ret").Text()
select new AliasEvaluator(_engine, name);
NamedParameter =
from name in Token
from leading in Space.Optional()
from op in Parse.Char('=')
from trailing in Space.Optional()
from value in Function.Or(Number).Or(QuotedString).Or(Ret).Or(Identifier).Or(Constant)
select new NamedParameterEvaluator(name, value);
Function =
from lparen in Parse.Char('[')
from _ in Space.Optional()
from name in Token
from space in Space.Optional()
from expr in Parse.Ref(() => NamedParameter.Or(Label).Or(Function).Or(Number).Or(QuotedString).Or(Ret).Or(Identifier).Or(Constant)).DelimitedBy(Space).Optional()
from trailing in Space.Optional()
from rparen in Parse.Char(']')
select new FunctionEvaluator(_engine, name, expr.GetOrDefault()?.ToArray() ?? Array.Empty <IEvaluator>());
Alias =
from value in Function.Or(Number).Or(QuotedString).Or(Ret).Or(Identifier).Or(Constant)
from leading in Space.Optional()
from op in Parse.Char(':')
from trailing in Space.Optional()
from name in Variable
select new AliasEvaluator(_engine, name, value);
Text =
from op in Parse.Char('-').Or(Parse.Char('+'))
from space in Space.Optional()
from text in Parse.CharExcept('\n').AtLeastOnce().Text().Optional()
select new TextEvaluator(_engine, text.GetOrDefault(), op);
Macro =
from op in Parse.Char('!')
from _ in Space.Optional()
from name in Token
from space in Space.Optional()
from parameters in MacroParameters.Optional()
from eol in Parse.LineEnd
from str in Parse.CharExcept('!').AtLeastOnce().Text()
from ending in Parse.Char('!')
select new MacroEvaluator(_engine, name, parameters.GetOrDefault()?.ToArray(), str);
Import =
from op in Parse.Char('%')
from space in Space.Optional()
from file in Parse.AnyChar.Except(Parse.LineTerminator).Many().Text()
select new ScriptEvaluator(_engine, File.ReadAllText(Path.Combine(_path, file)));
Evaluator = Import.Or(Macro).Or(Label).Or(Text).Or(Alias).Or(Function);
}
public static Parser <string> makeStringContentParser(char delimiter)
{
return(Parse.CharExcept(delimiter + "\\").Many().Text().XOr(Escape)
.Many().Select(ss => ss.Aggregate(string.Empty, (a, b) => a + b))
.Contained(Parse.Char(delimiter), Parse.Char(delimiter)));
}
public static string Evaluate(string[] instructions)
{
Parser <string> tokenItem =
from t in Parse.CharExcept(' ').Many().Text()
from trailing in Parse.WhiteSpace.Many()
select t;
Parser <string> word =
from t in Parse.CharExcept(' ').Many().Text()
select t;
Parser <IEnumerable <string> > instruction = tokenItem.XMany().End();
Stack <string> instructionStack = null;
Stack <int> processedStack = null;
string retVal = "";
Dictionary <string, List <string> > redefCommands = new Dictionary <string, List <string> >();
for (int i = 0; i < instructions.Length; i++)
{
if (instructions[i].Contains(':')) // process variable line
{
string[] commandList = instruction.Parse(instructions[i]).ToArray();
ParseDefinitions(ref redefCommands, commandList);
continue;
}
instructionStack = new Stack <string>();
processedStack = new Stack <int>();
string[] line = instruction.Parse(instructions[i]).ToArray();
foreach (var token in line.Reverse())
{
instructionStack.Push(token);
}
while (instructionStack.Where(s => !IsInt(s)).Count() > 0)
{
if (IsInt(instructionStack.Peek()))
{
processedStack.Push(int.Parse(instructionStack.Pop()));
}
else // operator
{
string tmpInst = instructionStack.Pop().ToUpper();
if (redefCommands.Keys.Contains(tmpInst))
{
foreach (var v in redefCommands[tmpInst])
{
instructionStack.Push(v);
}
}
else
{
ProcessInstruction(ref processedStack, tmpInst);
}
}
}
}
if (instructionStack.Where(s => !IsInt(s)).Count() == 0) // no instructions - just print
{
for (int i = 0; i < instructionStack.Count(); i++)
{
processedStack.Push(int.Parse(instructionStack.ElementAt(i)));
}
}
for (int i = processedStack.Count() - 1; i >= 0; i--)
{
retVal += $"{processedStack.ElementAt(i)}";
retVal += i > 0 ? " " : "";
}
return(retVal);
}
