public static UnifiedContinue Create( UnifiedExpression value = null) { return(new UnifiedContinue { Value = value, }); }
public static UnifiedDelete Create( UnifiedExpression value = null) { return(new UnifiedDelete { Value = value, }); }
public static UnifiedStringConversion Create( UnifiedExpression value = null) { return(new UnifiedStringConversion { Value = value, }); }
public static UnifiedReturn Create( UnifiedExpression value = null) { return(new UnifiedReturn { Value = value, }); }
public static UnifiedType Create( UnifiedExpression basicExpression = null) { return new UnifiedBasicType { BasicTypeName = basicExpression, }; }
public static UnifiedPrintChevron Create( UnifiedExpression value = null) { return(new UnifiedPrintChevron { Value = value, }); }
public static UnifiedType Create( UnifiedExpression basicExpression = null) { return(new UnifiedBasicType { BasicTypeName = basicExpression, }); }
public static UnifiedEigenConstrain Create( UnifiedExpression eigenObject) { return(new UnifiedEigenConstrain { EigenObject = eigenObject, }); }
public static UnifiedBlock ToBlock(this UnifiedExpression singleton) { if (singleton == null) { return(UnifiedBlock.Create()); } return(UnifiedBlock.Create(singleton)); }
public static UnifiedIf Create( UnifiedExpression condition, UnifiedBlock body) { return(new UnifiedIf { Body = body, Condition = condition, }); }
public static UnifiedOrderByKey Create( UnifiedExpression expression, bool ascending) { return(new UnifiedOrderByKey { Expression = expression, Ascending = ascending, }); }
public static UnifiedSetComprehension Create( UnifiedExpression element, UnifiedSet<UnifiedExpression> generator) { return new UnifiedSetComprehension { Element = element, Generator = generator, }; }
public static UnifiedCase Create( UnifiedExpression condtion = null, UnifiedBlock body = null) { return(new UnifiedCase { Body = body, Condition = condtion, }); }
public static UnifiedSelectQuery Create( UnifiedExpression expression, UnifiedVariableIdentifier receiver = null) { return(new UnifiedSelectQuery { Expression = expression, Receiver = receiver, }); }
public static UnifiedKeyValue Create( UnifiedExpression key = null, UnifiedExpression value = null) { return(new UnifiedKeyValue { Key = key, Value = value, }); }
public static UnifiedAnnotation Create( UnifiedExpression name = null, UnifiedSet <UnifiedArgument> arguments = null) { return(new UnifiedAnnotation { Name = name, Arguments = arguments, }); }
public static UnifiedLetQuery Create( UnifiedVariableIdentifier variable, UnifiedExpression expression) { return(new UnifiedLetQuery { Variable = variable, Expression = expression }); }
public static UnifiedAlias Create( UnifiedExpression value = null, UnifiedExpression alias = null) { return(new UnifiedAlias { Value = value, Alias = alias, }); }
public static UnifiedRange Create( UnifiedExpression min = null, UnifiedExpression max = null) { return(new UnifiedRange { Min = min, Max = max, }); }
public static UnifiedSynchronized Create( UnifiedExpression value = null, UnifiedBlock body = null) { return(new UnifiedSynchronized { Value = value, Body = body, }); }
public static UnifiedCountedLoop Create( UnifiedExpression count, UnifiedBlock body) { return(new UnifiedCountedLoop { Count = count, Body = body }); }
public static UnifiedIndexer Create( UnifiedExpression current = null, UnifiedSet <UnifiedArgument> create = null) { return(new UnifiedIndexer { Target = current, Arguments = create }); }
public static UnifiedSwitch Create( UnifiedExpression value = null, UnifiedSet <UnifiedCase> cases = null) { return(new UnifiedSwitch { Value = value, Cases = cases, }); }
public static UnifiedUnaryExpression Create( UnifiedExpression operand, UnifiedUnaryOperator unaryOperator) { return(new UnifiedUnaryExpression { Operand = operand, Operator = unaryOperator, }); }
public static UnifiedCast Create( UnifiedType type, UnifiedExpression createExpression) { return(new UnifiedCast { Type = type, Expression = createExpression }); }
public static UnifiedArrayLiteral ToArrayLiteral( this UnifiedExpression singleton) { if (singleton == null) { return(UnifiedArrayLiteral.Create()); } return(UnifiedArrayLiteral.Create(singleton)); }
public static UnifiedFix Create( UnifiedExpression value = null, UnifiedBlock body = null) { return(new UnifiedFix { Value = value, Body = body, }); }
public static UnifiedProgram ToProgram( this UnifiedExpression singleton) { if (singleton == null) { return(UnifiedProgram.Create(UnifiedBlock.Create())); } return(UnifiedProgram.Create(singleton.ToBlock())); }
public static UnifiedIterableLiteral ToLazyListLiteral( this UnifiedExpression singleton) { if (singleton == null) { return(UnifiedIterableLiteral.Create()); } return(UnifiedIterableLiteral.Create(singleton)); }
public static UnifiedGroupByQuery Create( UnifiedExpression element, UnifiedExpression key, UnifiedVariableIdentifier receiver = null) { return(new UnifiedGroupByQuery { Element = element, Key = key, Receiver = receiver }); }
public static UnifiedAssert Create( UnifiedExpression value = null, UnifiedExpression message = null ) { return(new UnifiedAssert { Value = value, Message = message, }); }
public static UnifiedExpression CreateCallExpressionSuffix( UnifiedExpression prefix, XElement node) { Contract.Requires(node != null); Contract.Requires(node.Name() == "callExpressionSuffix"); /* * callExpressionSuffix * : arguments * | indexSuffix * | propertyReferenceSuffix */ var first = node.NthElement(0); switch (first.Name()) { case "arguments": return UnifiedCall.Create(prefix, CreateArguments(first)); case "indexSuffix": return CreateIndexSuffix(prefix, first); case "propertyReferenceSuffix": return CreatePropertyReferenceSuffix(prefix, first); default: throw new InvalidOperationException(); } }
public static UnifiedProperty CreatePropertyReferenceSuffix( UnifiedExpression prefix, XElement node) { Contract.Requires(node != null); Contract.Requires(node.Name() == "propertyReferenceSuffix"); /* * propertyReferenceSuffix * : '.' LT!* Identifier */ return UnifiedProperty.Create( ".", prefix, UnifiedVariableIdentifier.Create( node.Element("Identifier").Value)); }
public static UnifiedExpression CreateInnerCreator( UnifiedExpression prefix, XElement node) { Contract.Requires(node != null); Contract.Requires(node.Name() == "innerCreator"); /* * innerCreator * : '.' 'new' (nonWildcardTypeArguments)? IDENTIFIER (typeArguments)? classCreatorRest */ //コード例 // X . new <T> Sample <E> (1,2){} var typeArguments = node.HasElement("typeArguments") ? CreateTypeArguments( node.Element("typeArguments")) : null; var type = UnifiedType.Create( node.Element("IDENTIFIER").Value).WrapGeneric(typeArguments); var creatorRest = CreateClassCreatorRest(node.Element("classCreatorRest")); var typeParameters = node.HasElement("nonWildcardTypeArguments") ? CreateNonWildcardTypeArguments( node.Element( "nonWildcardTypeArguments")) : null; var prop = UnifiedNew.Create( type, creatorRest.Item1, typeParameters, null, creatorRest.Item2); return UnifiedProperty.Create(".", prefix, prop); }
public static UnifiedExpression CreateSelector( UnifiedExpression prefix, XElement node) { Contract.Requires(node != null); Contract.Requires(node.Name() == "selector"); /* * selector : '.' IDENTIFIER arguments? //student.getName() | '.' nonWildcardTypeArguments IDENTIFIER arguments // fix to support "obj.method().<Object>method2()" | '.' 'this' //OuterClass.this | '.' 'super' superSuffix //Outer.super() | innerCreator | '[' expression ']' */ var secondElement = node.NthElementOrDefault(1); if (secondElement == null) { return CreateInnerCreator(prefix, node.FirstElement()); } if (secondElement.Name() == "IDENTIFIER") { prefix = UnifiedProperty.Create( ".", prefix, UnifiedVariableIdentifier.Create(secondElement.Value)); var arguments = node.Element("arguments"); if (arguments != null) { prefix = UnifiedCall.Create( prefix, CreateArguments(arguments)); } return prefix; } if (secondElement.Name() == "nonWildcardTypeArguments") { prefix = UnifiedProperty.Create( ".", prefix, UnifiedVariableIdentifier.Create( node.NthElement(2).Value)); return UnifiedCall.Create( prefix, CreateArguments(node.NthElement(3)), CreateNonWildcardTypeArguments(secondElement)); } if (secondElement.Value == "this") { return UnifiedProperty.Create( ".", prefix, UnifiedVariableIdentifier.Create("this")); } if (secondElement.Value == "super") { var prop = UnifiedProperty.Create( ".", prefix, UnifiedSuperIdentifier.Create("super")); return CreateSuperSuffix(prop, node.Element("superSuffix")); } if (secondElement.Name() == "expression") { return UnifiedIndexer.Create( prefix, UnifiedArgument.Create( CreateExpression(secondElement), null, null). ToSet()); } throw new InvalidOperationException(); }
public static UnifiedExpression CreateIdentifierSuffix( UnifiedExpression prefixProp, XElement node) { Contract.Requires(node != null); Contract.Requires(node.Name() == "identifierSuffix"); /* * identifierSuffix * : ('[' ']')+ '.' 'class' // java.lang.String[].class * | ('[' expression ']' )+ // strs[10] * | arguments // func(1, 2) * | '.' 'class' // java.lang.String.class * // this.<Integer>m(1), super.<Integer>m(1) * | '.' nonWildcardTypeArguments IDENTIFIER arguments * | '.' 'this' // Outer.this * | '.' 'super' arguments // new Outer().super(); * | innerCreator // new Outer().new <Integer> Inner<String>(1); */ var second = node.NthElementOrDefault(1); if (second == null) { // arguments // func(1, 2) if (node.FirstElement().Name() == "arguments") { return UnifiedCall.Create( prefixProp, CreateArguments(node.FirstElement())); } // innerCreator // new Outer().new <Integer> Inner<String>(1); return CreateInnerCreator( prefixProp, node.Element("innerCreator")); } // ('[' expression ']' )+ // strs[10] if (second.Name() == "expression") { return node.Elements("expression") .Select(CreateExpression) .Aggregate( prefixProp, (current, exp) => UnifiedIndexer.Create( current, UnifiedSet<UnifiedArgument>. Create( UnifiedArgument . Create ( exp, null, null))) ); } // '.' 'class' // java.lang.String.class if (second.Value == "class") { return UnifiedTypeof.Create(UnifiedType.Create(prefixProp)); } // ('[' ']')+ '.' 'class' // java.lang.String[].class if (node.LastElement().Value == "class") { var d = node.ElementsByContent("[").Count(); return UnifiedTypeof.Create( (UnifiedType.Create(prefixProp)). WrapArrayRepeatedly(d)); } // '.' nonWildcardTypeArguments IDENTIFIER arguments if (second.Name() == "nonWildcardTypeArguments") { var prop = UnifiedProperty.Create( ".", prefixProp, UnifiedVariableIdentifier.Create( node.NthElement(2).Value)); return UnifiedCall.Create( prop, CreateArguments(node.Element("arguments")), CreateNonWildcardTypeArguments( node.Element("nonWildcardTypeArguments"))); } // '.' 'this' // Outer.this if (second.Value == "this") { return UnifiedProperty.Create( ".", prefixProp, UnifiedThisIdentifier.Create("this")); } // '.' 'super' arguments // new Outer().super(); if (second.Value == "super") { var prop = UnifiedProperty.Create( ".", prefixProp, UnifiedSuperIdentifier.Create("super")); return UnifiedCall.Create( prop, CreateArguments(node.Element("arguments"))); } throw new InvalidOperationException(); }
public static UnifiedExpression CreateSuperSuffix( UnifiedExpression prefix, XElement node) { Contract.Requires(node != null); Contract.Requires(node.Name() == "superSuffix"); /* * superSuffix * : arguments * | '.' (typeArguments)? IDENTIFIER (arguments)? */ if (node.FirstElement().Name == "arguments") { // super(arg1, arg2) return UnifiedCall.Create( prefix, CreateArguments(node.FirstElement())); } var typeArgumentsNode = node.Element("typeArguments"); var typeArguments = typeArgumentsNode != null ? CreateTypeArguments(typeArgumentsNode) : null; var argumentsNode = node.Element("arguments"); var arguments = argumentsNode != null ? CreateArguments(argumentsNode) : null; var property = UnifiedProperty.Create( ".", prefix, UnifiedVariableIdentifier.Create( node.Element("IDENTIFIER").Value)); if (arguments != null) { // super.<Integer>method(arg1) return UnifiedCall.Create(property, arguments, typeArguments); } // super.field1 return property; }
public static UnifiedIndexer CreateIndexSuffix( UnifiedExpression prefix, XElement node) { Contract.Requires(node != null); Contract.Requires(node.Name() == "indexSuffix"); /* * indexSuffix * : '[' LT!* expression LT!* ']' */ return UnifiedIndexer.Create( prefix, UnifiedArgument.Create( CreateExpression(node.Element("expression")), null, null). ToSet()); }
public static UnifiedExpression CreateTrailer( UnifiedExpression prefix, XElement node) { Contract.Requires(node != null); Contract.Requires(node.Name() == "trailer"); /* * trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME */ switch (node.FirstElement().Value) { case "(": var arglistNode = node.Element("arglist"); return arglistNode != null ? UnifiedCall.Create( prefix, CreateArglist(arglistNode)) : UnifiedCall.Create( prefix, UnifiedSet<UnifiedArgument>.Create()); case "[": var second = node.NthElement(1); return UnifiedIndexer.Create( prefix, CreateSubscriptlist(second)); case ".": return UnifiedProperty.Create( ".", prefix, UnifiedVariableIdentifier.Create( node.LastElement().Value)); default: throw new IndexOutOfRangeException(); } }