Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision 51e076eafc08b318b66f0daf4086126420c95efe)
+++ src/Parser/ExpressionNode.cc	(revision 97065543cf1b9f9729488075aec62a4941f19f0d)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Aug  5 07:56:23 2016
-// Update Count     : 375
+// Last Modified On : Fri Aug  5 11:39:25 2016
+// Update Count     : 391
 //
 
@@ -289,5 +289,5 @@
 }
 
-CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
+CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 ):
 	function( f ), arguments( arg1 ) {
 	arguments->set_link( arg2 );
@@ -369,10 +369,15 @@
 }
 
-Expression *build_opr1( OperatorNode::Type op, ExpressionNode *expr_node ) {
+Expression *build_unary_val( OperatorNode::Type op, ExpressionNode *expr_node ) {
+	std::list<Expression *> args;
+	args.push_back( maybeBuild<Expression>(expr_node) );
+	return new UntypedExpr( new NameExpr( opName[ op ] ), args );
+}
+Expression *build_unary_ptr( OperatorNode::Type op, ExpressionNode *expr_node ) {
 	std::list<Expression *> args;
 	args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) );
 	return new UntypedExpr( new NameExpr( opName[ op ] ), args );
 }
-Expression *build_opr2( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
+Expression *build_binary_val( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
 	std::list<Expression *> args;
 	args.push_back( maybeBuild<Expression>(expr_node1) );
@@ -380,4 +385,10 @@
 	return new UntypedExpr( new NameExpr( opName[ op ] ), args );
 }
+Expression *build_binary_ptr( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
+	std::list<Expression *> args;
+	args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node1) ) );
+	args.push_back( maybeBuild<Expression>(expr_node2) );
+	return new UntypedExpr( new NameExpr( opName[ op ] ), args );
+}
 
 Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {
@@ -387,4 +398,25 @@
 Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
 	return new CommaExpr( maybeBuild<Expression>(expr_node1), maybeBuild<Expression>(expr_node2) );
+}
+
+Expression *build_attr( VarRefNode *var, ExpressionNode * expr ) {
+	if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr ) ) {
+		return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() );
+	} else {
+		return new AttrExpr( maybeBuild<Expression>(var), maybeBuild<Expression>(expr) );
+	} // if
+}
+
+Expression *build_tuple( ExpressionNode * expr ) {
+	TupleExpr *ret = new TupleExpr();
+	buildList( expr, ret->get_exprs() );
+	return ret;
+}
+
+Expression *build_func( ExpressionNode * function, ExpressionNode * expr ) {
+	std::list<Expression *> args;
+
+	buildList( expr, args );
+	return new UntypedExpr( maybeBuild<Expression>(function), args, nullptr );
 }
 
@@ -406,60 +438,6 @@
 	} // if
 
-	switch ( op->get_type() ) {
-	  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:
-		assert( ! args.empty() );
-		args.front() = new AddressExpr( args.front() );
-	  case OperatorNode::UnPlus:
-	  case OperatorNode::UnMinus:
-	  case OperatorNode::PointTo:
-	  case OperatorNode::Neg:
-	  case OperatorNode::BitNeg:
-	  case OperatorNode::LabelAddress:
-		return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
-
-	  case OperatorNode::Attr:
-		{
-			VarRefNode *var = dynamic_cast<VarRefNode *>( get_args() );
-			assert( var );
-			if ( ! get_args()->get_link() ) {
-				return new AttrExpr( maybeBuild<Expression>(var), ( Expression*)0);
-			} else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link() ) ) {
-				return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() );
-			} else {
-				return new AttrExpr( maybeBuild<Expression>(var), args.back() );
-			} // if
-		}
-	  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" );
-		// Tuples
-	  case OperatorNode::TupleC:
-		{
-			TupleExpr *ret = new TupleExpr();
-			std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
-			return ret;
-		}
-	  default:
-		assert( ((void)"CompositeExprNode::build", false) );
-		return 0;
-	} // switch
+	assert( ((void)"CompositeExprNode::build", false) );
+	return nullptr;
 }
 
