public static UnifiedClassDefinition CreateModule(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "module");
     return UnifiedClassDefinition.Create(
             null, null, CreateSymbol(node.NthElement(0)), null,
             null,
             CreateScope(node.NthElement(1)));
 }
 public static UnifiedIf CreateIf(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "if");
     return UnifiedIf.Create(
             CreateExpresion(node.NthElement(0)),
             CreateBlock(node.NthElement(1)),
             CreateBlock(node.NthElement(2)));
 }
 public static UnifiedExpression CreateDefn(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "defn");
     return UnifiedFunctionDefinition.Create(
             null, null, null, null,
             CreateSymbol(node.NthElement(0)),
             CreateArgs(node.NthElement(1)), null,
             CreateScope(node.NthElement(2)));
 }
 public static UnifiedEigenClassDefinition CreateSclass(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "sclass");
     return UnifiedEigenClassDefinition.Create(
             null, null, null, null,
             UnifiedEigenConstrain.Create(
                     CreateExpresion(node.NthElement(0))).
                     ToSet<UnifiedTypeConstrain>(),
             CreateScope(node.NthElement(1)));
 }
 public static UnifiedExpression CreateFor(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "for");
     Contract.Assert(
             node.NthElement(1).Name() == "lasgn"
             || node.NthElement(1).Name() == "masgn");
     return UnifiedForeach.Create(
             CreateExpresion(node.NthElement(0)),
             CreateExpresion(node.NthElement(1).FirstElement()),
             CreateBlock(node.NthElement(2)));
 }
 public static UnifiedClassDefinition CreateClass(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "class");
     var constNode = node.NthElement(1);
     var constrain = constNode.Name() != "nil"
                             ? UnifiedExtendConstrain.Create(
                                     UnifiedType.Create(constNode.Value))
                             : null;
     return UnifiedClassDefinition.Create(
             null, null, CreateSymbol(node.NthElement(0)), null,
             constrain.ToSet<UnifiedTypeConstrain>(),
             CreateScope(node.NthElement(2)));
 }
 public static UnifiedCall CreateCall(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "call");
     // TODO: 演算子への変換
     var receiver = CreateExpresion(node.NthElement(0));
     var secondNode = node.NthElement(1);
     return UnifiedCall.Create(
             receiver != null
                     ? UnifiedProperty.Create(
                             ".", receiver, CreateExpresion(secondNode))
                     : CreateExpresion(secondNode),
             CreateArglist(node.NthElement(2)));
 }
 public static UnifiedCall CreateIter(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "iter");
     var call = CreateCall(node.NthElement(0));
     var paramNode = node.NthElement(1);
     Contract.Assert(
             paramNode.Name() != "Fixnum" || paramNode.Value == "0");
     var parameters = paramNode.Name() != "Fixnum"
                              ? CreateLasgnOrMasgnOrNil(
                                      node.NthElement(1))
                                        .Select(e => e.ToParameter())
                                        .ToSet()
                              : null;
     var block = CreateBlock(node.NthElement(2));
     call.Proc = UnifiedProc.Create(parameters, block);
     return call;
 }
 public static UnifiedExpression CreateCase(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "case");
     return UnifiedSwitch.Create(
             CreateExpresion(node.NthElement(0)),
             node.Elements().Skip(1)
                     .SelectMany(CreateWhenAndDefault)
                     .ToSet()
             );
 }
 private static UnifiedExpression CreateDefs(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "defs");
     var owner = CreateExpresion(node.NthElement(0));
     var target = UnifiedFunctionDefinition.Create(
             null, null, null, null,
             CreateSymbol(node.NthElement(1)),
             CreateArgs(node.NthElement(2)), null,
             CreateScope(node.NthElement(3)));
     return UnifiedProperty.Create(".", owner, target);
 }
		public static UnifiedProgram CreateCompilationUnit(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "compilationUnit");
			/*
			 * compilationUnit 
			 * :   ( (annotations)? packageDeclaration )? (importDeclaration)* (typeDeclaration)*
			 */
			var program = UnifiedProgram.Create(UnifiedBlock.Create());
			var expressions = program.Body;

			var first = node.FirstElementOrDefault();
			if (first.SafeName() == "annotations") {
				var annotations = CreateAnnotations(node.FirstElement());
				var packageDeclaration =
						CreatePackageDeclaration(node.NthElement(1));
				packageDeclaration.Annotations = annotations;
				expressions.Add(packageDeclaration);
				expressions = packageDeclaration.Body;
			} else if (first.SafeName() == "packageDeclaration") {
				var packageDeclaration = CreatePackageDeclaration(first);
				expressions.Add(packageDeclaration);
				expressions = packageDeclaration.Body;
			}
			foreach (var e in node.Elements("importDeclaration")) {
				var importDeclaration = CreateImportDeclaration(e);
				expressions.Add(importDeclaration);
			}
			foreach (var e in node.Elements("typeDeclaration")) {
				var typeDeclaration = CreateTypeDeclaration(e);
				expressions.AddRange(typeDeclaration);
			}
			// Pick up comment nodes which are in last children of the root node
			program.Comments = node.Elements(Code2XmlConstants.CommentName)
					.Select(CreateComment)
					.ToSet();

			return program;
		}
				CreateNormalInterfaceDeclaration(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "normalInterfaceDeclaration");
			/*
			 * normalInterfaceDeclaration 
			 * :   modifiers 'interface' IDENTIFIER (typeParameters)? ('extends' typeList)? interfaceBody 
			 */
			var annotationsAndModifiers =
					CreateModifiers(node.Element("modifiers"));
			var name = UnifiedVariableIdentifier.Create(
					node.NthElement(2).Value);
			var typeParametersNode = node.Element("typeParameters");
			var typeParameters = typeParametersNode != null
										? CreateTypeParameters(
												typeParametersNode)
										: null;
			var typeListNode = node.Element("typeList");
			var constrains = typeListNode != null
									? UnifiedSet<UnifiedTypeConstrain>.Create(
											CreateTypeList(typeListNode).Select
													(
															UnifiedExtendConstrain
																	.Create))
									: null;
			var body = CreateInterfaceBody(node.Element("interfaceBody"));

			return UnifiedInterfaceDefinition.Create(
					annotationsAndModifiers.Item1,
					annotationsAndModifiers.Item2,
					name,
					typeParameters,
					constrains,
					body);
		}
		public static UnifiedExpression CreateForstatement(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "forstatement");
			/*
			 * forstatement 
			 * // enhanced for loop
			 *     'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement
			 * // normal for loop
			 * |   'for' '(' (forInit)? ';' (expression)? ';' (expressionList)? ')' statement 
			 */
			if (node.NthElement(2).Name() == "variableModifiers") {
				var annotationsAndModifiers =
						CreateVariableModifiers(
								node.Element("variableModifiers"));
				return UnifiedForeach.Create(
						UnifiedVariableDefinition.Create(
								annotationsAndModifiers.Item1,
								annotationsAndModifiers.Item2,
								CreateType(node.Element("type")),
								UnifiedVariableIdentifier.Create(
										node.Element("IDENTIFIER").Value)
								).ToVariableDefinitionList(),
						CreateExpression(node.Element("expression")),
						CreateStatement(node.Element("statement")).ToBlock()
						);
			}
			var forInit = node.HasElement("forInit")
								? CreateForInit(node.Element("forInit"))
								: null;
			var condition = node.HasElement("expression")
									? CreateExpression(
											node.Element("expression"))
									: null;
			var step = node.HasElement("expressionList")
					   // TODO tuple?
							? CreateExpressionList(
									node.Element("expressionList"))
									.ToTupleLiteral()
							: null;
			var body =
					UnifiedBlock.Create(
							CreateStatement(node.Element("statement")));

			return UnifiedFor.Create(forInit, condition, step, body);
		}
		public static UnifiedClassLikeDefinition CreateNormalClassDeclaration(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "normalClassDeclaration");
			/*
			 * normalClassDeclaration 
			 * :   modifiers 'class' IDENTIFIER (typeParameters)? ('extends' type)? ('implements' typeList)? classBody 
			 */
			var annotationsAndModifiers =
					CreateModifiers(node.Element("modifiers"));
			var name = node.NthElement(2).Value;
			var typeParameters = node.HasElement("typeParameters")
										? CreateTypeParameters(
												node.Element("typeParameters"))
										: null;
			var constrains = UnifiedSet<UnifiedTypeConstrain>.Create();
			if (node.HasElement("type")) {
				constrains.Add(
						UnifiedExtendConstrain.Create(
								CreateType(node.Element("type"))));
			}
			if (node.HasElement("typeList")) {
				foreach (var type in CreateTypeList(node.Element("typeList"))) {
					constrains.Add(UnifiedImplementsConstrain.Create(type));
				}
			}
			var body = CreateClassBody(node.Element("classBody"));
			return UnifiedClassDefinition.Create(
					annotationsAndModifiers.Item1,
					annotationsAndModifiers.Item2,
					UnifiedVariableIdentifier.Create(name), typeParameters,
					constrains, body);
		}
		public static UnifiedClassLikeDefinition CreateEnumDeclaration(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "enumDeclaration");
			/*
			 * enumDeclaration 
			 * :   modifiers ('enum') IDENTIFIER ('implements' typeList)? enumBody 
			 */
			var annotationsAndModifiers = CreateModifiers(node.FirstElement());
			var name = node.NthElement(2).Value;
			var typeListNode = node.Element("typeList");
			var constrains = typeListNode != null
									? CreateTypeList(typeListNode)
											.Select(
													UnifiedImplementsConstrain
															.Create)
											.ToSet<UnifiedTypeConstrain>()
									: null;
			var enumBody = CreateEnumBody(node.Element("enumBody"));
			return UnifiedEnumDefinition.Create(
					annotationsAndModifiers.Item1,
					annotationsAndModifiers.Item2,
					UnifiedVariableIdentifier.Create(name),
					null,
					constrains,
					enumBody);
		}
		public static UnifiedNew CreateArrayCreator(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "arrayCreator");
			/*
			 * arrayCreator 
			 * :   'new' createdName '[' ']' ('[' ']')* arrayInitializer
			 * |   'new' createdName '[' expression ']' ( '[' expression ']' )* ('[' ']')* 
			 */

			var type = CreateCreatedName(node.NthElement(1));

			if (node.HasElement("arrayInitializer")) {
				var initVal =
						CreateArrayInitializer(node.Element("arrayInitializer"));
				var dimension = node.ElementsByContent("[").Count();
				type = type.WrapArrayRepeatedly(dimension);
				return UnifiedNew.Create(type, null, null, initVal);
			}

			type = node.Elements("expression")
					.Aggregate(
							type, (current, exp) => current
															.WrapArray(
																	CreateExpression
																			(
																					exp)
																			.
																			ToArgument
																			()));
			{
				var dimension = node.ElementsByContent("[")
						.Where(e => e.NextElement().Value == "]")
						.Count();
				type = type.WrapArrayRepeatedly(dimension);
			}
			return UnifiedNew.Create(type);
		}
				CreateNonWildcardTypeArguments(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "nonWildcardTypeArguments");
			/*
			 * nonWildcardTypeArguments 
			 * :   '<' typeList '>'
			 */

			var typeList = CreateTypeList(node.NthElement(1));
			var typeArguments = UnifiedSet<UnifiedGenericArgument>.Create();

			foreach (var type in typeList) {
				var argument = UnifiedGenericArgument.Create(type);
				typeArguments.Add(argument);
			}
			return typeArguments;
		}
		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 CreateCreator(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "creator");
			/*
			 * creator 
			 * :   'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest
			 * |   'new' classOrInterfaceType classCreatorRest
			 * |   arrayCreator 
			 */

			//コード例
			//Sample<String> Sample = new <Integer> Sample<String> (1,2){ int z = 0; };

			var first = node.FirstElement();

			if (first.Name() == "arrayCreator") {
				return CreateArrayCreator(first);
			}

			var creatorRest =
					CreateClassCreatorRest(node.Element("classCreatorRest"));
			if (node.Elements().Count() == 4) {
				return UnifiedNew.Create(
						CreateClassOrInterfaceType(node.NthElement(2)),
						creatorRest.Item1,
						CreateNonWildcardTypeArguments(
								node.Element("nonWildcardTypeArguments")),
						null, creatorRest.Item2);
			}

			return UnifiedNew.Create(
					CreateClassOrInterfaceType(node.NthElement(1)),
					creatorRest.Item1, null,
					null, creatorRest.Item2);
		}
		public static UnifiedCast CreateCastExpression(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "castExpression");
			/*
			 * castExpression 
			 * :   '(' primitiveType ')' unaryExpression
			 * |   '(' type ')' unaryExpressionNotPlusMinus 
			 */
			if (node.LastElement().Name() == "unaryExpression") {
				return UnifiedCast.Create(
						CreatePrimitiveType(node.NthElement(1)),
						CreateUnaryExpression(node.NthElement(3))
						);
			}
			return UnifiedCast.Create(
					CreateType(node.NthElement(1)),
					CreateUnaryExpressionNotPlusMinus(node.NthElement(3))
					);
		}
		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 CreateAnnotationMethodDeclaration(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "annotationMethodDeclaration");
			/*
			 * annotationMethodDeclaration 
			 * :   modifiers type IDENTIFIER '(' ')' ('default' elementValue)? ';' 
			 */
			var annotationsAndModifiers = CreateModifiers(node.FirstElement());
			var elementValueNode = node.Element("elementValue");
			return UnifiedVariableDefinition.Create(
					annotationsAndModifiers.Item1, annotationsAndModifiers.Item2,
					CreateType(node.NthElement(1)),
					UnifiedVariableIdentifier.Create(node.NthElement(2).Value),
					arguments: UnifiedSet<UnifiedArgument>.Create(),
					initialValue: elementValueNode != null
										? CreateElementValue(elementValueNode)
										: null
					).ToVariableDefinitionList();
		}
		public static UnifiedParameter CreateEllipsisParameterDecl(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "ellipsisParameterDecl");
			/*
			 * ellipsisParameterDecl  
			 * :   variableModifiers type '...' IDENTIFIER 
			 */
			var annotationsAndModifiers =
					CreateVariableModifiers(node.Element("variableModifiers"));
			annotationsAndModifiers.Item2.Add(UnifiedModifier.Create("..."));
			var type = CreateType(node.Element("type"));
			return UnifiedParameter.Create(
					annotationsAndModifiers.Item1,
					annotationsAndModifiers.Item2,
					type,
					UnifiedVariableIdentifier.Create(node.NthElement(3).Value).
							ToSet<UnifiedIdentifier>());
		}
		public static UnifiedGenericArgument CreateTypeArgument(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "typeArgument");
			/*
			 * typeArgument 
			 * :   type
			 * |   '?' (('extends' | 'super') type)? 
			 */
			if (node.FirstElement().Name() == "type") {
				return
						UnifiedGenericArgument.Create(
								CreateType(node.FirstElement()));
			}

			var anyType = UnifiedType.Create(node.NthElement(0).Value);
			var typeNode = node.Element("type");
			if (typeNode != null) {
				UnifiedTypeConstrain constrain;
				if (node.NthElement(1).Value == "extends") {
					constrain =
							UnifiedExtendConstrain.Create(CreateType(typeNode));
				} else {
					constrain =
							UnifiedSuperConstrain.Create(CreateType(typeNode));
				}
				return UnifiedGenericArgument.Create(
						anyType, null, constrain.ToSet());
			}
			return UnifiedGenericArgument.Create(anyType);
		}
				CreateFormalParameter(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "formalParameter");
			/*
			 * formalParameter 
			 * :   variableModifiers type IDENTIFIER ('[' ']')* 
			 */

			var type = CreateType(node.NthElement(1));
			var dimension = node.ElementsByContent("[").Count();
			type = type.WrapArrayRepeatedly(dimension);
			var annotationsAndModifiers =
					CreateVariableModifiers(node.FirstElement());
			return Tuple.Create(
					annotationsAndModifiers, type,
					UnifiedVariableIdentifier.Create(node.NthElement(2).Value));
		}
		public static UnifiedTry CreateTrystatement(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "trystatement");
			/*
			 * trystatement 
			 * :   'try' block (catches 'finally' block | catches | 'finally' block) 
			 */
			var body = CreateBlock(node.NthElement(1));
			var catches = node.HasElement("catches")
								? CreateCatches(node.Element("catches"))
								: null;
			var finallyBlock = node.HasElement("FINALLY")
									? CreateBlock(
											node.Elements("block").ElementAt(
													1))
									: null;
			return UnifiedTry.Create(body, catches, null, finallyBlock);
		}
		public static UnifiedParameter CreateNormalParameterDecl(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "normalParameterDecl");
			/*
			 * normalParameterDecl 
			 * :   variableModifiers type IDENTIFIER ('[' ']')*
			 */
			var annotationsAndModifiers =
					CreateVariableModifiers(node.Element("variableModifiers"));
			var type = CreateType(node.Element("type"));
			var dimension = node.ElementsByContent("[").Count();
			type = type.WrapArrayRepeatedly(dimension);
			return UnifiedParameter.Create(
					annotationsAndModifiers.Item1,
					annotationsAndModifiers.Item2,
					type,
					UnifiedVariableIdentifier.Create(node.NthElement(2).Value).
							ToSet<UnifiedIdentifier>());
		}
		public static UnifiedExpression CreateParExpression(XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "parExpression");
			/*
			 * parExpression 
			 * :   '(' expression ')' 
			 */

			return CreateExpression(node.NthElement(1));
		}
        public static UnifiedVariableDefinition CreateEnumerator(XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "enumerator");
            /*
            enumerator
            : IDENTIFIER ('=' constant_expression)?
            */

            var identifier =
                    UnifiedIdentifier.CreateVariable(node.NthElement(0).Value);
            UnifiedExpression value = null;
            var expression = node.Element("constant_expression");
            if (expression != null) {
                value = CreateConstantExpression(expression);
            }
            return UnifiedVariableDefinition.Create(
                    null, null, null, identifier, value);
        }
		public static UnifiedExpression CreateConditionalExpression(
				XElement node) {
			Contract.Requires(node != null);
			Contract.Requires(node.Name() == "conditionalExpression");
			/*
			 * conditionalExpression 
			 * :   conditionalOrExpression ('?' expression ':' conditionalExpression)?
			 */

			if (node.HasElement("expression")) {
				return UnifiedTernaryExpression.Create(
						CreateConditionalOrExpression(node.NthElement(0)),
						CreateExpression(node.NthElement(2)),
						CreateConditionalExpression(node.NthElement(4))
						);
			}
			return CreateConditionalOrExpression(node.FirstElement());
		}