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();
}
}
