Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision 59db6897195376150fdc27245cae3d51cc615cd4)
+++ src/Parser/ExpressionNode.cc	(revision cd623a4e93c2eeb566858071f03b3e141d60d50c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun  6 23:18:19 2015
-// Update Count     : 128
+// Last Modified On : Sun Jun  7 07:58:00 2015
+// Update Count     : 135
 // 
 
@@ -60,4 +60,6 @@
 }
 
+//##############################################################################
+
 NullExprNode::NullExprNode() {}
 
@@ -84,24 +86,27 @@
 }
 
-static inline bool checku( char c ) { return c == 'u' || c == 'U'; }
-static inline bool checkl( char c ) { return c == 'l' || c == 'L'; }
-static inline bool checkf( char c ) { return c == 'f' || c == 'F'; }
-static inline bool checkx( char c ) { return c == 'x' || c == 'X'; }
+//##############################################################################
+
+static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
+static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
+static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
+static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
+
+// Very difficult to separate extra parts of constants during lexing because actions are not allow in the middle of
+// patterns:
+//
+//		prefix action constant action suffix
+//
+// Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
+//
+//		constant BEGIN CONT ...
+//		<CONT>(...)? BEGIN 0 ... // possible empty suffix
+//
+// because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
+// type.
 
 ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), value( *inVal ) {
+	// lexing divides constants into 4 kinds
 	switch ( type ) {
-	  case Float:
-		{
-			size_t len = value.length() - 1;
-
-			btype = BasicType::Double;					// default
-			if ( checkf( value[len] ) ) {
-				btype = BasicType::Float;
-			} // if
-			if ( checkl( value[len] ) ) {
-				btype = BasicType::LongDouble;
-			} // if
-			break;
-		}
 	  case Integer:
 		{
@@ -115,7 +120,7 @@
 			int size;									// 0 => int, 1 => long, 2 => long long
 
-			if ( value[0] == '0' ) {					// octal ?
+			if ( value[0] == '0' ) {					// octal constant ?
 				dec = false;
-				if ( last != 0 && checkx( value[1] ) ) { // hex ?
+				if ( last != 0 && checkX( value[1] ) ) { // hex constant ?
 					sscanf( (char *)value.c_str(), "%llx", &v );
 					//printf( "%llx %llu\n", v, v );
@@ -124,5 +129,5 @@
 					//printf( "%llo %llu\n", v, v );
 				} // if
-			} else {									// decimal ?
+			} else {									// decimal constant ?
 				sscanf( (char *)value.c_str(), "%lld", &v );
 				//printf( "%llu %llu\n", v, v );
@@ -146,22 +151,35 @@
 			} // if
 
-			if ( checku( value[last] ) ) {				// suffix 'u' ?
+			if ( checkU( value[last] ) ) {				// suffix 'u' ?
 				Unsigned = true;
-				if ( checkl( value[ last - 1 ] ) ) {	// suffix 'l' ?
+				if ( checkL( value[ last - 1 ] ) ) {	// suffix 'l' ?
 					size = 1;
-					if ( checkl( value[ last - 1 ] ) ) { // suffix 'll' ?
+					if ( checkL( value[ last - 1 ] ) ) { // suffix 'll' ?
 						size = 2;
 					} // if
 				} // if
-			} else if ( checkl( value[ last ] ) ) {		// suffix 'l' ?
+			} else if ( checkL( value[ last ] ) ) {		// suffix 'l' ?
 				size = 1;
-				if ( checkl( value[ last - 1 ] ) ) {	// suffix 'll' ?
+				if ( checkL( value[ last - 1 ] ) ) {	// suffix 'll' ?
 					size = 2;
 				} // if
-				if ( checku( value[ last - 1 ] ) ) {	// suffix 'u' ?
+				if ( checkU( value[ last - 1 ] ) ) {	// suffix 'u' ?
 					Unsigned = true;
 				} // if
 			} // if
-			btype = kind[Unsigned][size];				// loopup type of constant
+			btype = kind[Unsigned][size];				// lookup constant type
+			break;
+		}
+	  case Float:
+		{
+			size_t len = value.length() - 1;
+
+			btype = BasicType::Double;					// default
+			if ( checkF( value[len] ) ) {				// float ?
+				btype = BasicType::Float;
+			} // if
+			if ( checkL( value[len] ) ) {				// long double ?
+				btype = BasicType::LongDouble;
+			} // if
 			break;
 		}
@@ -185,16 +203,12 @@
 } // ConstantNode::ConstantNode
 
-ConstantNode::Type ConstantNode::get_type( void ) const {
-	return type;
-}
-
 ConstantNode *ConstantNode::appendstr( const std::string *newValue ) {
 	assert( newValue != 0 );
 	assert( type == String );
 
-	//printf( "%lu \"%s\" \"%s\"\n", value.length() - 1, value.c_str(), newValue->substr( 1, newValue->length() - 2 ).c_str() );
+	// "abc" "def" "ghi" => "abcdefghi", so remove new text from quotes and insert before last quote in old string.
 	value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) );
 	
-	delete newValue;									// allocated by yacc
+	delete newValue;									// allocated by lexer
 	return this;
 }
@@ -226,6 +240,5 @@
 
 Expression *ConstantNode::build() const {
-	::Type::Qualifiers q;
-	BasicType *bt;
+	::Type::Qualifiers q;								// no qualifiers on constants
 
 	switch ( get_type() ) {
@@ -241,8 +254,9 @@
 		}
 	  default:
-	   	bt = new BasicType( q, btype );
-		return new ConstantExpr( Constant( bt, get_value() ), maybeBuild< Expression >( get_argName() ) );
+		return new ConstantExpr( Constant( new BasicType( q, btype ), get_value() ), maybeBuild< Expression >( get_argName() ) );
 	}
 }
+
+//##############################################################################
 
 VarRefNode::VarRefNode() : isLabel( false ) {}
@@ -268,4 +282,6 @@
 	os << endl;
 }
+
+//##############################################################################
 
 OperatorNode::OperatorNode( Type t ) : type( t ) {}
@@ -300,5 +316,5 @@
 	"Cond",   "NCond",
 	// diadic
-	"SizeOf",      "AlignOf", "Attr", "CompLit", "Plus",    "Minus",   "Mul",     "Div",     "Mod",      "Or",
+	"SizeOf",     "AlignOf", "Attr", "CompLit", "Plus",    "Minus",   "Mul",     "Div",     "Mod",      "Or",
 	"And",       "BitOr",   "BitAnd",  "Xor",     "Cast",    "LShift",  "RShift",  "LThan",   "GThan",
 	"LEThan",    "GEThan", "Eq",      "Neq",     "Assign",  "MulAssn", "DivAssn", "ModAssn", "PlusAssn",
@@ -308,4 +324,6 @@
 	"UnPlus", "UnMinus", "AddressOf", "PointTo", "Neg", "BitNeg", "Incr", "IncrPost", "Decr", "DecrPost", "LabelAddress"
 };
+
+//##############################################################################
 
 CompositeExprNode::CompositeExprNode( void ) : ExpressionNode(), function( 0 ), arguments( 0 ) {
@@ -362,192 +380,191 @@
 	buildList( get_args(), args );
 
-	if ( ! ( op = dynamic_cast<OperatorNode *>( function )) ) {
-		// a function as opposed to an operator
+	if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator
 		return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
-	} else {
-		switch ( op->get_type()) {
-		  case OperatorNode::Incr:
-		  case OperatorNode::Decr:
-		  case OperatorNode::IncrPost:
-		  case OperatorNode::DecrPost:
-		  case OperatorNode::Assign:
-		  case OperatorNode::MulAssn:
-		  case OperatorNode::DivAssn:
-		  case OperatorNode::ModAssn:
-		  case OperatorNode::PlusAssn:
-		  case OperatorNode::MinusAssn:
-		  case OperatorNode::LSAssn:
-		  case OperatorNode::RSAssn:
-		  case OperatorNode::AndAssn:
-		  case OperatorNode::ERAssn:
-		  case OperatorNode::OrAssn:
-			// the rewrite rules for these expressions specify that the first argument has its address taken
-			assert( ! args.empty() );
-			args.front() = new AddressExpr( args.front() );
-			break;
-		  default:
-			/* do nothing */
-			;
-		}
-
-		switch ( op->get_type() ) {
-		  case OperatorNode::Incr:
-		  case OperatorNode::Decr:
-		  case OperatorNode::IncrPost:
-		  case OperatorNode::DecrPost:
-		  case OperatorNode::Assign:
-		  case OperatorNode::MulAssn:
-		  case OperatorNode::DivAssn:
-		  case OperatorNode::ModAssn:
-		  case OperatorNode::PlusAssn:
-		  case OperatorNode::MinusAssn:
-		  case OperatorNode::LSAssn:
-		  case OperatorNode::RSAssn:
-		  case OperatorNode::AndAssn:
-		  case OperatorNode::ERAssn:
-		  case OperatorNode::OrAssn:
-		  case OperatorNode::Plus:
-		  case OperatorNode::Minus:
-		  case OperatorNode::Mul:
-		  case OperatorNode::Div:
-		  case OperatorNode::Mod:
-		  case OperatorNode::BitOr:
-		  case OperatorNode::BitAnd:
-		  case OperatorNode::Xor:
-		  case OperatorNode::LShift:
-		  case OperatorNode::RShift:
-		  case OperatorNode::LThan:
-		  case OperatorNode::GThan:
-		  case OperatorNode::LEThan:
-		  case OperatorNode::GEThan:
-		  case OperatorNode::Eq:
-		  case OperatorNode::Neq:
-		  case OperatorNode::Index:
-		  case OperatorNode::Range:
-		  case OperatorNode::UnPlus:
-		  case OperatorNode::UnMinus:
-		  case OperatorNode::PointTo:
-		  case OperatorNode::Neg:
-		  case OperatorNode::BitNeg:
-		  case OperatorNode::LabelAddress:
-			return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
-		  case OperatorNode::AddressOf:
-			assert( args.size() == 1 );
-			assert( args.front() );
-
-			return new AddressExpr( args.front() );
-		  case OperatorNode::Cast:
-			{
-				TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
-				assert( arg );
-
-				DeclarationNode *decl_node = arg->get_decl();
-				ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
-
-				Type *targetType = decl_node->buildType();
-				if ( dynamic_cast< VoidType* >( targetType ) ) {
-					delete targetType;
-					return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
-				} else {
-					return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
-				} // if
-			}
-		  case OperatorNode::FieldSel:
-			{
-				assert( args.size() == 2 );
-
-				NameExpr *member = dynamic_cast<NameExpr *>( args.back());
-				// TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
-
-				if ( member != 0 ) {
-					UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
-					delete member;
-					return ret;
-					/* else if ( memberTup != 0 )
-					   {
-					   UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
-					   delete member;
-					   return ret;
-					   } */
-				} else
-					assert( false );
-			}
-		  case OperatorNode::PFieldSel:
-			{
-				assert( args.size() == 2 );
-
-				NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
-				assert( member != 0 );
-
-				UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-				deref->get_args().push_back( args.front() );
-
-				UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
+	} // if
+
+	switch ( op->get_type()) {
+	  case OperatorNode::Incr:
+	  case OperatorNode::Decr:
+	  case OperatorNode::IncrPost:
+	  case OperatorNode::DecrPost:
+	  case OperatorNode::Assign:
+	  case OperatorNode::MulAssn:
+	  case OperatorNode::DivAssn:
+	  case OperatorNode::ModAssn:
+	  case OperatorNode::PlusAssn:
+	  case OperatorNode::MinusAssn:
+	  case OperatorNode::LSAssn:
+	  case OperatorNode::RSAssn:
+	  case OperatorNode::AndAssn:
+	  case OperatorNode::ERAssn:
+	  case OperatorNode::OrAssn:
+		// the rewrite rules for these expressions specify that the first argument has its address taken
+		assert( ! args.empty() );
+		args.front() = new AddressExpr( args.front() );
+		break;
+	  default:
+		/* do nothing */
+		;
+	}
+
+	switch ( op->get_type() ) {
+	  case OperatorNode::Incr:
+	  case OperatorNode::Decr:
+	  case OperatorNode::IncrPost:
+	  case OperatorNode::DecrPost:
+	  case OperatorNode::Assign:
+	  case OperatorNode::MulAssn:
+	  case OperatorNode::DivAssn:
+	  case OperatorNode::ModAssn:
+	  case OperatorNode::PlusAssn:
+	  case OperatorNode::MinusAssn:
+	  case OperatorNode::LSAssn:
+	  case OperatorNode::RSAssn:
+	  case OperatorNode::AndAssn:
+	  case OperatorNode::ERAssn:
+	  case OperatorNode::OrAssn:
+	  case OperatorNode::Plus:
+	  case OperatorNode::Minus:
+	  case OperatorNode::Mul:
+	  case OperatorNode::Div:
+	  case OperatorNode::Mod:
+	  case OperatorNode::BitOr:
+	  case OperatorNode::BitAnd:
+	  case OperatorNode::Xor:
+	  case OperatorNode::LShift:
+	  case OperatorNode::RShift:
+	  case OperatorNode::LThan:
+	  case OperatorNode::GThan:
+	  case OperatorNode::LEThan:
+	  case OperatorNode::GEThan:
+	  case OperatorNode::Eq:
+	  case OperatorNode::Neq:
+	  case OperatorNode::Index:
+	  case OperatorNode::Range:
+	  case OperatorNode::UnPlus:
+	  case OperatorNode::UnMinus:
+	  case OperatorNode::PointTo:
+	  case OperatorNode::Neg:
+	  case OperatorNode::BitNeg:
+	  case OperatorNode::LabelAddress:
+		return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
+	  case OperatorNode::AddressOf:
+		assert( args.size() == 1 );
+		assert( args.front() );
+
+		return new AddressExpr( args.front() );
+	  case OperatorNode::Cast:
+		{
+			TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
+			assert( arg );
+
+			DeclarationNode *decl_node = arg->get_decl();
+			ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
+
+			Type *targetType = decl_node->buildType();
+			if ( dynamic_cast< VoidType* >( targetType ) ) {
+				delete targetType;
+				return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
+			} else {
+				return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
+			} // if
+		}
+	  case OperatorNode::FieldSel:
+		{
+			assert( args.size() == 2 );
+
+			NameExpr *member = dynamic_cast<NameExpr *>( args.back());
+			// TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
+
+			if ( member != 0 ) {
+				UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
 				delete member;
 				return ret;
+				/* else if ( memberTup != 0 )
+				   {
+				   UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
+				   delete member;
+				   return ret;
+				   } */
+			} else
+				assert( false );
+		}
+	  case OperatorNode::PFieldSel:
+		{
+			assert( args.size() == 2 );
+
+			NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
+			assert( member != 0 );
+
+			UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+			deref->get_args().push_back( args.front() );
+
+			UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
+			delete member;
+			return ret;
+		}
+	  case OperatorNode::AlignOf:
+	  case OperatorNode::SizeOf:
+		{
+/// 	bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf );
+
+			if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
+				return new SizeofExpr( arg->get_decl()->buildType());
+			} else {
+				return new SizeofExpr( args.front());
+			} // if
+		}
+	  case OperatorNode::Attr:
+		{
+			VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
+			assert( var );
+			if ( ! get_args()->get_link() ) {
+				return new AttrExpr( var->build(), ( Expression*)0);
+			} else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
+				return new AttrExpr( var->build(), arg->get_decl()->buildType());
+			} else {
+				return new AttrExpr( var->build(), args.back());
+			} // if
+		}
+	  case OperatorNode::CompLit:
+		throw UnimplementedError( "C99 compound literals" );
+		// the short-circuited operators
+	  case OperatorNode::Or:
+	  case OperatorNode::And:
+		assert( args.size() == 2);
+		return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) );
+	  case OperatorNode::Cond:
+		{
+			assert( args.size() == 3);
+			std::list< Expression* >::const_iterator i = args.begin();
+			Expression *arg1 = notZeroExpr( *i++ );
+			Expression *arg2 = *i++;
+			Expression *arg3 = *i++;
+			return new ConditionalExpr( arg1, arg2, arg3 );
+		}
+	  case OperatorNode::NCond:
+		throw UnimplementedError( "GNU 2-argument conditional expression" );
+	  case OperatorNode::Comma:
+		{
+			assert( args.size() == 2);
+			std::list< Expression* >::const_iterator i = args.begin();
+			Expression *ret = *i++;
+			while ( i != args.end() ) {
+				ret = new CommaExpr( ret, *i++ );
 			}
-		  case OperatorNode::AlignOf:
-		  case OperatorNode::SizeOf:
-			{
-/// 	bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf );
-
-				if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
-					return new SizeofExpr( arg->get_decl()->buildType());
-				} else {
-					return new SizeofExpr( args.front());
-				} // if
-			}
-		  case OperatorNode::Attr:
-			{
-				VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
-				assert( var );
-				if ( ! get_args()->get_link() ) {
-					return new AttrExpr( var->build(), ( Expression*)0);
-				} else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
-					return new AttrExpr( var->build(), arg->get_decl()->buildType());
-				} else {
-					return new AttrExpr( var->build(), args.back());
-				} // if
-			}
-		  case OperatorNode::CompLit:
-			throw UnimplementedError( "C99 compound literals" );
-			// the short-circuited operators
-		  case OperatorNode::Or:
-		  case OperatorNode::And:
-			assert( args.size() == 2);
-			return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) );
-		  case OperatorNode::Cond:
-			{
-				assert( args.size() == 3);
-				std::list< Expression* >::const_iterator i = args.begin();
-				Expression *arg1 = notZeroExpr( *i++ );
-				Expression *arg2 = *i++;
-				Expression *arg3 = *i++;
-				return new ConditionalExpr( arg1, arg2, arg3 );
-			}
-		  case OperatorNode::NCond:
-			throw UnimplementedError( "GNU 2-argument conditional expression" );
-		  case OperatorNode::Comma:
-			{
-				assert( args.size() == 2);
-				std::list< Expression* >::const_iterator i = args.begin();
-				Expression *ret = *i++;
-				while ( i != args.end() ) {
-					ret = new CommaExpr( ret, *i++ );
-				}
-				return ret;
-			}
-			// Tuples
-		  case OperatorNode::TupleC:
-			{
-				TupleExpr *ret = new TupleExpr();
-				std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
-				return ret;
-			}
-		  default:
-			// shouldn't happen
-			return 0;
-		}
-	}
+			return ret;
+		}
+		// Tuples
+	  case OperatorNode::TupleC:
+		{
+			TupleExpr *ret = new TupleExpr();
+			std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
+			return ret;
+		}
+	  default:
+		// shouldn't happen
+		return 0;
+	} // switch
 }
 
