public static string Build(bool generateImplementation)
{
var ID = id("Developer.LanguageServices.NativeX.NativeXTokenizer.IdToken");
var TYPE_KEYWORD = id("Developer.LanguageServices.NativeX.NativeXTokenizer.TypeKeywordToken");
var STRING = id("Developer.LanguageServices.NativeX.NativeXTokenizer.StringToken");
var NUMBER = id("Developer.LanguageServices.NativeX.NativeXTokenizer.NumberToken");
var ATTID = id("Developer.LanguageServices.NativeX.NativeXTokenizer.AttributeToken");
var REFERENCE_TYPE = rule <NativeXReferenceType>("ReferenceType");
var FUNCTION_TYPE = rule <NativeXFunctionType>("FunctionType");
var INSTANCIATED_TYPE = rule <NativeXInstanciatedType>("InstanciatedType");
var PRIMITIVE_TYPE = rule <NativeXType>("PrimitiveType");
var TYPEOFE = rule <NativeXTypeofExpressionType>("TypeofExpression");
var TYPEOFM = rule <NativeXTypeofMemberType>("TypeofMember");
var TYPE = rule <NativeXType>("Type");
var STRICT_INSTANCE_FUNCTION_REFERENCE = rule <NativeXInstanceFunctionExpression>("StrictInstanceFunctionReference");
var STRICT_INSTANCIATED_REFERENCE = rule <NativeXInstanciatedExpression>("StrictInstanciatedReference");
var STRICT_IDENTIFIER_REFERENCE = rule <NativeXReferenceExpression>("StrictIdentifierReference");
var STRICT_REFERENCE = rule <NativeXExpression>("StrictReference");
var PRIMITIVE = rule <NativeXPrimitiveExpression>("Primitive");
var INSTANCE_FUNCTION_REFERENCE = rule <NativeXInstanceFunctionExpression>("InstanceFunctionReference");
var INSTANCIATED_REFERENCE = rule <NativeXInstanciatedExpression>("InstanciatedReference");
var IDENTIFIER_REFERENCE = rule <NativeXReferenceExpression>("IdentifierReference");
var REFERENCE = rule <NativeXExpression>("Reference");
var RESULT = rule <NativeXFunctionResultExpression>("Result");
var EXCEPTION = rule <NativeXExceptionExpression>("Exception");
var CAST = rule <NativeXCastingExpression>("Casting");
var SIZEOF = rule <NativeXSizeofTypeExpression>("SizeofType");
var OFFSETOF = rule <NativeXOffsetofMemberExpression>("OffsetofMember");
var EXP0 = rule <NativeXExpression>("EXP0");
var EXP1 = rule <NativeXExpression>("EXP1");
var UNARY = rule <NativeXUnaryExpression>("Unary");
var EXP2 = rule <NativeXExpression>("EXP2");
var EXP_BINS = Enumerable.Range(3, 11).Select(i => rule <NativeXExpression>("EXP" + i.ToString())).ToArray();
var EXPRESSION = rule <NativeXExpression>("Expression");
var EMPTY_STATEMENT = rule <NativeXEmptyStatement>("EmptyStatement");
var EXPRESSION_STATEMENT = rule <NativeXExpressionStatement>("ExpressionStatement");
var VARIABLE_STATEMENT = rule <NativeXVariableStatement>("VariableStatement");
var IF_STATEMENT = rule <NativeXIfStatement>("IfStatement");
var BREAK_STATEMENT = rule <NativeXBreakStatement>("BreakStatement");
var CONTINUE_STATEMENT = rule <NativeXContinueStatement>("ContinueStatement");
var EXIT_STATEMENT = rule <NativeXReturnStatement>("ExitStatement");
var COMPOSITE_STATEMENT = rule <NativeXCompositeStatement>("CompositeStatement");
var DO_WHILE_STATEMENT = rule <NativeXWhileStatement>("DoWhileStatement");
var LOOP_STATEMENT = rule <NativeXWhileStatement>("LoopStatement");
var WHILE_DO_STATEMENT = rule <NativeXWhileStatement>("WhileDoStatement");
var FOR_STATEMENT = rule <NativeXForStatement>("ForStatement");
var TRY_CATCH_STATEMENT = rule <NativeXTryCatchStatement>("TryCatchStatement");
var THROW_STATEMENT = rule <NativeXThrowStatement>("ThrowStatement");
var STATEMENT = rule <NativeXStatement>("Statement");
var FUNCTION_PARAMETER = rule <NativeXNameTypePair>("FunctionParameterItem");
var STRUCTURE_MEMBER = rule <NativeXNameTypePair>("StructureMemberItem");
var INSTANCE_FUNCTION = rule <NativeXNameExpressionPair>("InstanceFunctionItem");
var CONCEPT_FUNCTION = rule <NativeXNameTypePair>("ConceptFunctionItem");
var GENERIC_PARAMETER = rule <NativeXGenericParameter>("GenericParameterItem");
var GENERIC_CONSTRAINT = rule <NativeXGenericConstraint>("GenericConstraintItem");
var LINKING = rule <NativeXLinking>("Linking");
var FUNCTION_DECLARATION = rule <NativeXFunctionDeclaration>("FunctionDeclaration");
var TYPE_RENAME_DECLARATION = rule <NativeXTypeRenameDeclaration>("TypeRenameDeclaration");
var VARIABLE_DECLARATION = rule <NativeXVariableDeclaration>("VariableDeclaration");
var STRUCTURE_DECLARATION = rule <NativeXStructureDeclaration>("StructureDeclaration");
var INSTANCE_DECLARATION = rule <NativeXInstanceDeclaration>("InstanceDeclaration");
var CONCEPT_DECLARATION = rule <NativeXConceptDeclaration>("ConceptDeclaration");
var GENERIC_DECLARATION = rule <NativeXDeclaration>("GenericDeclaration");
var NON_GENERIC_DECLARATION = rule <NativeXDeclaration>("NonGenericDeclaration");
var DECLARATION_CANDIDATE = rule <NativeXDeclaration>("DeclarationCandidate");
var ATTRIBUTE = rule <NativeXAttribute>("Attribute");
var DECLARATION = rule <NativeXDeclaration>("Declaration");
var USE = rule <NativeXUses>("UseUnitItem");
var UNIT = rule <NativeXUnit>("Unit");
var CONCEPT_REFERENCE = rule <NativeXConceptReference>("ConceptReference");
var EDITING_DECLARATION = rule <NativeXEditingDeclarations>("EditingDeclarations");
{
USE.Infer(
ID["UnitName"]
);
UNIT.Infer(
opt(!tok("unit") + ID["Name"] + tok(";"))
+ opt(!tok("uses") + list <NativeXUses>(tok(","), USE)["UsesUnits"] + tok(";"))
+ list_hard <NativeXDeclaration>(DECLARATION)["Declarations"]
);
CONCEPT_REFERENCE.Infer(
ID["ReferenceName"]
);
EDITING_DECLARATION.Infer(
list_hard <NativeXDeclaration>(DECLARATION)["Declarations"]
);
}
{
FUNCTION_PARAMETER.Infer(
!TYPE["Type"] + ID["Name"]
);
STRUCTURE_MEMBER.Infer(
!TYPE["Type"] + ID["Name"] + tok(";")
);
INSTANCE_FUNCTION.Infer(
!ID["Name"] + tok("=") + STRICT_REFERENCE["Expression"] + tok(";")
);
CONCEPT_FUNCTION.Infer(
!ID["Name"] + tok("=") + TYPE["Type"] + tok(";")
);
GENERIC_PARAMETER.Infer(
!ID["ParameterName"]
);
GENERIC_CONSTRAINT.Infer(
!ID["ParameterName"] + tok(":") + CONCEPT_REFERENCE["ConceptName"]
);
LINKING.Infer(
!tok("alias") + ID["LinkingAssembly"] + tok(".") + ID["LinkingSymbol"]
);
}
{
FUNCTION_DECLARATION.Infer(
opt(tok("foreign")["Foreign", "true"])
+ !tok("function") + TYPE["ReturnType"] + ID["Name"] + tok("(") + list <NativeXNameTypePair>(tok(","), FUNCTION_PARAMETER)["Parameters"] + tok(")")
+ opt(LINKING["Linking"])
+ (tok(";") | STATEMENT["Statement"])
);
VARIABLE_DECLARATION.Infer(
!tok("variable") + TYPE["Type"] + ID["Name"] + opt(LINKING["Linking"]) + opt(!tok("=") + EXPRESSION["Initializer"]) + tok(";")
);
TYPE_RENAME_DECLARATION.Infer(
!tok("type") + ID["Name"] + tok("=") + TYPE["Type"] + tok(";")
);
STRUCTURE_DECLARATION.Infer(
!tok("structure") + ID["Name"]
+ (
tok(";")
| (
opt(LINKING["Linking"]) + !tok("{") + list <NativeXNameTypePair>(STRUCTURE_MEMBER, "}")["Members"] + tok("}")
)
)
);
INSTANCE_DECLARATION.Infer(
!tok("instance") + REFERENCE_TYPE["Type"] + tok(":") + CONCEPT_REFERENCE["ConceptName"]
+ (
tok(";")
| (
!tok("{") + list <NativeXNameExpressionPair>(INSTANCE_FUNCTION, "}")["Functions"] + tok("}")
)
)
);
CONCEPT_DECLARATION.Infer(
!tok("concept") + GENERIC_PARAMETER["ConceptType"] + tok(":") + ID["Name"] + opt(LINKING["Linking"]) + tok("{") + list <NativeXNameTypePair>(CONCEPT_FUNCTION, "}")["Functions"] + tok("}")
);
}
{
DECLARATION_CANDIDATE.Infer(
ret(FUNCTION_DECLARATION)
| ret(TYPE_RENAME_DECLARATION)
| ret(VARIABLE_DECLARATION)
| ret(STRUCTURE_DECLARATION)
| ret(INSTANCE_DECLARATION)
| ret(CONCEPT_DECLARATION)
);
NON_GENERIC_DECLARATION.Infer(
list <NativeXAttribute>(ATTRIBUTE)["Attributes"] + ret(DECLARATION_CANDIDATE)
);
GENERIC_DECLARATION.Infer(
!tok("generic") + tok("<") + list <NativeXGenericParameter>(tok(","), GENERIC_PARAMETER)["GenericParameters"] + tok(">")
+ opt(!tok("where") + list <NativeXGenericConstraint>(tok(","), GENERIC_CONSTRAINT)["GenericConstraints"])
+ ret(NON_GENERIC_DECLARATION)
);
ATTRIBUTE.Infer(
ATTID["Name"]
);
DECLARATION.Infer(
ret(GENERIC_DECLARATION) | ret(NON_GENERIC_DECLARATION)
);
}
{
EMPTY_STATEMENT.Infer(
tok(";")
);
EXPRESSION_STATEMENT.Infer(
!EXPRESSION["Expression"] + tok(";")
);
VARIABLE_STATEMENT.Infer(
!tok("variable") + TYPE["Type"] + ID["Name"] + opt(!tok("=") + EXPRESSION["Initializer"]) + tok(";")
);
IF_STATEMENT.Infer(
!tok("if") + tok("(") + EXPRESSION["Condition"] + tok(")") + STATEMENT["TrueStatement"] + opt(!tok("else") + STATEMENT["FalseStatement"])
);
BREAK_STATEMENT.Infer(
!tok("break") + tok(";")
);
CONTINUE_STATEMENT.Infer(
!tok("continue") + tok(";")
);
EXIT_STATEMENT.Infer(
!tok("exit") + tok(";")
);
COMPOSITE_STATEMENT.Infer(
!tok("{") + list <NativeXStatement>(STATEMENT, "}")["Statements"] + tok("}")
);
DO_WHILE_STATEMENT.Infer(
!tok("do") + STATEMENT["Statement"] + tok("while") + tok("(") + EXPRESSION["EndCondition"] + tok(")") + tok(";")
);
LOOP_STATEMENT.Infer(
!tok("loop") + STATEMENT["Statement"]
);
WHILE_DO_STATEMENT.Infer(
!tok("while") + tok("(") + EXPRESSION["BeginCondition"] + tok(")") + STATEMENT["Statement"] + opt(!tok("when") + tok("(") + EXPRESSION["EndCondition"] + tok(")") + tok(";"))
);
FOR_STATEMENT.Infer(
!tok("for") + tok("(") + list <NativeXStatement>(STATEMENT)["Initializer"]
+ tok("when") + tok("(") + EXPRESSION["Condition"] + tok(")")
+ tok("with") + list <NativeXStatement>(STATEMENT)["SideEffect"]
+ tok(")") + tok("do") + STATEMENT["Statement"]
);
TRY_CATCH_STATEMENT.Infer(
!tok("try") + STATEMENT["TryStatement"] + tok("catch") + STATEMENT["CatchStatement"]
);
THROW_STATEMENT.Infer(
!tok("throw") + opt(EXPRESSION["ExceptionExpression"]) + tok(";")
);
STATEMENT.Infer(
ret(EMPTY_STATEMENT)
| ret(VARIABLE_STATEMENT)
| ret(IF_STATEMENT)
| ret(BREAK_STATEMENT)
| ret(CONTINUE_STATEMENT)
| ret(EXIT_STATEMENT)
| ret(COMPOSITE_STATEMENT)
| ret(DO_WHILE_STATEMENT)
| ret(LOOP_STATEMENT)
| ret(WHILE_DO_STATEMENT)
| ret(FOR_STATEMENT)
| ret(TRY_CATCH_STATEMENT)
| ret(THROW_STATEMENT)
| ret(EXPRESSION_STATEMENT)
);
}
{
STRICT_INSTANCE_FUNCTION_REFERENCE.Infer(
CONCEPT_REFERENCE["ConceptName"] + tok("<") + TYPE["Type"] + tok(">") + !tok(":") + tok(":") + ID["FunctionName"]
);
STRICT_INSTANCIATED_REFERENCE.Infer(
ID["ReferencedName"] + !tok("<") + list <NativeXType>(tok(","), TYPE)["GenericArguments"] + tok(">")
);
STRICT_IDENTIFIER_REFERENCE.Infer(
!ID["ReferencedName"]
);
STRICT_REFERENCE.Infer(
ret(STRICT_INSTANCE_FUNCTION_REFERENCE) | ret(STRICT_INSTANCIATED_REFERENCE) | ret(STRICT_IDENTIFIER_REFERENCE)
);
}
{
INSTANCE_FUNCTION_REFERENCE.Infer(
CONCEPT_REFERENCE["ConceptName"] + tok("<") + TYPE["Type"] + tok(">") + !tok(":") + tok(":") + ID["FunctionName"]
);
INSTANCIATED_REFERENCE.Infer(
ID["ReferencedName"] + tok("<") + list <NativeXType>(tok(","), TYPE)["GenericArguments"] + tok(">")
);
IDENTIFIER_REFERENCE.Infer(
!ID["ReferencedName"]
);
REFERENCE.Infer(
ret(INSTANCE_FUNCTION_REFERENCE) | ret(INSTANCIATED_REFERENCE) | ret(IDENTIFIER_REFERENCE)
);
PRIMITIVE.Infer(
STRING["Code"] | NUMBER["Code"] | toks("true", "false", "null")["Code"]
);
RESULT.Infer(
!tok("result")
);
EXCEPTION.Infer(
!tok("exception")
);
CAST.Infer(
!tok("cast") + tok("<") + TYPE["Type"] + tok(">") + tok("(") + EXPRESSION["Operand"] + tok(")")
);
SIZEOF.Infer(
!tok("sizeof") + tok("(") + TYPE["Type"] + tok(")")
);
OFFSETOF.Infer(
!tok("offsetof") + tok("(") + TYPE["Type"] + tok(":") + tok(":") + ID["MemberName"] + tok(")")
);
EXP0.Infer(
ret(SIZEOF) | ret(OFFSETOF) | ret(RESULT) | ret(EXCEPTION) | ret(CAST) | ret(PRIMITIVE) | ret(REFERENCE) | !tok("(") + ret(EXPRESSION) + tok(")")
);
EXP1.Infer(
ret(leftrecg(
EXP0,
g <NativeXSubscribeExpression>("Operand", !tok("[") + EXPRESSION["Subscribe"] + tok("]")),
g <NativeXInvokeExpression>("Function", !tok("(") + list <NativeXExpression>(tok(","), EXPRESSION)["Arguments"] + tok(")")),
g <NativeXMemberExpression>("Operand", !tok(".") + ID["MemberName"]),
g <NativeXPointerMemberExpression>("Operand", !tok("->") + ID["MemberName"]),
g <NativeXPostUnaryExpression>("Operand", !toks("++", "--")["Operator"])
))
);
UNARY.Infer(
((!toks("++", "--", "&", "*", "-", "!", "~")["Operator"])) + EXP2["Operand"]
);
EXP2.Infer(
ret(EXP1) | ret(UNARY)
);
{
string[][] binaryOperators = new string[][] {
new string[] { "*", "/", "%" },
new string[] { "+", "-" },
new string[] { "<<", ">>" },
new string[] { "<", "<=", ">", ">=" },
new string[] { "==", "!=" },
new string[] { "&" },
new string[] { "^" },
new string[] { "|" },
new string[] { "&&" },
new string[] { "||" },
new string[] { "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "/=", "&&=", "||=", "=" }
};
ParserNode shiftNode = (tok("<") + !tok("<"))["Operator", "\"<<\""] | (tok(">") + !tok(">"))["Operator", "\">>\""];
ParserNode[] operatorNodes = binaryOperators
.Select(ops => ops.First() == "<<" ? shiftNode : !toks(ops)["Operator"])
.ToArray();
ParserNode[] previousNode = new ParserNode[] { EXP2 }
.Concat(EXP_BINS.Take(EXP_BINS.Length - 1))
.ToArray();
for (int i = 0; i < EXP_BINS.Length; i++)
{
EXP_BINS[i].Infer(
ret(leftrec <NativeXBinaryExpression>(previousNode[i]["LeftOperand"], operatorNodes[i] + previousNode[i]["RightOperand"]))
);
}
}
EXPRESSION.Infer(
ret(EXP_BINS.Last())
);
}
{
REFERENCE_TYPE.Infer(
(ID["ReferencedName"] | TYPE_KEYWORD["ReferencedName"])
);
FUNCTION_TYPE.Infer(
!tok("function") + TYPE["ReturnType"] + tok("(") + list <NativeXType>(tok(","), TYPE)["Parameters"] + tok(")")
);
INSTANCIATED_TYPE.Infer(
REFERENCE_TYPE["ElementType"] + !tok("<") + list <NativeXType>(tok(","), TYPE)["GenericArguments"] + tok(">")
);
TYPEOFM.Infer(
tok("typeof") + tok("(") + TYPE["Type"] + !tok(":") + tok(":") + ID["MemberName"] + tok(")")
);
TYPEOFE.Infer(
!tok("typeof") + tok("(") + EXPRESSION["Expression"] + tok(")")
);
PRIMITIVE_TYPE.Infer(
ret(TYPEOFM) | ret(TYPEOFE) | ret(FUNCTION_TYPE) | ret(INSTANCIATED_TYPE) | ret(REFERENCE_TYPE)
);
TYPE.Infer(
ret(leftrecg(
PRIMITIVE_TYPE,
g <NativeXPointerType>("ElementType", tok("*")),
g <NativeXArrayType>("ElementType", !tok("[") + PRIMITIVE["Size"] + tok("]"))
))
);
}
if (generateImplementation)
{
return(ParserGenerator.GenerateCSharpCode("Developer.LanguageServices.NativeX", "NativeXCodeParser", UNIT, EDITING_DECLARATION));
}
else
{
return(ParserGenerator.GenerateCSharpCodeWithoutImplementation("Developer.LanguageServices.NativeX", "NativeXCodeParser", UNIT, EDITING_DECLARATION));
}
}