public virtual Parser <ISyntaxNode> RegPtrReg(string mnemonic)
{
return(from mnem in UpperOrLowerStr(mnemonic)
from ws in Parse.WhiteSpace
from args in DoubleArg(Parse.Char('&').Then((arg) => Register), Register)
select new InstructionNode(mnem, mnemonic + "_reg_ptr_reg", args));
}
public string ParamsProcess(string input, fmQueryExtract form)
{
//Dim pramItemID As New SqlParameter("@ItemID", SqlDbType.VarChar, 30)
Parser <string> dimSqlParameterParser
= from dim in Parse.String("Dim").Text().Token()
from _a in Parse.LetterOrDigit.Many().Token()
from _b in Parse.String("As New SqlParameter(\"").Text().Token()
from at in Parse.Char('@')
from param in Parse.LetterOrDigit.AtLeastOnce().Text().Token()
from _c in Parse.Char('"')
from _d in Parse.AnyChar.Many()
select at + param;
foreach (var line in input.Split(Environment.NewLine.ToArray()))
{
if (line != "")
{
Regex dimRegex = new System.Text.RegularExpressions.Regex("^Dim");
Regex sqlParameterRegex = new System.Text.RegularExpressions.Regex("SqlParameter");
if (dimRegex.IsMatch(line) && sqlParameterRegex.IsMatch(line))
{
var result = dimSqlParameterParser.Parse(line);
form.RegistSqlParam(result);
}
}
}
return(input);
}
static void Main(string[] args)
{
var personTag = from a in Parse.String("Person") from b in Parse.LineEnd select a;
var point = Parse.Char('.');
Parser <string> nameParser = from tag in Parse.String("name:").Token()
from name in Parse.AnyChar.Except(Parse.LineEnd).AtLeastOnce().Text()
from le in Parse.LineEnd
select name;
Parser <string> ageParser = from tag in Parse.String("age:").Token()
from name in Parse.AnyChar.Except(Parse.LineEnd).AtLeastOnce().Text()
from le1 in Parse.LineEnd
from del in point
from le2 in Parse.LineEnd.Optional()
select name;
Parser <Person> personParser =
from p in personTag
from name in nameParser
from age in ageParser
select new Person {
Name = name, Age = age
};
var personsParser = personParser.Many();
var persons = personsParser.Parse(Text);
foreach (var person in persons)
{
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}
Console.ReadLine();
}
public ExpressionParserBuilder(Storage storage)
{
var constantParser =
Parse.Double.Select(s => (Expression)s).
Or(Parse.BigInt.Select(d => (Expression)d)).
Trim();
var functionParser =
(from name in Parse.Ident
from leftBracket in Parse.Char('(').Trim()
from parameters in Parse.Ref(() => _expressionParser).Many(Parse.Char(',').Trim())
from rightBracket in Parse.Char(')').Trim()
select new FunctionExpression(storage.Functions[name], parameters)).
Catch("Function not found");
var variableParser = Parse.Ident.
Trim().
Select(n => storage.Variables[n]).
Catch("Variable not found");
var bracketExpressionParser =
from leftBracket in Parse.Char('(').Trim()
from expression in Parse.Ref(() => _expressionParser)
from rightBracket in Parse.Char(')').Trim()
select expression;
var simpleExpression =
constantParser.Or(functionParser).Or(variableParser).Or(bracketExpressionParser);
var unarySignExpression =
from @operator in Parse.Char('+').Or(Parse.Char('-')).Optional('+')
from expression in simpleExpression
select @operator == '+' ? expression : new FunctionExpression(Operators.Negate, expression);
// TODO: multiple signs chars, i.e. -+-6
var powerExpression =
from @base in unarySignExpression
from power in unarySignExpression.RequiredIf(Parse.Char('^').Trim())
select power == null ? @base : new FunctionExpression(Operators.Power, @base, power);
var productOperator =
Parse.Char('*').Trim().Select(c => Operators.Multiply).Or(
Parse.Char('/').Trim().Select(c => Operators.Divide));
var productExpression =
from product in powerExpression.AtLeastOnce(productOperator,
(left, @operator, right) => new FunctionExpression(@operator, left, right))
select product;
var sumOperator =
Parse.Char('+').Trim().Select(c => Operators.Add).Or(
Parse.Char('-').Trim().Select(c => Operators.Subtract));
var sumExpression =
from product in productExpression.AtLeastOnce(sumOperator,
(left, @operator, right) => new FunctionExpression(@operator, left, right))
select product;
_expressionParser = sumExpression;
}
public static Parser <DateTime> DateParse() =>
from year in Parse.Number
from separator in Parse.Char('-')
from month in Parse.Number
from separator2 in Parse.Char('-')
from day in Parse.Number
select new DateTime(int.Parse(year), int.Parse(month), int.Parse(day));
public static void ChainL1EmptyFailure()
{
var state = new ParserState("", 4);
Func <char, char, char> fn = (l, r) => {
if (l > r)
{
return(l);
}
else
{
return(r);
}
};
var exception = Assert.Throws <ExpectedException>(() =>
Parse.Letter.ChainL1(Parse.Char(',').Then(fn))(state)
);
Assert.AreEqual(0, exception.Index);
Assert.AreEqual(
new string[] { "letter" },
exception.Expected
);
Assert.AreEqual(0, state.Index);
Assert.AreEqual(0, state.IndentIndex);
}
public void CanParseContained()
{
var parser = Parse.Char('a').Contained(Parse.Char('['), Parse.Char(']'));
var r = parser.TryParse("[a]");
Assert.True(r.WasSuccessful);
Assert.True(r.Remainder.AtEnd);
}
public BooleanExpressionParser()
{
Parser <Expression> boolean = BasicParser.IdentifierToken
.Select(id => Expression.Constant(conditionalConstants.Contains(id)))
.Named("boolean");
Parser <Expression> factor = (from lparen in Parse.Char('(')
from expr in Parse.Ref(() => expression)
from rparen in Parse.Char(')')
select expr).Named("expression")
.XOr(boolean);
Parser <Expression> operand = ((from sign in Parse.Char('!').Token()
from f in factor
select Expression.Not(f))
.XOr(factor)).Token();
// The higher the expr number, the higher the precendence. In this case, AND takes precedence over OR
Parser <Expression> expression2 = Parse.ChainOperator(and, operand, Expression.MakeBinary);
expression =
Parse.ChainOperator(or, expression2, Expression.MakeBinary);
lambda =
expression.End().Select(body => Expression.Lambda <Func <bool> >(body));
}
public void RepeatParserCanParseWithCountOfZero()
{
var repeated = Parse.Char('a').Repeat(0);
var r = repeated.TryParse("bbb");
Assert.True(r.WasSuccessful);
Assert.Equal(0, r.Remainder.Position);
}
public void CanParseSequence()
{
var sequence = Parse.Char('a').DelimitedBy(Parse.Char(','));
var r = sequence.TryParse("a,a,a");
Assert.True(r.WasSuccessful);
Assert.True(r.Remainder.AtEnd);
}
public void RepeatParserDoesntConsumeInputOnFailedMatch()
{
var repeated = Parse.Char('a').Repeat(3);
var r = repeated.TryParse("bbbaaa");
Assert.True(!r.WasSuccessful);
Assert.Equal(0, r.Remainder.Position);
}
public void RepeatParserConsumeInputOnSuccessfulMatch()
{
var repeated = Parse.Char('a').Repeat(3);
var r = repeated.TryParse("aaabbb");
Assert.True(r.WasSuccessful);
Assert.Equal(3, r.Remainder.Position);
}
public void WithOr_WhenFirstOptionFailsAndConsumesInput_SecondOptionTried()
{
var first = Parse.Char('a').Once().Concat(Parse.Char('b').Once());
var second = Parse.Char('a').Once();
var p = first.Or(second);
AssertParser.SucceedsWithAll(p, "a");
}
public void WithXOr_WhenFirstOptionFailsAndConsumesInput_SecondOptionNotTried()
{
var first = Parse.Char('a').Once().Concat(Parse.Char('b').Once());
var second = Parse.Char('a').Once();
var p = first.XOr(second);
AssertParser.FailsAt(p, "a", 1);
}
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);
}
/// <summary>
/// Matches extension in parenthesis or without them
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
private static Parser <T> OptionallyParenthesis <T>(Parser <T> source)
{
return((from left in Parse.Char('(')
from srcRef in Parse.Ref(() => source)
from right in Parse.Char(')')
select srcRef).XOr(source));
}
public void ConcatenatingParsers_ConcatenatesResults()
{
var p = Parse.Char('a').Once().Then(a =>
Parse.Char('b').Once().Select(b => a.Concat(b)));
AssertParser.SucceedsWithAll(p, "ab");
}
public static Parser <IEnumerable <T> > ListDelimitedBy <T>(this Parser <T> parser, char delimiter)
{
return
(from head in parser
from tail in Parse.Char(delimiter).Then(_ => parser).Many()
select head.Cons(tail));
}
static Parser <string> EndTag(string name)
{
return(Tag(from slash in Parse.Char('/')
from id in Identifier
where id == name
select id).Named("closing tag for " + name));
}
static Parser <T> Tag <T>(Parser <T> content)
{
return(from lt in Parse.Char('<')
from t in content
from gt in Parse.Char('>').Token()
select t);
}
public static Parser <Char> WhitespaceCharacter()
{
return(CharacterByUnicodeCategory(UnicodeCategory.SpaceSeparator)
.Or(Parse.Char('\u0009')) // Horizontal tab character
.Or(Parse.Char('\u000B')) // Vertical tab character
.Or(Parse.Char('\u000C'))); // Form feed character
}
static ScimExpressionParser()
{
CaseInsensitiveString = from content in QuotedString
select ScimExpression.String(content);
IdentifierName = Parse.Identifier(Parse.Letter, Parse.LetterOrDigit);
//compValue = false / null / true / number / string
//; rules from JSON(RFC 7159)
Literal = Parse.String("true").Return(ScimExpression.Constant(true))
.XOr(Parse.String("false").Return(ScimExpression.Constant(false)))
.XOr(Parse.String("null").Return(ScimExpression.Constant(null)));
//ATTRNAME = ALPHA * (nameChar)
//nameChar = "-" / "_" / DIGIT / ALPHA
// TODO : check - and _
AttrName = IdentifierName.Select(ScimExpression.Attribute);
//valuePath = attrPath "[" valFilter "]"
// ; FILTER uses sub - attributes of a parent attrPath
ValuePath = from open in Parse.Char('[')
from expr in Parse.Ref(() => Filter)
from close in Parse.Char(']')
select new Func <ScimExpression, ScimExpression>(r => ScimExpression.Binary("Where", r, expr));
//subAttr = "." ATTRNAME
//; a sub-attribute of a complex attribute
SubAttr = Parse.Char('.')
.Then(_ => IdentifierName)
.Then(n => Parse.Return(new Func <ScimExpression, ScimExpression>(r => ScimExpression.SubAttribute(n, r))));
//attrPath = [URI ":"] ATTRNAME * 1subAttr
// ; SCIM attribute name
// ; URI is SCIM "schema" URI
AttrPath = AttrName
.SelectMany(root => SubAttr.XOr(ValuePath).XMany(), (name, path) => path.Aggregate(name, (o, f) => f(o)));
Operand = (ExpressionInParentheses
.XOr(Literal.Or(AttrPath.Token()))
.XOr(CaseInsensitiveString)).Token();
// compareOp = "eq" / "ne" / "co" /
// "sw" / "ew" /
// "gt" / "lt" /
// "ge" / "le"
Comparison = Parse.XChainOperator(Le.Or(Lt).XOr(Ge.Or(Gt)).XOr(Eq.Or(Ne)).XOr(Sw.Or(Ew)).XOr(Co).XOr(Pr), Operand, ScimExpression.Binary);
// attrPath SP "pr"
Presence = Operand.SelectMany(operand => Pr, (operand, pr) => ScimExpression.Unary(pr, operand));
// attrExp = (attrPath SP "pr") /
// (attrPath SP compareOp SP compValue)
AttributeExpression = Presence.Or(Comparison);
// logExp = FILTER SP ("and" / "or") SP FILTER
LogicalExpression = Parse.XChainOperator(Or.Or(And), AttributeExpression, ScimExpression.Binary);
Filter = LogicalExpression;
}
private static ParserWithContainer <Expression, KeyPropertyContainer> ConditionFactor(KeyPropertyContainer container)
{
return(new ParserWithContainer <Expression, KeyPropertyContainer>(
(from lparen in Parse.Char('(').Token()
from expr in Parse.Ref(() => ConditionExpr(container).Parser)
from rparen in Parse.Char(')').Token()
select expr).Named("expression"), container));
}
internal static Parser <string> UntilCharacters(params char[] characters)
{
var charactersLookup = new HashSet <char>(characters);
return
(from word in Parse.Char(p => !charactersLookup.Contains(p), "Consume until we hit a specified character").Many().Text()
select word);
}
public void Issue166()
{
var letterA = Parse.Char('a');
var letterReferenced = Parse.Ref(() => letterA);
var someAlternative = letterReferenced.Or(letterReferenced);
Assert.False(someAlternative.TryParse("b").WasSuccessful);
}
private static Parser <char> Operator(char op)
{
return
(from leading in Parse.WhiteSpace.Many()
from bracket in Parse.Char(op)
from trailing in Parse.WhiteSpace.Many()
select bracket);
}
// Factory method for building name=value pair parser combinators
private static Parser <KeyValuePair <string, TValue> > NameValuePair <TValue>(string name, Parser <TValue> valueParser)
{
return((from key in Parse.String(name).Text( ).Token( )
from eq in Parse.Char('=').Token( )
from value in valueParser
select new KeyValuePair <string, TValue>(key, value)
).Token( ));
}
public static Parser <Char> NewLineCharacter()
{
return(Parse.Char('\u000D') // Carriage return character
.Or(Parse.Char('\u000A')) // Line feed character
.Or(Parse.Char('\u0085')) // Next line character
.Or(Parse.Char('\u2028')) // Line separator character
.Or(Parse.Char('\u2029'))); // Paragraph separator character
}
public void CanSpecifyParsersUsingQueryComprehensions()
{
var p = from a in Parse.Char('a').Once()
from bs in Parse.Char('b').Many()
from cs in Parse.Char('c').AtLeastOnce()
select a.Concat(bs).Concat(cs);
AssertParser.SucceedsWithAll(p, "abbbc");
}
public static Parser <Expression> Function(Expression context)
{
return
(from n in Lexer.Identifier.Select(name => name)
from lparen in Parse.Char('(').Token()
from paramList in Parse.Ref(() => FunctionParameter(n).Named("parameter")).DelimitedBy(Parse.Char(',').Token()).Optional()
from rparen in Parse.Char(')').Token()
select new FunctionCallExpression(context, n, TypeInfo.Any, paramList.GetOrElse(Enumerable.Empty <Expression>())));
}
