public FreeTextLiteralTestGrammar(Terminal terminal) : base(caseSensitive: true) { var rule = new BnfExpression(terminal); MarkReservedWords(Terminator); rule += Terminator; base.Root = new NonTerminal("Root"); Root.Rule = rule; }
public TerminalTestGrammar(Terminal terminal, string terminator = null) : base(caseSensitive: true) { Terminator = terminator; var rule = new BnfExpression(terminal); if (Terminator != null) { MarkReservedWords(Terminator); rule += Terminator; } base.Root = new NonTerminal("Root"); Root.Rule = rule; }
private void CollectTermsRecursive(BnfTerm term) { if (_grammarData.AllTerms.Contains(term)) { return; } _grammarData.AllTerms.Add(term); NonTerminal nt = term as NonTerminal; if (nt == null) { return; } if (string.IsNullOrEmpty(nt.Name)) { if (nt.Rule != null && !string.IsNullOrEmpty(nt.Rule.Name)) { nt.Name = nt.Rule.Name; } else { nt.Name = "Unnamed" + (_unnamedCount++); } } if (nt.Rule == null) { _language.Errors.AddAndThrow(GrammarErrorLevel.Error, null, Resources.ErrNtRuleIsNull, nt.Name); } //check all child elements foreach (BnfTermList elemList in nt.Rule.Data) { for (int i = 0; i < elemList.Count; i++) { BnfTerm child = elemList[i]; if (child == null) { _language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrRuleContainsNull, nt.Name, i); continue; //for i loop } //Check for nested expression - convert to non-terminal BnfExpression expr = child as BnfExpression; if (expr != null) { child = new NonTerminal(null, expr); elemList[i] = child; } CollectTermsRecursive(child); } //for i } } //method
public TerminalTestGrammar(Terminal terminal, string terminator = null) : base(caseSensitive: true) { Terminator = terminator; var rule = new BnfExpression(terminal); if (Terminator != null) { MarkReservedWords(Terminator); rule += Terminator; } Root = new NonTerminal("Root") { Rule = rule }; }
private static NonTerminal NonTerminal <T>(string name, BnfExpression rule, Func <ParseTreeNode, T> creator) { return(new NonTerminal(name, (context, n) => { try { n.AstNode = creator(n); } catch (Exception e) { var input = GetTokens(n).JoinStrings(" "); const string messageFormat = "exception creating ast node from node {0} [{1}]"; throw new InvalidOperationException(string.Format(messageFormat, n, input), e); } }) { Rule = rule }); }
BnfTerm MultiWordTermial(string term) { var parts = term.Split(' '); if (parts.Length == 1) { return(ToTerm(term)); } var nonterm = new NonTerminal(term, typeof(MultiWordTermialNode)); BnfExpression expr = new BnfExpression(ToTerm(parts[0])); foreach (var part in parts.Skip(1)) { expr += ToTerm(part); } nonterm.Rule = expr; return(nonterm); }
private void ProcessUnparseHints(BnfExpression rule) { if (rule != null) { for (int childBnfTermListIndex = 0; childBnfTermListIndex < rule.Data.Count; childBnfTermListIndex++) { BnfTermList bnfTermList = rule.Data[childBnfTermListIndex]; try { UnparseHint unparseHint = (UnparseHint)bnfTermList.SingleOrDefault(bnfTerm => bnfTerm is UnparseHint); childBnfTermListIndexToUnparseHint.Add(childBnfTermListIndex, unparseHint); } catch (InvalidOperationException) { GrammarHelper.ThrowGrammarErrorException( GrammarErrorLevel.Error, "NonTerminal '{0}' has more than one UnparseHint on its {1}. childrenlist. Only one UnparseHint is allowed per childrenlist.", this, childBnfTermListIndex + 1 ); } } } }
private BnfExpression TerminalsFromEnum <TEnum>(string groupName = null) where TEnum : struct, Enum { BnfExpression expr = null; var names = Enum.GetNames <TEnum>(); KeyTerm toTerm(string name) => groupName is null?ToTerm(name) : ToTerm(name, groupName); foreach (var name in names) { if (expr is null) { expr = toTerm(name); } else { expr |= toTerm(name); } } return(expr); }
protected BnfExpression CreateRuleFromObjectTypes <T>(IEnumerable <T> types) where T : ObjectType { BnfExpression rule = null; foreach (var type in types) { if (rule == null) { rule = TypeName(type.Name); } else { rule |= TypeName(type.Name); } // Add alternative names as well foreach (var alternativeName in type.AlternativeNames) { rule |= TypeName(alternativeName); } } return(rule); }
NonTerminal BuildTerminal <TNode>(string name, string filename) where TNode : MultiWordTermialNode { const string ResourcePrefix = "Shakespeare.include."; var termList = new NonTerminal(name, typeof(TNode)); var strm = Assembly.GetExecutingAssembly().GetManifestResourceStream(ResourcePrefix + filename.ToLowerInvariant()); var sw = new StreamReader(strm); var block = sw.ReadToEnd(); var lines = block.Split('\n', '\r'); if (lines.Any()) { BnfExpression expr = new BnfExpression(MultiWordTermial(lines[0])); foreach (var line in lines.Skip(1)) { if (!String.IsNullOrWhiteSpace(line)) { expr |= MultiWordTermial(line); } } termList.Rule = expr; } return(termList); }
public QueryGrammar() : base(false) { LanguageFlags = LanguageFlags.CreateAst; not = Transient("not", ToTerm("NOT") | "НЕ"); by = NonTerminal("by", ToTerm("by") | "ПО", TermFlags.NoAstNode); distinctOpt = NonTerminal("distinctOpt", null); var identifier = Identifier(); var root = NonTerminal("root", null, ToSqlQuery); var selectStatement = NonTerminal("selectStmt", null, ToSelectClause); var expression = Expression(identifier, root); var asOpt = NonTerminal("asOpt", Empty | "AS" | "КАК"); var alias = NonTerminal("alias", null, TermFlags.IsTransient); var aliasOpt = NonTerminal("aliasOpt", null, TermFlags.IsTransient); var columnItem = NonTerminal("columnItem", null, ToSelectFieldExpression); var tableDeclaration = NonTerminal("joinSource", null, ToTableDeclaration); var columnSource = NonTerminal("columnSource", null, TermFlags.IsTransient); var joinItemList = Join(columnSource, expression); var whereClauseOpt = NonTerminal("whereClauseOpt", null, node => node.ChildNodes.Count == 0 ? null : node.ChildNodes[1].AstNode); var groupClauseOpt = GroupBy(expression); var orderClauseOpt = OrderBy(expression); var havingClauseOpt = NonTerminal("havingClauseOpt", Empty | ToTerm("having") + expression, node => node.ChildNodes.Count == 0 ? null : node.ChildNodes[1].AstNode); var columnItemList = NonTerminal("columnItemList", null); var topOpt = NonTerminal("topOpt", null); var selectList = NonTerminal("selectList", null); var unionStmtOpt = NonTerminal("unionStmt", null, ToUnionType); var unionList = NonTerminal("unionList", null, ToUnionList); var subqueryTable = NonTerminal("subQuery", null, ToSubqueryTable); //rules selectStatement.Rule = Transient("select", ToTerm("SELECT") | "ВЫБРАТЬ") + topOpt + distinctOpt + selectList + Transient("from", ToTerm("FROM") | ToTerm("ИЗ")) + columnSource + joinItemList + whereClauseOpt + groupClauseOpt + havingClauseOpt; selectList.Rule = columnItemList | "*"; topOpt.Rule = Empty | Transient("top", ToTerm("TOP") | "ПЕРВЫЕ") + numberLiteral; distinctOpt.Rule = Empty | Transient("distinct", ToTerm("DISTINCT") | "РАЗЛИЧНЫЕ"); columnSource.Rule = tableDeclaration | subqueryTable; alias.Rule = asOpt + identifier; aliasOpt.Rule = Empty | alias; columnItem.Rule = expression + aliasOpt; tableDeclaration.Rule = identifier + aliasOpt; columnItemList.Rule = MakePlusRule(columnItemList, ToTerm(","), columnItem); subqueryTable.Rule = ToTerm("(") + root + ")" + alias; whereClauseOpt.Rule = Empty | (Transient("where", ToTerm("WHERE") | "ГДЕ") + expression); unionStmtOpt.Rule = Empty | (Transient("union", ToTerm("UNION") | "ОБЪЕДИНИТЬ") + Transient("unionAllModifier", Empty | "ALL" | "ВСЕ")); unionList.Rule = MakePlusRule(unionList, null, NonTerminal("unionListElement", selectStatement + unionStmtOpt)); root.Rule = unionList + orderClauseOpt; RegisterOperators <SqlBinaryOperator>(); RegisterOperators <UnaryOperator>(); MarkPunctuation(",", "(", ")"); MarkPunctuation(asOpt); AddOperatorReportGroup("operator"); AddToNoReportGroup("as", "КАК"); Root = root; }
public static NonTerminal Named(string name, BnfExpression expr) { var nt = new NonTerminal(name); nt.Rule = expr; return nt; }
public ListPattern(string name, string separator = null, BnfExpression elementRule = null) : base(name) { if (separator != null) Separators = new string[] { separator }; ElementRule = elementRule; }
protected static BnfTerm WithStar(BnfExpression expression) { return ToElement(expression).Star(); }
protected static BnfTerm ToElement(BnfExpression expression) { string name = expression.ToString(); return new NonTerminal(name, expression); }
protected BnfiExpression() { this.bnfExpression = new BnfExpression(); }
protected BnfiExpressionConversion(BnfExpression bnfExpression) : base(bnfExpression) { }
protected BnfiExpression(BnfExpression bnfExpression) { this.bnfExpression = bnfExpression; }
static NonTerminal CreateNonTerminal(string name, BnfExpression rule) { var nt = new NonTerminal(name); nt.Rule = rule; return nt; }
protected BnfiExpression(BnfTerm bnfTerm) { this.bnfExpression = bnfTerm.ToBnfExpression(); }
protected void CreateBNFRule(BnfExpression myBnfExpression) { CLICommandNonTerminal.Rule = myBnfExpression; CLICommandNonTerminal.GraphOptions.Add(GraphOption.IsCommandRoot); //ToDo: Via reflection // Non-terminal integration _CommandNonTerminals.Add(CLICommandNonTerminal); // Symbol integration _CommandSymbolTerminal.Add(CLICommandSymbolTerminal); }
protected BnfiExpression() { this.bnfExpression = new BnfExpression(); }
protected BnfiExpression(BnfExpression bnfExpression) { this.bnfExpression = bnfExpression; }
protected BnfiExpression(BnfTerm bnfTerm) { this.bnfExpression = bnfTerm.ToBnfExpression(); }
internal static IEnumerable <BnfTermList> GetBnfTermsList(this BnfExpression bnfExpression) { return(bnfExpression.Data); }
protected BnfiExpressionConversion(BnfExpression bnfExpression) : base(bnfExpression) { }
public static NonTerminal WithRule(this NonTerminal @this, BnfExpression expression) { @this.Rule = expression; return @this; }
public XbnfGrammar(Mode mode) { this.mode = mode; var alternationChar = (mode == Mode.Strict) ? "/" : "|"; var rulename = new IdentifierTerminal("rulename", "-_", null); var funcname = new IdentifierTerminal("funcname", ".", null); var newrulename = new IdentifierTerminal("newrulename", "-_", null); var comment = new CommentTerminal("comment", "/*", "*/"); var bindig1 = new NumberLiteral("bindig", NumberOptions.Binary | NumberOptions.IntOnly); var bindig2 = new NumberLiteral("bindig", NumberOptions.Binary | NumberOptions.IntOnly); var hexdig1 = new NumberLiteral("hexdig", NumberOptions.Hex | NumberOptions.IntOnly); var hexdig2 = new NumberLiteral("hexdig", NumberOptions.Hex | NumberOptions.IntOnly); var decdig1 = new NumberLiteral("decvalue", NumberOptions.IntOnly); var decdig2 = new NumberLiteral("decvalue", NumberOptions.IntOnly); var charval = new StringLiteral("charval", "\"", StringOptions.NoEscapes); var repeat1 = new NumberLiteral("repeat1", NumberOptions.IntOnly); var repeat2 = new NumberLiteral("repeat2", NumberOptions.IntOnly); var minus = ToTerm("-", "minus"); var point = ToTerm(".", "point"); bindig1.AddPrefix("b", NumberOptions.None); hexdig1.AddPrefix("x", NumberOptions.None); decdig1.AddPrefix("d", NumberOptions.None); base.NonGrammarTerminals.Add(comment); // NON TERMINALS var numval = new NonTerminal("numval"); var hexval = new NonTerminal("hexval"); var hexvalp = new NonTerminal("hexvalpoint"); var hexvalps = new NonTerminal("hexvalpointstar"); var binval = new NonTerminal("binval"); var binvalp = new NonTerminal("binvalpoint"); var binvalps = new NonTerminal("binvalpointstar"); var decval = new NonTerminal("decval"); var decvalp = new NonTerminal("decvalpoint"); var decvalps = new NonTerminal("decvalpointstar"); var rule = new NonTerminal("rule"); var rulelist = new NonTerminal("rulelist"); var alternation = new NonTerminal("alternation"); var concatenation = new NonTerminal("concatenation"); var substraction = new NonTerminal("substraction"); var repetition = new NonTerminal("repetition"); var repeat = new NonTerminal("repeat"); var element = new NonTerminal("element"); var elements = new NonTerminal("elements"); var group = new NonTerminal("group"); var option = new NonTerminal("option"); var func = new NonTerminal("func"); var funcarg = new NonTerminal("funcarg"); var funcargs = new NonTerminal("funcargs"); // RULES hexval.Rule = hexdig1 + (hexvalps | (minus + hexdig2) | Empty); hexvalp.Rule = point + hexdig2; hexvalps.Rule = MakePlusRule(hexvalps, hexvalp); binval.Rule = bindig1 + (binvalps | (minus + bindig2) | Empty); binvalp.Rule = point + bindig2; binvalps.Rule = MakePlusRule(binvalps, binvalp); decval.Rule = decdig1 + (decvalps | (minus + decdig2) | Empty); decvalp.Rule = point + decdig2; decvalps.Rule = MakePlusRule(decvalps, decvalp); numval.Rule = ToTerm("%") + (binval | hexval | decval); BnfExpression rp = ToTerm("*"); if (mode == Mode.HttpCompatible) { rp = rp | "#"; } repeat.Rule = ((repeat1) | ((repeat1 | Empty) + rp + (repeat2 | Empty))); group.Rule = ToTerm("(") + alternation + ")"; option.Rule = ToTerm("[") + alternation + "]"; funcarg.Rule = alternation; funcargs.Rule = MakePlusRule(funcargs, ToTerm(","), funcarg); func.Rule = ToTerm("{") + funcname + "," + funcargs + "}"; //alternation.Rule = MakePlusRule(alternation, ToTerm(alternationChar), concatenation); //concatenation.Rule = MakePlusRule(concatenation, repetition); alternation.Rule = MakePlusRule(alternation, ToTerm(alternationChar), substraction); substraction.Rule = MakePlusRule(substraction, ToTerm("&!"), concatenation); //concatenation + ((ToTerm("--") + concatenation) | Empty); concatenation.Rule = MakePlusRule(concatenation, repetition); repetition.Rule = (Empty | repeat) + element; element.Rule = rulename | group | option | numval | charval | func; elements.Rule = alternation; rule.Rule = newrulename + (ToTerm("=") | ToTerm("=" + alternationChar)) + elements + ";"; rulelist.Rule = MakeStarRule(rulelist, rule); base.Root = rulelist; base.LanguageFlags |= LanguageFlags.CanRunSample; }
protected static BnfTerm WithPlus(BnfExpression expression) { return ToElement(expression).Plus(); }
private NonTerminal _(string name, BnfExpression rule) { return new NonTerminal(name) {Rule = rule}; }
public Pattern(string name, BnfExpression rule = null) : base(name) { Rule = rule; }
private void _(NonTerminal nonTerminal, BnfExpression rule) { nonTerminal.Rule = rule; }
private void BuildGraphCLIGrammar() { #region global grammar options GraphCLIGrammar.CaseSensitive = false; NonTerminal _Command = new NonTerminal("Command"); List<ABnfTerm> _SubtreeCommandGrammarRoot = new List<ABnfTerm>(); #endregion #region get command specific grammars foreach (KeyValuePair<String, AllCLICommands> _aCommand in Commands) { //TODO: check if the grammar is valid. if not --> handle error Grammar _aCommandGrammar = _aCommand.Value.CommandGrammar; LanguageCompiler _testCompiler = new LanguageCompiler(_aCommandGrammar); Boolean isGrammarValid = true; foreach (String aErrorString in _testCompiler.Grammar.Errors) { if (aErrorString.StartsWith("Error")) { WriteLine(aErrorString); isGrammarValid = false; } } if (isGrammarValid) { GraphCLIGrammar.NonTerminals.AddRange(_aCommandGrammar.NonTerminals); GraphCLIGrammar.Terminals.AddRange(_aCommandGrammar.Terminals); _SubtreeCommandGrammarRoot.Add(_aCommandGrammar.Root); } else { WriteLine("ERROR! The command \"{0}\" is defined by an incorrect BNF grammar. It is not integrated into the GraphCLI!"); } } #endregion #region build new root for (int i = 0; i < _SubtreeCommandGrammarRoot.Count; i++) { BnfExpression _exprNew = new BnfExpression(_SubtreeCommandGrammarRoot[i]); if (!i.Equals(0)) { BnfExpression _exprActual = new BnfExpression(_Command.Rule); _Command.Rule = _exprActual | _exprNew; } else { _Command.Rule = _exprNew; } } GraphCLIGrammar.NonTerminals.Add(_Command); GraphCLIGrammar.Root = _Command; #endregion }
public static BnfExpression Q(this BnfExpression bnf, string name) { bnf = bnf.Q(); bnf.Name = name; return(bnf); }