public static StringLiteral CreatePythonString(string name) { StringLiteral term = new StringLiteral(name); term.AddStartEnd("'", StringOptions.AllowsAllEscapes); term.AddStartEnd("'''", StringOptions.AllowsAllEscapes | StringOptions.AllowsLineBreak); term.AddStartEnd("\"", StringOptions.AllowsAllEscapes); term.AddStartEnd("\"\"\"", StringOptions.AllowsAllEscapes | StringOptions.AllowsLineBreak); term.AddPrefix("u", StringOptions.AllowsAllEscapes); term.AddPrefix("r", StringOptions.NoEscapes ); term.AddPrefix("ur", StringOptions.NoEscapes); return term; }
public static StringLiteral CreateCSharpString(string name) { var term = new StringLiteral(name, "\"", StringOptions.AllowsAllEscapes); term.AddPrefix("@", StringOptions.NoEscapes | StringOptions.AllowsLineBreak | StringOptions.AllowsDoubledQuote); return term; }
public GMacGrammar(GMacGrammarRootType rootType) { #region Terminals var multiLineComment = new CommentTerminal(GMacParseNodeNames.MultiLineComment, "/*", "*/"); NonGrammarTerminals.Add(multiLineComment); var singleLineComment = new CommentTerminal(GMacParseNodeNames.SingleLineComment, "//", "\n", "\r\n"); NonGrammarTerminals.Add(singleLineComment); //Double quoted string var dqString = new StringLiteral(GMacParseNodeNames.DqString, "\"", StringOptions.AllowsAllEscapes); dqString.AddPrefix("@", StringOptions.NoEscapes | StringOptions.AllowsLineBreak | StringOptions.AllowsDoubledQuote); //Single quoted string var sqString = new StringLiteral(GMacParseNodeNames.SqString, "'", StringOptions.AllowsAllEscapes); sqString.AddPrefix("@", StringOptions.NoEscapes | StringOptions.AllowsLineBreak | StringOptions.AllowsDoubledQuote); var identifier = new IdentifierTerminal(GMacParseNodeNames.Identifier); var constantNumber = new NumberLiteral(GMacParseNodeNames.ConstantNumber, NumberOptions.AllowSign); var punctColon = ToTerm(":"); var punctDot = ToTerm("."); var punctComma = ToTerm(","); var punctEqual = ToTerm("="); var punctHash = ToTerm("#"); var punctAt = ToTerm("@"); var punctAmp = ToTerm("&"); var punctLcb = ToTerm("{"); var punctRcb = ToTerm("}"); var punctLrb = ToTerm("("); var punctRrb = ToTerm(")"); var punctLsb = ToTerm("["); var punctRsb = ToTerm("]"); var punctLab = ToTerm("<"); var punctRab = ToTerm(">"); var keywordBreakpoint = ToTerm("breakpoint"); //TODO: Create an enum for GMacDSL keywords. This is useful for coloring in the source code editor var keywordUsing = ToTerm("using"); var keywordBegin = ToTerm("begin"); var keywordEnd = ToTerm("end"); var keywordFrame = ToTerm("frame"); var keywordMacro = ToTerm("macro"); var keywordTransform = ToTerm("transform"); var keywordEuclidean = ToTerm("euclidean"); var keywordIpm = ToTerm("IPM"); var keywordCbm = ToTerm("CBM"); var keywordOrthogonal = ToTerm("orthogonal"); var keywordOrthonormal = ToTerm("orthonormal"); var keywordReciprocal = ToTerm("reciprocal"); var keywordClass = ToTerm("class"); var keywordGa = ToTerm("ga"); var keywordDeclare = ToTerm("declare"); var keywordLet = ToTerm("let"); var keywordOutput = ToTerm("output"); var keywordReturn = ToTerm("return"); var keywordNamespace = ToTerm("namespace"); var keywordConstant = ToTerm("constant"); var keywordStructure = ToTerm("structure"); var keywordFrom = ToTerm("from"); var keywordTo = ToTerm("to"); var keywordOpen = ToTerm("open"); var keywordTemplate = ToTerm("template"); var keywordImplement = ToTerm("implement"); var keywordSubspace = ToTerm("subspace"); var keywordOn = ToTerm("on"); var keywordAccess = ToTerm("access"); var keywordBind = ToTerm("bind"); var keywordWith = ToTerm("with"); var keywordBinding = ToTerm("binding"); var gaOpCaret = ToTerm("^"); var gaOpTimes = ToTerm("*"); var gaOpDivide = ToTerm("/"); var gaOpPlus = ToTerm("+"); var gaOpMinus = ToTerm("-"); var gaOpOuterProduct = ToTerm("op"); var gaOpGeometricProduct = ToTerm("gp"); var gaOpScalarProduct = ToTerm("sp"); var gaOpLeftContractionProduct = ToTerm("lcp"); var gaOpRightContractionProduct = ToTerm("rcp"); var gaOpFatDotProduct = ToTerm("fdp"); var gaOpHestenesInnrProduct = ToTerm("hip"); var gaOpCommutatorProduct = ToTerm("cp"); var gaOpAntiCommutatorProduct = ToTerm("acp"); var gaOpEuclideanGeometricProduct = ToTerm("egp"); var gaOpEuclideanScalarProduct = ToTerm("esp"); var gaOpEuclideanLeftContractionProduct = ToTerm("elcp"); var gaOpEuclideanRightContractionProduct = ToTerm("ercp"); var gaOpEuclideanFatDotProduct = ToTerm("efdp"); var gaOpEuclideanHestenesInnrProduct = ToTerm("ehip"); var gaOpEuclideanCommutatorProduct = ToTerm("ecp"); var gaOpEuclideanAntiCommutatorProduct = ToTerm("eacp"); #endregion #region Non-Terminals var gmacDslRoot = new NonTerminal(GMacParseNodeNames.GMacDslRoot); var gmacDslItemsList = new NonTerminal(GMacParseNodeNames.GMacDslItemsList); var gmacDslItem = new NonTerminal(GMacParseNodeNames.GMacDslItem); var breakpoint = new NonTerminal(GMacParseNodeNames.Breakpoint); var Namespace = new NonTerminal(GMacParseNodeNames.Namespace); var openNamespace = new NonTerminal(GMacParseNodeNames.OpenNamespace); var frame = new NonTerminal(GMacParseNodeNames.Frame); var frameVectors = new NonTerminal(GMacParseNodeNames.FrameVectors); var frameSignature = new NonTerminal(GMacParseNodeNames.FrameSignature); var frameSignatureEuclidean = new NonTerminal(GMacParseNodeNames.FrameSignatureEuclidean); var frameSignatureIpm = new NonTerminal(GMacParseNodeNames.FrameSignatureIpm); var frameSignatureCbm = new NonTerminal(GMacParseNodeNames.FrameSignatureCbm); var frameSignatureOrthonormal = new NonTerminal(GMacParseNodeNames.FrameSignatureOrthonormal); var frameSignatureOrthogonal = new NonTerminal(GMacParseNodeNames.FrameSignatureOrthogonal); var frameSignatureReciprocal = new NonTerminal(GMacParseNodeNames.FrameSignatureReciprocal); var frameSubspaceList = new NonTerminal(GMacParseNodeNames.FrameSubspaceList); var frameSubspace = new NonTerminal(GMacParseNodeNames.FrameSubspace); var stringLiteral = new NonTerminal(GMacParseNodeNames.StringLiteral); var outerproductList = new NonTerminal(GMacParseNodeNames.OuterproductList); var identifierList = new NonTerminal(GMacParseNodeNames.IdentifierList); var qualifiedIdentifier = new NonTerminal(GMacParseNodeNames.QualifiedIdentifier); var qualifiedIdentifierList = new NonTerminal(GMacParseNodeNames.QualifiedIdentifierList); var basisBladesSet = new NonTerminal(GMacParseNodeNames.BasisBladesSet); var basisBladesSetList = new NonTerminal(GMacParseNodeNames.BasisBladesSetList); var basisBladesSetListItem = new NonTerminal(GMacParseNodeNames.BasisBladesSetListItem); var basisBladesSetListItemGaSpan = new NonTerminal(GMacParseNodeNames.BasisBladesSetListItemGaSpan); var qualifiedBasisBladesSet = new NonTerminal(GMacParseNodeNames.QualifiedBasisBladesSet); var dataMembersSet = new NonTerminal(GMacParseNodeNames.DataMembersSet); var qualifiedDataMembersSet = new NonTerminal(GMacParseNodeNames.QualifiedDataMembersSet); var basisBladeCoefficient = new NonTerminal(GMacParseNodeNames.BasisBladeCoefficient); var qualifiedBasisBladeCoefficient = new NonTerminal(GMacParseNodeNames.QualifiedBasisBladeCoefficient); var qualifiedItem = new NonTerminal(GMacParseNodeNames.QualifiedItem); var macro = new NonTerminal(GMacParseNodeNames.Macro); var macroTemplate = new NonTerminal(GMacParseNodeNames.MacroTemplate); var macroInputs = new NonTerminal(GMacParseNodeNames.MacroInputs); var identifierDeclaration = new NonTerminal(GMacParseNodeNames.IdentifierDeclaration); var templatesImplementation = new NonTerminal(GMacParseNodeNames.TemplatesImplementation); var expressionOpt = new NonTerminal(GMacParseNodeNames.ExpressionOpt); var expression = new NonTerminal(GMacParseNodeNames.Expression); var expressionSum = new NonTerminal(GMacParseNodeNames.ExpressionSum); var expressionProduct = new NonTerminal(GMacParseNodeNames.ExpressionProduct); var expressionAtomic = new NonTerminal(GMacParseNodeNames.ExpressionAtomic); var expressionBracketed = new NonTerminal(GMacParseNodeNames.ExpressionBracketed); var expressionScoped = new NonTerminal(GMacParseNodeNames.ExpressionScoped); var expressionFunction = new NonTerminal(GMacParseNodeNames.ExpressionFunction); var expressionFunctionDefaultValueOpt = new NonTerminal(GMacParseNodeNames.ExpressionFunctionDefaultValueOpt); var expressionFunctionDefaultValue = new NonTerminal(GMacParseNodeNames.ExpressionFunctionDefaultValue); var expressionFunctionInputsOpt = new NonTerminal(GMacParseNodeNames.ExpressionFunctionInputsOpt); var expressionFunctionInputs = new NonTerminal(GMacParseNodeNames.ExpressionFunctionInputs); var expressionFunctionInputsExpressions = new NonTerminal(GMacParseNodeNames.ExpressionFunctionInputsExpressions); var expressionFunctionInputsAssignments = new NonTerminal(GMacParseNodeNames.ExpressionFunctionInputsAssignments); var expressionFunctionInputsAssignmentsItem = new NonTerminal(GMacParseNodeNames.ExpressionFunctionInputsAssignmentsItem); var expressionFunctionInputsAssignmentsItemLhs = new NonTerminal(GMacParseNodeNames.ExpressionFunctionInputsAssignmentsItemLhs); var expressionComposite = new NonTerminal(GMacParseNodeNames.ExpressionComposite); var command = new NonTerminal(GMacParseNodeNames.Command); var commandLet = new NonTerminal(GMacParseNodeNames.CommandLet); var commandLetLhs = new NonTerminal(GMacParseNodeNames.CommandLetLhs); var commandDeclare = new NonTerminal(GMacParseNodeNames.CommandDeclare); var commandReturn = new NonTerminal(GMacParseNodeNames.CommandReturn); //var Command_Output = new NonTerminal(GMacParseNodeNames.Command_Output); var commandBlock = new NonTerminal(GMacParseNodeNames.CommandBlock); var commandBlockCommandsList = new NonTerminal(GMacParseNodeNames.CommandBlockCommandsList); var gaBinarySum = new NonTerminal(GMacParseNodeNames.GaBinarySum); var gaUnaryOperation = new NonTerminal(GMacParseNodeNames.GaUnaryOperation); var gaBinaryProduct = new NonTerminal(GMacParseNodeNames.GaBinaryProduct); var constant = new NonTerminal(GMacParseNodeNames.Constant); var structure = new NonTerminal(GMacParseNodeNames.Structure); var structureMembers = new NonTerminal(GMacParseNodeNames.StructureMembers); var transform = new NonTerminal(GMacParseNodeNames.Transform); #endregion #region Rules switch (rootType) { case GMacGrammarRootType.Normal: Root = gmacDslRoot; break; case GMacGrammarRootType.Expression: Root = expression; break; case GMacGrammarRootType.QualifiedItem: Root = qualifiedItem; break; case GMacGrammarRootType.Macro: Root = macro; break; case GMacGrammarRootType.Structure: Root = structure; break; case GMacGrammarRootType.Commands: Root = commandBlockCommandsList; break; default: Root = gmacDslRoot; break; } gmacDslRoot.Rule = gmacDslItemsList; gmacDslItemsList.Rule = MakeStarRule(gmacDslItemsList, gmacDslItem); gmacDslItem.Rule = breakpoint | Namespace | openNamespace | frame | structure | constant | macro | transform | macroTemplate | templatesImplementation; breakpoint.Rule = keywordBreakpoint; Namespace.Rule = keywordNamespace + qualifiedIdentifier; openNamespace.Rule = keywordOpen + qualifiedIdentifier; frame.Rule = keywordFrame + identifier + punctLrb + frameVectors + punctRrb + frameSignature + frameSubspaceList; frameVectors.Rule = MakePlusRule(frameVectors, punctComma, identifier); frameSignature.Rule = frameSignatureEuclidean | frameSignatureIpm | frameSignatureCbm | frameSignatureOrthonormal | frameSignatureOrthogonal | frameSignatureReciprocal; frameSignatureEuclidean.Rule = keywordEuclidean; frameSignatureIpm.Rule = keywordIpm + stringLiteral; frameSignatureCbm.Rule = keywordCbm + qualifiedIdentifier + stringLiteral; frameSignatureOrthonormal.Rule = keywordOrthonormal + stringLiteral; frameSignatureOrthogonal.Rule = keywordOrthogonal + stringLiteral; frameSignatureReciprocal.Rule = keywordReciprocal + qualifiedIdentifier; frameSubspaceList.Rule = MakeStarRule(frameSubspaceList, frameSubspace); frameSubspace.Rule = keywordSubspace + identifier + punctEqual + basisBladesSet; stringLiteral.Rule = dqString | sqString; outerproductList.Rule = MakePlusRule(outerproductList, gaOpCaret, identifier); identifierList.Rule = MakePlusRule(identifierList, punctComma, identifier); qualifiedIdentifier.Rule = MakePlusRule(qualifiedIdentifier, punctDot, identifier); qualifiedIdentifierList.Rule = MakePlusRule(qualifiedIdentifierList, punctComma, qualifiedIdentifier); basisBladesSet.Rule = punctAt + basisBladesSetList + punctAt; basisBladesSetList.Rule = MakePlusRule(basisBladesSetList, punctComma, basisBladesSetListItem); basisBladesSetListItem.Rule = outerproductList | basisBladesSetListItemGaSpan; basisBladesSetListItemGaSpan.Rule = keywordGa + punctLcb + identifierList + punctRcb; qualifiedBasisBladesSet.Rule = qualifiedIdentifier + punctDot + basisBladesSet; dataMembersSet.Rule = punctAt + identifierList + punctAt; qualifiedDataMembersSet.Rule = qualifiedIdentifier + punctDot + dataMembersSet; basisBladeCoefficient.Rule = punctHash + outerproductList + punctHash; qualifiedBasisBladeCoefficient.Rule = qualifiedIdentifier + punctDot + basisBladeCoefficient; qualifiedItem.Rule = qualifiedIdentifier | qualifiedBasisBladeCoefficient | qualifiedBasisBladesSet | qualifiedDataMembersSet;//TODO: Implement Qualified_DataMembersSet in the AST generators macroTemplate.Rule = keywordTemplate + macro; macro.Rule = keywordMacro + qualifiedIdentifier + punctLrb + macroInputs + punctRrb + punctColon + qualifiedIdentifier + commandBlock; macroInputs.Rule = MakeStarRule(macroInputs, punctComma, identifierDeclaration); identifierDeclaration.Rule = identifier + punctColon + qualifiedIdentifier; templatesImplementation.Rule = keywordImplement + qualifiedIdentifierList + keywordUsing + qualifiedIdentifierList; expressionOpt.Rule = Empty | expression; expression.Rule = expressionSum | gaUnaryOperation + expressionSum; expressionSum.Rule = expressionProduct | expressionSum + gaBinarySum + expressionProduct; expressionProduct.Rule = expressionAtomic | expressionProduct + gaBinaryProduct + expressionAtomic; expressionAtomic.Rule = constantNumber | qualifiedItem | expressionBracketed | expressionScoped | stringLiteral | expressionComposite | expressionFunction; expressionBracketed.Rule = punctLrb + expression + punctRrb; expressionScoped.Rule = qualifiedIdentifier + punctDot + punctAmp + expression + punctAmp; expressionFunction.Rule = qualifiedIdentifier + expressionFunctionDefaultValueOpt + punctLrb + expressionFunctionInputsOpt + punctRrb; expressionFunctionDefaultValueOpt.Rule = expressionFunctionDefaultValue | Empty; expressionFunctionDefaultValue.Rule = punctLcb + expression + punctRcb; expressionFunctionInputsOpt.Rule = Empty | expressionFunctionInputs; expressionFunctionInputs.Rule = expressionFunctionInputsExpressions | expressionFunctionInputsAssignments; expressionFunctionInputsExpressions.Rule = MakePlusRule(expressionFunctionInputsExpressions, punctComma, expression); expressionFunctionInputsAssignments.Rule = MakePlusRule(expressionFunctionInputsAssignments, punctComma, expressionFunctionInputsAssignmentsItem); expressionFunctionInputsAssignmentsItem.Rule = expressionFunctionInputsAssignmentsItemLhs + punctEqual + expression; expressionFunctionInputsAssignmentsItemLhs.Rule = qualifiedIdentifier | qualifiedBasisBladeCoefficient | basisBladeCoefficient; expressionComposite.Rule = punctLcb + keywordOutput + identifierDeclaration + commandBlockCommandsList + punctRcb; commandBlock.Rule = keywordBegin + commandBlockCommandsList + keywordEnd; commandBlockCommandsList.Rule = MakePlusRule(commandBlockCommandsList, command); command.Rule = commandDeclare | commandLet | commandReturn | commandBlock; //| Command_Output commandLet.Rule = keywordLet + commandLetLhs + punctEqual + expression; commandLetLhs.Rule = identifierDeclaration | qualifiedItem; commandDeclare.Rule = keywordDeclare + identifierDeclaration; commandReturn.Rule = keywordReturn + expression; gaUnaryOperation.Rule = gaOpPlus | gaOpMinus; gaBinarySum.Rule = gaOpPlus | gaOpMinus; gaBinaryProduct.Rule = gaOpTimes | gaOpDivide | gaOpCaret | gaOpOuterProduct | gaOpGeometricProduct | gaOpScalarProduct | gaOpLeftContractionProduct | gaOpRightContractionProduct | gaOpFatDotProduct | gaOpHestenesInnrProduct | gaOpCommutatorProduct | gaOpAntiCommutatorProduct | gaOpEuclideanGeometricProduct | gaOpEuclideanScalarProduct | gaOpEuclideanLeftContractionProduct | gaOpEuclideanRightContractionProduct | gaOpEuclideanFatDotProduct | gaOpEuclideanHestenesInnrProduct | gaOpEuclideanCommutatorProduct | gaOpEuclideanAntiCommutatorProduct; constant.Rule = keywordConstant + qualifiedIdentifier + punctEqual + expression; structure.Rule = keywordStructure + qualifiedIdentifier + punctLrb + structureMembers + punctRrb; structureMembers.Rule = MakePlusRule(structureMembers, punctComma, identifierDeclaration); transform.Rule = keywordTransform + identifier + keywordFrom + qualifiedIdentifier + keywordTo + qualifiedIdentifier + punctEqual; #endregion #region Configuration RegisterBracePair("[", "]"); RegisterBracePair("(", ")"); RegisterBracePair("{", "}"); RegisterOperators(1, Associativity.Left, gaOpPlus, gaOpMinus ); RegisterOperators(2, Associativity.Left, gaOpTimes, gaOpDivide, gaOpCaret, gaOpGeometricProduct, gaOpLeftContractionProduct, gaOpRightContractionProduct, gaOpFatDotProduct, gaOpHestenesInnrProduct, gaOpCommutatorProduct, gaOpAntiCommutatorProduct, gaOpEuclideanGeometricProduct, gaOpEuclideanScalarProduct, gaOpEuclideanLeftContractionProduct, gaOpEuclideanRightContractionProduct, gaOpEuclideanFatDotProduct, gaOpEuclideanHestenesInnrProduct, gaOpEuclideanCommutatorProduct, gaOpEuclideanAntiCommutatorProduct ); MarkPunctuation( keywordBreakpoint, keywordUsing, keywordBegin, keywordEnd, keywordDeclare, keywordCbm, keywordClass, keywordConstant, keywordEuclidean, keywordFrame, keywordGa, keywordIpm, keywordMacro, keywordNamespace, keywordOrthonormal, keywordOrthogonal, keywordReciprocal, keywordTransform, keywordLet, keywordOutput, keywordReturn, keywordStructure, keywordFrom, keywordTo, keywordOpen, keywordTemplate, keywordImplement, keywordSubspace, keywordOn, keywordAccess, keywordBind, keywordWith, keywordBinding, punctColon, punctDot, punctComma, punctEqual, punctHash, punctAt, punctAmp, punctLcb, punctRcb, punctLrb, punctRrb, punctLsb, punctRsb, punctLab, punctRab ); //this.MarkTransient( // DSL_Definition_Item, // Frame_Classes_List_opt, // Frame_Class_Constants_opt, // Macro_Inputs_opt, // Macro_Input_Type_opt, // Multivector_Expression_Atomic // ); #endregion }
public EbisterGrammar() : base(true) { // 0. Comments var commentSingleLine = new CommentTerminal("commentSingleLine", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var commentMultiLine = new CommentTerminal("commentMultiLine", "/*", "*/"); NonGrammarTerminals.Add(commentSingleLine); NonGrammarTerminals.Add(commentMultiLine); // 1. Literals and Operators var literalNumber = new NumberLiteral("number", NumberOptions.AllowSign | NumberOptions.AllowStartEndDot | NumberOptions.AllowUnderscore ); literalNumber.AddPrefix("0x", NumberOptions.Hex); literalNumber.AddPrefix("0b", NumberOptions.Binary); var literalString = new StringLiteral("string", "\"", StringOptions.AllowsAllEscapes); literalString.AddPrefix("@", StringOptions.NoEscapes | StringOptions.AllowsLineBreak | StringOptions.AllowsDoubledQuote); var identifier = new IdentifierTerminal("identifier"); var operatorPlus = ToTerm("+"); var operatorMinus = ToTerm("-"); var operatorAsterisk = ToTerm("*"); var operatorSlash = ToTerm("/"); var operatorPercent = ToTerm("%"); var operatorParenLeft = ToTerm("("); var operatorParenRight = ToTerm(")"); var operatorSemicolon = ToTerm(";"); // 2. Non-Terminals // 2.1 Statements var program = new NonTerminal("program", typeof(IronyProgramNode)); var statement = new NonTerminal("statement", typeof(IronyGroupedNode)); var statementBlock = new NonTerminal("statementBlock", typeof(IronyBlockStatementNode)); var statementExpression = new NonTerminal("statementBlock", typeof(IronyExpressionStatementNode)); var statementKeyword = new NonTerminal("statementKeyword", typeof(IronyKeywordStatementNode)); var statementRepeat = new NonTerminal("statementRepeat", typeof(IronyRepeatStatementNode)); // 2.2 Expressions var exprAddSub = new NonTerminal("exprAddSub", typeof(IronyExpressionNode)); var exprMulDiv = new NonTerminal("exprMulDiv", typeof(IronyExpressionNode)); var expr = new NonTerminal("expr", typeof(IronyExpressionNode)); var exprs = new NonTerminal("exprs", typeof(IronyExpressionsNode)); var exprParen = new NonTerminal("exprParen", typeof(IronyParenExpressionNode)); var exprUnary = new NonTerminal("exprUnary", typeof(IronyUnaryExpressionNode)); var exprCall = new NonTerminal("call", typeof(IronyCallExpressionNode)); var operatorUnary = new NonTerminal("operatorUnary", typeof(IronyUnaryOperatorNode)); // 3. BNF Definition program.Rule = MakeStarRule(program, statement); exprs.Rule = MakeStarRule(exprs, ToTerm(","), exprAddSub); statementExpression.Rule = exprAddSub + operatorSemicolon; statementBlock.Rule = ToTerm("{") + program + ToTerm("}"); statementKeyword.Rule = "break" + operatorSemicolon | "continue" + operatorSemicolon | "return" + operatorSemicolon; statementRepeat.Rule = "repeat" + statement; statement.Rule = statementExpression | statementBlock | statementKeyword | statementRepeat; exprAddSub.Rule = exprMulDiv | exprAddSub + operatorPlus + exprAddSub | exprAddSub + operatorMinus + exprAddSub; exprMulDiv.Rule = expr | exprMulDiv + operatorAsterisk + exprMulDiv | exprMulDiv + operatorSlash + exprMulDiv | exprMulDiv + operatorPercent + exprMulDiv; exprCall.Rule = expr + operatorParenLeft + exprs + operatorParenRight; expr.Rule = exprParen | exprUnary | exprCall | literalNumber | literalString | "true" | "false" | "null" | identifier; exprParen.Rule = operatorParenLeft + exprAddSub + operatorParenRight; exprUnary.Rule = operatorUnary + expr; operatorUnary.Rule = operatorPlus | operatorMinus; Root = program; LanguageFlags = LanguageFlags.CreateAst; }
public CalcGrammar() : base(true) { var comment = new CommentTerminal("comment", "//", "\n", "\r"); var blockComment = new CommentTerminal("blockComment", "/*", "*/"); NonGrammarTerminals.Add(comment); NonGrammarTerminals.Add(blockComment); NonTerminal start = new NonTerminal("start", typeof(StatementListNode)); NonTerminal block = new NonTerminal("block"); NonTerminal instructions = new NonTerminal("instructions", typeof(BlockNode)); NonTerminal instruction = new NonTerminal("instruction"); NonTerminal embeddedInstruction = new NonTerminal("embeddedInstruction"); NonTerminal ifClause = new NonTerminal("ifClause", typeof(IfNode)); NonTerminal ifElseClause = new NonTerminal("ifElseClause", typeof(IfNode)); NonTerminal forClause = new NonTerminal("forClause", typeof(ForNode)); NonTerminal forInitClause = new NonTerminal("forInit", typeof(StatementListNode)); NonTerminal forConditionClause = new NonTerminal("forCondition"); NonTerminal forIterClause = new NonTerminal("forIter", typeof(StatementListNode)); NonTerminal foreachClause = new NonTerminal("foreachClause", typeof(ForeachNode)); NonTerminal foreachVarDecl = new NonTerminal("foreachVarDecl"); NonTerminal whileClause = new NonTerminal("whileClause", typeof(WhileNode)); NonTerminal doWhileClause = new NonTerminal("doWhileClause", typeof(DoWhileNode)); NonTerminal returnClause = new NonTerminal("returnClause", typeof(ReturnNode)); NonTerminal emptyReturnClause = new NonTerminal("emptyReturnClause", typeof(ReturnNode)); NonTerminal breakClause = new NonTerminal("breakClause", typeof(BreakNode)); NonTerminal continueClause = new NonTerminal("continueClause", typeof(ContinueNode)); NonTerminal usingClause = new NonTerminal("usingClause", typeof(UsingNode)); NonTerminal usingNamespace = new NonTerminal("namespace", typeof(UsingNamespaceNode)); NonTerminal tryClause = new NonTerminal("tryClause", typeof(TryNode)); NonTerminal catchClause = new NonTerminal("catchClause", typeof(CatchNode)); NonTerminal finallyClause = new NonTerminal("finallyClause"); NonTerminal throwClause = new NonTerminal("throwClause", typeof(ThrowNode)); NonTerminal assignment = new NonTerminal("assignment", typeof(AssignmentNode)); NonTerminal assignmentOp = new NonTerminal("assignmentOp", "assignment operator"); NonTerminal varDeclaration = new NonTerminal("varDeclaration", typeof(VarDeclarationNode)); NonTerminal varDeclarationAndAssign = new NonTerminal("varDeclaration", typeof(VarDeclarationNode)); NonTerminal functionDef = new NonTerminal("functionDef", typeof(FunctionDefNode)); NonTerminal functionBody = new NonTerminal("functionBody", typeof(StatementListNode)); NonTerminal lambdaBody = new NonTerminal("lambdaBody", typeof(StatementListNode)); NonTerminal inlineFunctionDef = new NonTerminal("inlineFunctionDef", typeof(LambdaNode)); NonTerminal externFunctionDef = new NonTerminal("externFunctionDef", typeof(ExternFunctionNode)); NonTerminal paramList = new NonTerminal("paramList", typeof(ParamListNode)); NonTerminal param = new NonTerminal("param", typeof(ParamNode)); NonTerminal lambdaParamList = new NonTerminal("lambdaParamList", typeof(ParamListNode)); NonTerminal singleLambdaParamList = new NonTerminal("lambdaParamList", typeof(ParamListNode)); NonTerminal lambdaParam = new NonTerminal("lambdaParam", typeof(ParamNode)); NonTerminal paramsOrEmpty = new NonTerminal("paramsOrEmpty"); NonTerminal arrayDef = new NonTerminal("arrayDef"); NonTerminal arrayDefList = new NonTerminal("arrayDefList", typeof(ArrayDefNode)); NonTerminal arrayDefListItem = new NonTerminal("arrayDefListItem"); NonTerminal namedArrayItem = new NonTerminal("namedArrayItem", typeof(NamedArrayItemNode)); NonTerminal expr = new NonTerminal("expr"); NonTerminal prefixExpr = new NonTerminal("prefixExpr", typeof(IncDecNode)); NonTerminal postfixExpr = new NonTerminal("postfixExpr", typeof(IncDecNode)); NonTerminal binExpr = new NonTerminal("binExpr", typeof(BinaryOperationNode)); NonTerminal unExpr = new NonTerminal("unExpr", typeof(UnaryExpressionNode)); NonTerminal var = new NonTerminal("var"); NonTerminal objRef = new NonTerminal("objRef"); NonTerminal memberAccess = new NonTerminal("memberAccess", typeof(MemberAccessNode)); NonTerminal ternaryIf = new NonTerminal("ternaryIf", typeof(IfNode)); NonTerminal coalescence = new NonTerminal("coalescence", typeof(CoalescenceNode)); NonTerminal functionCall = new NonTerminal("functionCall", typeof(FunctionCallNode)); NonTerminal varList = new NonTerminal("varList", typeof(ExpressionListNode)); NonTerminal array = new NonTerminal("array"); NonTerminal singleDimArray = new NonTerminal("singleDimArray", typeof(IndexedAccessNode)); NonTerminal rangeArrayDef = new NonTerminal("rangeArrayDef", typeof(RangeArrayDefNode)); NonTerminal rangeInclusiveArrayDef = new NonTerminal("rangeInclusiveArrayDef", typeof(RangeArrayDefNode)); NonTerminal typeInfo = new NonTerminal("typeInfo"); NonTerminal typeInfoOrEmpty = new NonTerminal("typeInfoOrEmpty"); IdentifierTerminal name = new IdentifierTerminal("name", IdOptions.IsNotKeyword); IdentifierTerminal newName = new IdentifierTerminal("newName", IdOptions.IsNotKeyword); NumberLiteral number = new NumberLiteral("number", NumberOptions.AllowUnderscore); StringLiteral _string = new StringLiteral("string", "\"", StringOptions.AllowsAllEscapes); StringLiteral _char = new StringLiteral("Char", "'", StringOptions.IsChar | StringOptions.AllowsAllEscapes); NonTerminal boolVal = new NonTerminal("boolVal", typeof(BoolValNode)); NonTerminal nullVal = new NonTerminal("nullVal", typeof(NullValueNode)); NonTerminal thisVal = new NonTerminal("thisVal", typeof(ThisNode)); NonTerminal binOp = new NonTerminal("binOp", "operator"); NonTerminal unaryOp = new NonTerminal("unaryOp", "operator"); NonTerminal incDecOp = new NonTerminal("incDecOp", "operator"); NonTerminal emptyInstruction = new NonTerminal("emptyInstruction", typeof(EmptyNode)); start.Rule = MakeStarRule(start, instruction); block.Rule = "{" + instructions + "}"; instructions.Rule = MakeStarRule(instructions, instruction); instruction.Rule = block | embeddedInstruction + ";" | ifClause | ifElseClause | functionDef | externFunctionDef + ";" | returnClause + ";" | emptyReturnClause | breakClause | continueClause | forClause | foreachClause | whileClause | doWhileClause | usingClause | varDeclaration + ";" | emptyInstruction | tryClause | throwClause + ";"; emptyInstruction.Rule = ToTerm(";"); instruction.ErrorRule = SyntaxError + ";"; embeddedInstruction.Rule = functionCall | postfixExpr | prefixExpr | assignment | varDeclarationAndAssign; ifElseClause.Rule = ToTerm("if") + "(" + expr + ")" + instruction + PreferShiftHere() + "else" + instruction; ifClause.Rule = ToTerm("if") + "(" + expr + ")" + instruction; forClause.Rule = ToTerm("for") + "(" + forInitClause + ";" + forConditionClause + ";" + forIterClause + ")" + instruction; forInitClause.Rule = MakeStarRule(forInitClause, ToTerm(","), embeddedInstruction); forConditionClause.Rule = Empty | expr; forIterClause.Rule = MakeStarRule(forIterClause, ToTerm(","), embeddedInstruction); foreachClause.Rule = ToTerm("foreach") + "(" + foreachVarDecl + "in" + expr + ")" + instruction; foreachVarDecl.Rule = varDeclaration | name; whileClause.Rule = ToTerm("while") + "(" + expr + ")" + instruction; doWhileClause.Rule = ToTerm("do") + instruction + ToTerm("while") + "(" + expr + ")" + ToTerm(";"); returnClause.Rule = "return" + expr; emptyReturnClause.Rule = ToTerm("return") + ";"; breakClause.Rule = ToTerm("break") + ";"; continueClause.Rule = ToTerm("continue") + ";"; tryClause.Rule = "try" + block + (catchClause + finallyClause | finallyClause | catchClause); catchClause.Rule = "catch" + ("(" + name + ")").Q() + block; finallyClause.Rule = "finally" + block; throwClause.Rule = "throw" + expr; usingClause.Rule = ToTerm("using") + usingNamespace + ";"; usingNamespace.Rule = (name + "." + usingNamespace) | name; varDeclaration.Rule = "var" + name + typeInfoOrEmpty; varDeclarationAndAssign.Rule = "var" + name + typeInfoOrEmpty + "=" + expr; assignment.Rule = objRef + assignmentOp + expr; assignmentOp.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "|=" | "^=" | "&=" | "<<=" | ">>=" | "**="; objRef.Rule = name | array | memberAccess; memberAccess.Rule = var + PreferShiftHere() + "." + name; functionDef.Rule = "function" + name + "(" + paramList + ")" + ToTerm("extension").Q() + functionBody; functionDef.NodeCaptionTemplate = "function #{0}(...)"; inlineFunctionDef.Rule = (ToTerm("function") + "(" + paramList + ")" + functionBody) | ("(" + lambdaParamList + ")" + ToTerm("=>") + expr) | (singleLambdaParamList + "=>" + expr); externFunctionDef.Rule = ToTerm("extern") + "function" + name + "(" + paramList + ")" + ToTerm("extension").Q(); inlineFunctionDef.NodeCaptionTemplate = "function(...)"; functionBody.Rule = block | returnClause; paramList.Rule = MakeStarRule(paramList, ToTerm(","), param); lambdaParamList.Rule = MakeStarRule(lambdaParamList, ToTerm(","), lambdaParam); singleLambdaParamList.Rule = lambdaParam; lambdaParam.Rule = name + ReduceIf("=>", "+", "-", "*", "/", "%", "**", "&", "&&", "|", "||", "^", "==", "<=", ">=", "<", ">", "!=", "<<", ">>", ";", "(", "??"); param.Rule = paramsOrEmpty + name + typeInfoOrEmpty; paramsOrEmpty.Rule = ToTerm("params") | Empty; arrayDef.Rule = "{" + arrayDefList + "}"; arrayDefList.Rule = MakeStarRule(arrayDefList, ToTerm(","), arrayDefListItem); arrayDefListItem.Rule = namedArrayItem | expr; namedArrayItem.Rule = (name + ReduceHere() | _string) + "=" + expr; rangeArrayDef.Rule = expr + PreferShiftHere() + ".." + expr + ((PreferShiftHere() + ":" + expr) | Empty); rangeInclusiveArrayDef.Rule = expr + PreferShiftHere() + "..." + expr + ((PreferShiftHere() + ":" + expr) | Empty); expr.Rule = prefixExpr | postfixExpr | ternaryIf | inlineFunctionDef | var | unExpr | binExpr | arrayDef | rangeArrayDef | rangeInclusiveArrayDef | assignment | coalescence; coalescence.Rule = expr + "??" + expr; binExpr.Rule = expr + binOp + expr; binOp.Rule = ToTerm("&&") | "||" | "&" | "|" | "^" | ToTerm("==") | "<=" | ">=" | "<" | ">" | "!=" | ToTerm("+") | "-" | ToTerm("*") | "/" | "%" | "**" | ToTerm("<<") | ">>"; prefixExpr.Rule = incDecOp + objRef + ReduceHere(); postfixExpr.Rule = objRef + PreferShiftHere() + incDecOp; unExpr.Rule = unaryOp + expr + ReduceHere(); var.Rule = objRef | number | boolVal | nullVal | thisVal | _string | _char | functionCall + ReduceHere() | ("(" + expr + ")"); ternaryIf.Rule = expr + "?" + expr + ":" + expr; functionCall.Rule = var + PreferShiftHere() + "(" + varList + ")"; functionCall.NodeCaptionTemplate = "call #{0}(...)"; varList.Rule = MakeStarRule(varList, ToTerm(","), expr); array.Rule = singleDimArray; singleDimArray.Rule = var + PreferShiftHere() + "[" + expr + "]"; boolVal.Rule = ToTerm("true") | "false"; nullVal.Rule = ToTerm("null"); thisVal.Rule = ToTerm("this"); typeInfoOrEmpty.Rule = ":" + typeInfo | Empty; typeInfo.Rule = ToTerm("string") | "function" | "number" | "bool" | "table" | "char"; unaryOp.Rule = ToTerm("-") | "!" | "~"; incDecOp.Rule = ToTerm("++") | "--"; MarkPunctuation("(", ")", "?", ":", "[", "]", ";", "{", "}", ".", ",", "@", "=>", "??", "return", "if", "else", "for", "while", "break", "continue", "using", "do", "var", "foreach", "in", "try", "catch", "finally", "throw", "extern"); RegisterBracePair("(", ")"); RegisterBracePair("[", "]"); RegisterBracePair("{", "}"); RegisterOperators(10, "?"); RegisterOperators(15, "&&", "||", "&", "|", "^"); RegisterOperators(20, "==", "<", "<=", ">", ">=", "!="); RegisterOperators(25, "<<", ">>"); RegisterOperators(30, "+", "-"); RegisterOperators(40, "*", "/", "%", "**"); RegisterOperators(60, "!", "~"); RegisterOperators(70, "++", "--", "??"); MarkTransient(var, expr, binOp, unaryOp, block, instruction, embeddedInstruction, objRef, array, arrayDef, assignmentOp, arrayDefListItem, incDecOp, functionBody, lambdaBody, foreachVarDecl, paramsOrEmpty, typeInfoOrEmpty); AddTermsReportGroup("assignment", "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>="); AddTermsReportGroup("statement", "if", "while", "for", "return", "break", "continue", "using", "do", "try", "throw", "foreach"); AddTermsReportGroup("variable declaration", "var"); AddTermsReportGroup("function declaration", "function", "extern"); AddTermsReportGroup("constant", number, _string, _char); AddTermsReportGroup("constant", "null", "false", "true", "this", "@"); AddTermsReportGroup("unary operator", "+", "-", "!"); AddTermsReportGroup("operator", "+", "-", "*", "/", "%", "**", "&", "&&", "|", "||", "^", "?", "==", "<=", "<", ">=", ">", "!=", "<<", ">>", "??", ".."); AddToNoReportGroup("(", "[", "{", ".", ",", "++", "--"); MarkReservedWords("if", "else", "return", "function", "while", "for", "null", "false", "true", "this", "break", "continue", "using", "do", "var", "foreach", "in", "params", "try", "catch", "finally", "throw", "extern"); number.DefaultFloatType = TypeCode.Double; number.DefaultIntTypes = new TypeCode[] { TypeCode.Int64 }; number.AddPrefix("0x", NumberOptions.Hex); number.AddPrefix("0b", NumberOptions.Binary); number.AddSuffix("d", TypeCode.Double); number.AddSuffix("l", TypeCode.Int64); number.AddSuffix("m", TypeCode.Decimal); _string.AddPrefix("@", StringOptions.NoEscapes); _string.AddPrefix("$", StringOptions.IsTemplate | StringOptions.AllowsAllEscapes); var stringTemplateSettings = new StringTemplateSettings(); stringTemplateSettings.StartTag = "{"; stringTemplateSettings.EndTag = "}"; stringTemplateSettings.ExpressionRoot = expr; this.SnippetRoots.Add(expr); _string.AstConfig.NodeType = typeof(StringTemplateNode); _string.AstConfig.Data = stringTemplateSettings; this.Root = start; this.LanguageFlags = LanguageFlags.CreateAst; }
public TextExpressionDslGrammar() { #region Terminals //Double quoted string var dqString = new StringLiteral(TextExpressionDslParseNodeNames.DqString, "\"", StringOptions.AllowsAllEscapes); dqString.AddPrefix("@", StringOptions.NoEscapes | StringOptions.AllowsLineBreak | StringOptions.AllowsDoubledQuote); //Single quoted string var sqString = new StringLiteral(TextExpressionDslParseNodeNames.SqString, "'", StringOptions.AllowsAllEscapes); sqString.AddPrefix("@", StringOptions.NoEscapes | StringOptions.AllowsLineBreak | StringOptions.AllowsDoubledQuote); var identifier = new IdentifierTerminal(TextExpressionDslParseNodeNames.Identifier); var literalNumber = new NumberLiteral(TextExpressionDslParseNodeNames.LiteralNumber, NumberOptions.AllowSign); var punctColon = ToTerm(":"); var punctDot = ToTerm("."); var punctComma = ToTerm(","); var punctLsb = ToTerm("["); var punctRsb = ToTerm("]"); var punctLcb = ToTerm("{"); var punctRcb = ToTerm("}"); #endregion #region Non-Terminals var ntExpression = new NonTerminal(TextExpressionDslParseNodeNames.Expression); var ntQualifiedIdentifier = new NonTerminal(TextExpressionDslParseNodeNames.QualifiedIdentifier); var ntExpressionName = new NonTerminal(TextExpressionDslParseNodeNames.ExpressionName); var ntList = new NonTerminal(TextExpressionDslParseNodeNames.List); var ntListArgs = new NonTerminal(TextExpressionDslParseNodeNames.ListArgs); var ntDictionary = new NonTerminal(TextExpressionDslParseNodeNames.Dictionary); var ntDictionaryArgs = new NonTerminal(TextExpressionDslParseNodeNames.DictionaryArgs); var ntDictionaryArg = new NonTerminal(TextExpressionDslParseNodeNames.DictionaryArg); #endregion #region Rules //Set root of grammar Root = ntExpression; ntExpression.Rule = ntQualifiedIdentifier | dqString | sqString | literalNumber | ntList | ntDictionary; ntQualifiedIdentifier.Rule = MakePlusRule(ntQualifiedIdentifier, punctDot, identifier); ntList.Rule = ntExpressionName + punctLsb + ntListArgs + punctRsb; ntExpressionName.Rule = Empty | ntQualifiedIdentifier; ntListArgs.Rule = MakeStarRule(ntListArgs, punctComma, ntExpression); ntDictionary.Rule = ntExpressionName + punctLcb + ntDictionaryArgs + punctRcb; ntDictionaryArgs.Rule = MakeStarRule(ntDictionaryArgs, punctComma, ntDictionaryArg); ntDictionaryArg.Rule = ntQualifiedIdentifier + punctColon + ntExpression; #endregion #region Configuration RegisterBracePair("[", "]"); RegisterBracePair("{", "}"); MarkPunctuation( punctColon, punctDot, punctComma, punctLsb, punctRsb, punctLcb, punctRcb ); #endregion }