@@ -598,4 +615,6 @@
 }
 
+//##############################################################################
+
 CommaExprNode::CommaExprNode(): CompositeExprNode( new OperatorNode( OperatorNode::Comma )) {}
 
@@ -615,4 +634,6 @@
 }
 
+//##############################################################################
+
 ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {}
 
@@ -637,4 +658,6 @@
 	return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) );
 }
+
+//##############################################################################
 
 ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
@@ -689,10 +712,10 @@
 }
 
-TypeValueNode::TypeValueNode( DeclarationNode *decl )
-	: decl( decl ) {
-}
-
-TypeValueNode::TypeValueNode( const TypeValueNode &other )
-	: ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
+//##############################################################################
+
+TypeValueNode::TypeValueNode( DeclarationNode *decl ) : decl( decl ) {
+}
+
+TypeValueNode::TypeValueNode( const TypeValueNode &other ) : ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
 }
 
@@ -712,14 +735,12 @@
 
 ExpressionNode *flattenCommas( ExpressionNode *list ) {
-	if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) )
-		{
-			OperatorNode *op;
-			if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) )
-				{
-					if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
-						composite->add_arg( next );
-					return flattenCommas( composite->get_args() );
-				}
-		}
+	if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
+		OperatorNode *op;
+		if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) {
+			if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
+				composite->add_arg( next );
+			return flattenCommas( composite->get_args() );
+		} // if
+	} // if
 
 	if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
@@ -734,5 +755,5 @@
 		if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )
 			return composite->get_args();
-	}
+	} // if
 	return tuple;
 }
