internal BnfTerms(TerminalFactoryS TerminalFactoryS)
{
this.OBJECT_BEGIN = TerminalFactoryS.CreateKeyTerm("{");
this.OBJECT_END = TerminalFactoryS.CreateKeyTerm("}");
this.ARRAY_BEGIN = TerminalFactoryS.CreateKeyTerm("[");
this.ARRAY_END = TerminalFactoryS.CreateKeyTerm("]");
this.COMMA = TerminalFactoryS.CreateKeyTerm(",");
this.COLON = TerminalFactoryS.CreateKeyTerm(":");
this.NUMBER = TerminalFactoryS.CreateNumberLiteral();
this.STRING = TerminalFactoryS.CreateStringLiteral(name: "stringliteral", startEndSymbol: "\"");
this.BOOLEAN = new BnfiTermConstant <bool>()
{
{ "true", true },
{ "false", false }
};
this.NULL = new BnfiTermConstantTL()
{
{ "null", (object)null }
};
}
public UDLGrammar()
: base(AstCreation.CreateAst, EmptyCollectionHandling.ReturnNull, ErrorHandling.ThrowException)
{
var group = new BnfiTermType<Group>();
var namespace_usage = new BnfiTermType<NamespaceUsing>();
var @namespace = new BnfiTermType<Namespace>();
var definitions = new BnfiTermCollection<List<Definition>, Definition>();
var definition = new BnfiTermChoice<Definition>();
var quantity_definition = new BnfiTermType<QuantityDefinition>();
var prefix_definition = new BnfiTermType<PrefixDefinition>();
var unit_definition = new BnfiTermType<UnitDefinition>();
var conversions = new BnfiTermCollection<List<Conversion>, Conversion>();
var conversion = new BnfiTermChoice<Conversion>();
var simple_conversion = new BnfiTermType<SimpleConversion>();
var complex_conversion = new BnfiTermChoice<ComplexConversion>();
var complex_conversion_without_equal = new BnfiTermType<ComplexConversion>("complex_conversion_without_equal");
var complex_conversion_with_equal = new BnfiTermType<ComplexConversion>("complex_conversion_with_equal");
var simple_conversion_op = new BnfiTermChoice<Direction>("simple_conversion_op");
var complex_conversion_op = new BnfiTermChoice<Direction>("complex_conversion_op");
var unit_expression = new BnfiTermChoice<UnitExpression>();
var binary_unit_expression = new BnfiTermType<UnitExpression.Binary>();
var square_unit_expression = new BnfiTermType<UnitExpression.Square>();
var cube_unit_expression = new BnfiTermType<UnitExpression.Cube>();
var recip_unit_expression = new BnfiTermType<UnitExpression.Recip>();
var unit_unit_expression = new BnfiTermType<UnitExpression.Unit>();
var expression = new BnfiTermChoice<Expression>();
var binary_expression = new BnfiTermType<Expression.Binary>();
var number_expression = new BnfiTermType<Expression.Number>();
var unary_expression = new BnfiTermType<Expression.Unary>();
var expression_with_unit = new BnfiTermChoice<ExpressionWithUnit>();
var binary_expression_with_unit = new BnfiTermType<ExpressionWithUnit.Binary>();
var binary_expression_with_unit2 = new BnfiTermType<ExpressionWithUnit.Binary2>();
var unary_expression_with_unit = new BnfiTermType<ExpressionWithUnit.Unary>();
var unit_variable_expression_with_unit = new BnfiTermType<ExpressionWithUnit.Unit>();
var binary_operator = new BnfiTermChoice<BinaryOperator>();
var unit_expression_binary_operator = new BnfiTermChoice<UnitExpression.Binary.Operator>();
var unary_operator = new BnfiTermChoice<UnaryOperator>();
var external_variable = new BnfiTermType<Expression.ExternalVariable>();
var SIMPLE_MUTUAL_CONVERSION_OP = ToTerm("<=>", Direction.BiDir);
var SIMPLE_TO_THIS_CONVERSION_OP = ToTerm("<=", Direction.From);
var SIMPLE_TO_THAT_CONVERSION_OP = ToTerm("=>", Direction.To);
var COMPLEX_MUTUAL_CONVERSION_OP = ToTerm("<:>", Direction.BiDir);
var COMPLEX_TO_THIS_CONVERSION_OP = ToTerm("<:", Direction.From);
var COMPLEX_TO_THAT_CONVERSION_OP = ToTerm(":>", Direction.To);
var POS_OP = ToTerm("+", UnaryOperator.Pos);
var NEG_OP = ToTerm("-", UnaryOperator.Neg);
var ADD_OP = ToTerm("+", BinaryOperator.Add);
var SUB_OP = ToTerm("-", BinaryOperator.Sub);
var MUL_OP = ToTerm("*", BinaryOperator.Mul);
var DIV_OP = ToTerm("/", BinaryOperator.Div);
var POW_OP = ToTerm("^", BinaryOperator.Pow);
var USE = ToTerm("use");
var DECLARE = ToTerm("declare");
var DEFINE = ToTerm("define");
var PREFIX = ToTerm("prefix");
var NAMESPACE = ToTerm("namespace");
var QUANTITY = ToTerm("quantity");
var UNIT = ToTerm("unit");
var OF = ToTerm("of");
var EXTERNAL_VARIABLE_PREFIX = ToTerm("::");
var EQUAL_STATEMENT = ToTerm("=");
var DOT = ToTerm(".");
var LEFT_PAREN = ToPunctuation("(");
var RIGHT_PAREN = ToPunctuation(")");
var LEFT_BRACKET = ToPunctuation("[");
var RIGHT_BRACKET = ToPunctuation("]");
var NUMBER = CreateNumberLiteral();
var IDENTIFIER = CreateIdentifier();
var qualified_identifier = new BnfiTermValue<string>();
var name = new BnfiTermType<Name>();
var namespace_name = new BnfiTermType<Name>("namespace_name");
var nameref = new BnfiTermValue<NameRef>();
var quantity_reference = new BnfiTermValue<Reference<QuantityDefinition>>();
var unit_reference = new BnfiTermValue<Reference<UnitDefinition>>();
var CONSTANT = new BnfiTermConstant<Expression.Constant>()
{
{ "PI", Constants.PI },
{ "π", Constants.PI }
};
RegisterOperators(20, ADD_OP, SUB_OP);
RegisterOperators(30, MUL_OP, DIV_OP);
RegisterOperators(40, NEG_OP, POS_OP);
RegisterOperators(50, Associativity.Right, POW_OP);
RegisterBracePair(LEFT_PAREN, RIGHT_PAREN);
RegisterBracePair(LEFT_BRACKET, RIGHT_BRACKET);
#region Rules
this.Root = group;
group.Rule =
namespace_usage.StarList().BindMember(group, t => t.NamespaceUsings)
+ @namespace.PlusList().BindMember(group, t => t.Namespaces)
;
namespace_usage.Rule =
USE
+ NAMESPACE
+ nameref.BindMember(namespace_usage, t => t.NameRef)
;
@namespace.Rule =
DECLARE
+ NAMESPACE
+ namespace_name.BindMember(@namespace, t => t.Name)
+ definitions.BindMember(@namespace, t => t.Definitions)
;
definitions.Rule = definition.PlusList();
definition.SetRuleOr(
prefix_definition,
quantity_definition,
unit_definition
);
prefix_definition.Rule =
DEFINE
+ PREFIX
+ name.BindMember(prefix_definition, t => t.Name)
+ expression.BindMember(prefix_definition, t => t.Factor)
;
quantity_definition.Rule =
DEFINE
+ QUANTITY
+ name.BindMember(quantity_definition, t => t.Name)
;
unit_definition.Rule =
DEFINE + UNIT
+ name.BindMember(unit_definition, t => t.Name)
+ OF
+ quantity_reference.BindMember(unit_definition, t => t.Quantity)
+ conversions.BindMember(unit_definition, t => t.Conversions)
;
conversions.Rule = conversion.StarList();
conversion.SetRuleOr(
simple_conversion,
complex_conversion
);
simple_conversion.Rule =
simple_conversion_op.BindMember(simple_conversion, t => t.Direction)
+ expression.BindMember(simple_conversion, t => t.Factor)
+ unit_expression.BindMember(simple_conversion, t => t.OtherUnit)
|
simple_conversion_op.BindMember(simple_conversion, t => t.Direction)
+ unit_expression.BindMember(simple_conversion, t => t.OtherUnit)
;
complex_conversion.Rule = complex_conversion_with_equal | complex_conversion_without_equal;
complex_conversion_without_equal.Rule =
complex_conversion_op.BindMember(complex_conversion, t => t.Direction)
+ expression_with_unit.BindMember(complex_conversion, t => t.Expr)
;
complex_conversion_with_equal.Rule =
complex_conversion_without_equal.Copy()
+ PreferShiftHere()
+ EQUAL_STATEMENT
+ unit_variable_expression_with_unit.ConvertValue(unit_variable => unit_variable.Value, _unit_expression => new ExpressionWithUnit.Unit { Value = _unit_expression }).BindMember(complex_conversion, t => t.OtherUnit)
;
unit_expression.SetRuleOr(
binary_unit_expression,
square_unit_expression,
cube_unit_expression,
recip_unit_expression,
unit_unit_expression,
LEFT_PAREN + unit_expression + RIGHT_PAREN
);
binary_unit_expression.Rule =
unit_expression.BindMember(binary_unit_expression, t => t.Term1)
+ unit_expression_binary_operator.BindMember(binary_unit_expression, t => t.Op)
+ unit_expression.BindMember(binary_unit_expression, t => t.Term2);
square_unit_expression.Rule =
unit_expression.BindMember(square_unit_expression, t => t.Base)
+ POW_OP.NoAst()
+ ToTerm("2");
cube_unit_expression.Rule =
unit_expression.BindMember(cube_unit_expression, t => t.Base)
+ POW_OP.NoAst()
+ ToTerm("3");
recip_unit_expression.Rule =
ToTerm("1")
+ DIV_OP.NoAst()
+ unit_expression.BindMember(recip_unit_expression, t => t.Denominator);
unit_unit_expression.Rule = unit_reference.BindMember(unit_unit_expression, t => t.Value);
simple_conversion_op.Rule = SIMPLE_MUTUAL_CONVERSION_OP | SIMPLE_TO_THAT_CONVERSION_OP | SIMPLE_TO_THIS_CONVERSION_OP;
complex_conversion_op.Rule = COMPLEX_MUTUAL_CONVERSION_OP | COMPLEX_TO_THAT_CONVERSION_OP | COMPLEX_TO_THIS_CONVERSION_OP;
binary_operator.Rule = ADD_OP | SUB_OP | MUL_OP | DIV_OP | POW_OP;
unit_expression_binary_operator.SetRuleOr(
MUL_OP.Cast(unit_expression_binary_operator),
DIV_OP.Cast(unit_expression_binary_operator)
);
unary_operator.Rule = NEG_OP | POS_OP;
expression.SetRuleOr(
number_expression,
CONSTANT,
external_variable,
binary_expression,
unary_expression,
LEFT_PAREN + expression + RIGHT_PAREN
);
number_expression.Rule = NUMBER.BindMember(number_expression, t => t.Value);
binary_expression.Rule =
expression.BindMember(binary_expression, t => t.Term1)
+ binary_operator.BindMember(binary_expression, t => t.Op)
+ expression.BindMember(binary_expression, t => t.Term2);
unary_expression.Rule = unary_operator.BindMember(unary_expression, t => t.Op)
+ expression.BindMember(unary_expression, t => t.Term);
external_variable.Rule =
EXTERNAL_VARIABLE_PREFIX
+ nameref.BindMember(external_variable, t => t.NameRef);
expression_with_unit.SetRuleOr(
unit_variable_expression_with_unit,
binary_expression_with_unit,
binary_expression_with_unit2,
unary_expression_with_unit,
LEFT_PAREN + expression_with_unit + RIGHT_PAREN
);
binary_expression_with_unit.Rule =
expression_with_unit.BindMember(binary_expression_with_unit, t => t.Term1)
+ binary_operator.BindMember(binary_expression_with_unit, t => t.Op)
+ expression.BindMember(binary_expression_with_unit, t => t.Term2);
binary_expression_with_unit2.Rule =
expression.BindMember(binary_expression_with_unit2, t => t.Term1)
+ binary_operator.BindMember(binary_expression_with_unit2, t => t.Op)
+ expression_with_unit.BindMember(binary_expression_with_unit2, t => t.Term2);
unary_expression_with_unit.Rule =
unary_operator.BindMember(unary_expression_with_unit, t => t.Op)
+ expression_with_unit.BindMember(unary_expression_with_unit, t => t.Term);
unit_variable_expression_with_unit.Rule =
LEFT_BRACKET
+ unit_expression.BindMember(unit_variable_expression_with_unit, t => t.Value)
+ RIGHT_BRACKET;
qualified_identifier.Rule =
IDENTIFIER
.PlusList(DOT)
.ConvertValue(
_identifiers => string.Join(DOT.Text, _identifiers),
_qualifiedIdentifier => _qualifiedIdentifier.Split(new string[] { DOT.Text }, StringSplitOptions.None)
);
name.Rule = IDENTIFIER.BindMember(name, t => t.Value);
namespace_name.Rule = qualified_identifier.BindMember(namespace_name, t => t.Value);
nameref.Rule = qualified_identifier.ConvertValue(_qualifiedIdentifier => new NameRef(_qualifiedIdentifier), _nameRef => _nameRef.Value);
quantity_reference.Rule = nameref.ConvertValue(_nameRef => Reference.Get<QuantityDefinition>(_nameRef), _quantityReference => _quantityReference.NameRef);
unit_reference.Rule = nameref.ConvertValue(_nameRef => Reference.Get<UnitDefinition>(_nameRef), _unitReference => _unitReference.NameRef);
#endregion
#region Unparse
// this is not really needed, it is only here for performance reasons
qualified_identifier.UtokenizerForUnparse = (formatProvider, _qualifiedIdentifier) => new [] { UtokenValue.CreateText(_qualifiedIdentifier) };
UnparseControl.DefaultFormatting.InsertUtokensAround(DOT, UtokenInsert.NoWhitespace);
UnparseControl.DefaultFormatting.InsertUtokensRightOf(LEFT_PAREN, UtokenInsert.NoWhitespace);
UnparseControl.DefaultFormatting.InsertUtokensLeftOf(RIGHT_PAREN, UtokenInsert.NoWhitespace);
UnparseControl.DefaultFormatting.InsertUtokensRightOf(LEFT_BRACKET, UtokenInsert.NoWhitespace);
UnparseControl.DefaultFormatting.InsertUtokensLeftOf(RIGHT_BRACKET, UtokenInsert.NoWhitespace);
UnparseControl.DefaultFormatting.InsertUtokensLeftOf(@namespace, UtokenInsert.EmptyLine);
UnparseControl.DefaultFormatting.InsertUtokensLeftOf(definitions, UtokenInsert.EmptyLine);
UnparseControl.DefaultFormatting.InsertUtokensRightOf(definition, UtokenInsert.NewLine);
UnparseControl.DefaultFormatting.InsertUtokensLeftOf(conversions, UtokenInsert.NewLine);
UnparseControl.DefaultFormatting.SetBlockIndentationOn(conversions, BlockIndentation.Indent);
UnparseControl.DefaultFormatting.InsertUtokensRightOf(conversions, priority: 1, behavior: Behavior.Overridable, utokensRight: UtokenInsert.EmptyLine);
UnparseControl.DefaultFormatting.InsertUtokensRightOf(conversion, UtokenInsert.NewLine);
UnparseControl.DefaultFormatting.InsertUtokensBetweenUnordered(prefix_definition, unit_definition, UtokenInsert.EmptyLine);
UnparseControl.DefaultFormatting.InsertUtokensBetweenUnordered(prefix_definition, quantity_definition, UtokenInsert.EmptyLine);
UnparseControl.DefaultFormatting.InsertUtokensBetweenUnordered(unit_definition, quantity_definition, UtokenInsert.EmptyLine);
#endregion
}
