Index: src/Parser/ParseNode.cc
===================================================================
--- src/Parser/ParseNode.cc	(revision 5d125e49aa2f2ff1eefe1c255ce478ca86a872a5)
+++ src/Parser/ParseNode.cc	(revision c967ef905a6c69ef3a11863962ad5778f9d23faf)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:26:29 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 15 18:49:25 2016
-// Update Count     : 62
+// Last Modified On : Sun Jul 24 02:17:01 2016
+// Update Count     : 90
 // 
 
@@ -29,4 +29,6 @@
 // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
 // type.
+
+static Type::Qualifiers emptyQualifiers;				// no qualifiers on constants
 
 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
@@ -37,145 +39,113 @@
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
 
-BasicType::Kind literalType( ConstantNode::Type type, string &value ) {
-	BasicType::Kind btype;
-
-	// lexing divides constants into 4 kinds
-	switch ( type ) {
-	  case ConstantNode::Integer:
-		{
-			static const BasicType::Kind kind[2][3] = {
-				{ BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
-				{ BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
-			};
-			bool dec = true, Unsigned = false;			// decimal, unsigned constant
-			int size;									// 0 => int, 1 => long, 2 => long long
-			unsigned long long v;						// converted integral value
-			size_t last = value.length() - 1;			// last character of constant
-
-			if ( value[0] == '0' ) {					// octal/hex constant ?
-				dec = false;
-				if ( last != 0 && checkX( value[1] ) ) { // hex constant ?
-					sscanf( (char *)value.c_str(), "%llx", &v );
-					//printf( "%llx %llu\n", v, v );
-				} else {								// octal constant
-					sscanf( (char *)value.c_str(), "%llo", &v );
-					//printf( "%llo %llu\n", v, v );
-				} // if
-			} else {									// decimal constant ?
-				sscanf( (char *)value.c_str(), "%llu", &v );
-				//printf( "%llu %llu\n", v, v );
-			} // if
-
-			if ( v <= INT_MAX ) {						// signed int
-				size = 0;
-			} else if ( v <= UINT_MAX && ! dec ) {		// unsigned int
-				size = 0;
-				Unsigned = true;						// unsigned
-			} else if ( v <= LONG_MAX ) {				// signed long int
-				size = 1;
-			} else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
-				size = 1;
-				Unsigned = true;						// unsigned long int
-			} else if ( v <= LLONG_MAX ) {				// signed long long int
-				size = 2;
-			} else {									// unsigned long long int
-				size = 2;
-				Unsigned = true;						// unsigned long long int
-			} // if
-
-			if ( checkU( value[last] ) ) {				// suffix 'u' ?
-				Unsigned = true;
-				if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'l' ?
-					size = 1;
-					if ( last > 1 && checkL( value[ last - 2 ] ) ) { // suffix 'll' ?
-						size = 2;
-					} // if
-				} // if
-			} else if ( checkL( value[ last ] ) ) {		// suffix 'l' ?
-				size = 1;
-				if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'll' ?
-					size = 2;
-					if ( last > 1 && checkU( value[ last - 2 ] ) ) { // suffix 'u' ?
-						Unsigned = true;
-					} // if
-				} else {
-					if ( last > 0 && checkU( value[ last - 1 ] ) ) { // suffix 'u' ?
-						Unsigned = true;
-					} // if
-				} // if
-			} // if
-			btype = kind[Unsigned][size];				// lookup constant type
-			break;
-		}
-	  case ConstantNode::Float:
-		{
-			//long double v;
-			static const BasicType::Kind kind[2][3] = {
-				{ BasicType::Float, BasicType::Double, BasicType::LongDouble },
-				{ BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
-			};
-			bool complx = false;						// real, complex
-			int size = 1;								// 0 => float, 1 => double (default), 2 => long double
-			// floating-point constant has minimum of 2 characters: 1. or .1
-			size_t last = value.length() - 1;
-
-			if ( checkI( value[last] ) ) {				// imaginary ?
-				complx = true;
-				last -= 1;								// backup one character
-			} // if
-
-			//sscanf( (char *)value.c_str(), "%Lf", &v );
-			//printf( "%s %24.22Lf %Lf\n", value.c_str(), v, v );
-
-			if ( checkF( value[last] ) ) {				// float ?
-				size = 0;
-			} else if ( checkD( value[last] ) ) {		// double ?
-				size = 1;
-			} else if ( checkL( value[last] ) ) {		// long double ?
+ConstantNode *makeConstantInteger( std::string & str ) {
+	static const BasicType::Kind kind[2][3] = {
+		{ BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
+		{ BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
+	};
+	bool dec = true, Unsigned = false;					// decimal, unsigned constant
+	int size;											// 0 => int, 1 => long, 2 => long long
+	unsigned long long v;								// converted integral value
+	size_t last = str.length() - 1;						// last character of constant
+
+	if ( str[0] == '0' ) {								// octal/hex constant ?
+		dec = false;
+		if ( last != 0 && checkX( str[1] ) ) {			// hex constant ?
+			sscanf( (char *)str.c_str(), "%llx", &v );
+			//printf( "%llx %llu\n", v, v );
+		} else {										// octal constant
+			sscanf( (char *)str.c_str(), "%llo", &v );
+			//printf( "%llo %llu\n", v, v );
+		} // if
+	} else {											// decimal constant ?
+		sscanf( (char *)str.c_str(), "%llu", &v );
+		//printf( "%llu %llu\n", v, v );
+	} // if
+
+	if ( v <= INT_MAX ) {								// signed int
+		size = 0;
+	} else if ( v <= UINT_MAX && ! dec ) {				// unsigned int
+		size = 0;
+		Unsigned = true;								// unsigned
+	} else if ( v <= LONG_MAX ) {						// signed long int
+		size = 1;
+	} else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
+		size = 1;
+		Unsigned = true;								// unsigned long int
+	} else if ( v <= LLONG_MAX ) {						// signed long long int
+		size = 2;
+	} else {											// unsigned long long int
+		size = 2;
+		Unsigned = true;								// unsigned long long int
+	} // if
+
+	if ( checkU( str[last] ) ) {						// suffix 'u' ?
+		Unsigned = true;
+		if ( last > 0 && checkL( str[last - 1] ) ) {	// suffix 'l' ?
+			size = 1;
+			if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?
 				size = 2;
 			} // if
-			if ( ! complx && checkI( value[last - 1] ) ) { // imaginary ?
-				complx = true;
+		} // if
+	} else if ( checkL( str[ last ] ) ) {				// suffix 'l' ?
+		size = 1;
+		if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'll' ?
+			size = 2;
+			if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?
+				Unsigned = true;
 			} // if
-			btype = kind[complx][size];					// lookup constant type
-			break;
-		}
-	  case ConstantNode::Character:
-		btype = BasicType::Char;						// default
-		if ( string( "LUu" ).find( value[0] ) != string::npos ) {
-			// ???
-		} // if
-		break;
-	  case ConstantNode::String:
-		assert( false );
-		// array of char
-		if ( string( "LUu" ).find( value[0] ) != string::npos ) {
-			if ( value[0] == 'u' && value[1] == '8' ) {
-				// ???
-			} else {
-				// ???
+		} else {
+			if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?
+				Unsigned = true;
 			} // if
 		} // if
-		break;
-	} // switch
-	return btype;
-} // literalType
-
-
-ConstantNode *makeConstant( ConstantNode::Type type, std::string *str ) {
-	::Type::Qualifiers emptyQualifiers;					// no qualifiers on constants
-	return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, literalType( type, *str ) ), *str ), nullptr ) );
-}
-
-ConstantNode *makeConstantStr( ConstantNode::Type type, std::string *str ) {
-	::Type::Qualifiers emptyQualifiers;					// no qualifiers on constants
+	} // if
+
+	return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ), nullptr ) );
+} // makeConstantInteger
+
+ConstantNode *makeConstantFloat( std::string & str ) {
+	static const BasicType::Kind kind[2][3] = {
+		{ BasicType::Float, BasicType::Double, BasicType::LongDouble },
+		{ BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
+	};
+
+	bool complx = false;								// real, complex
+	int size = 1;										// 0 => float, 1 => double (default), 2 => long double
+	// floating-point constant has minimum of 2 characters: 1. or .1
+	size_t last = str.length() - 1;
+
+	if ( checkI( str[last] ) ) {						// imaginary ?
+		complx = true;
+		last -= 1;										// backup one character
+	} // if
+
+	if ( checkF( str[last] ) ) {						// float ?
+		size = 0;
+	} else if ( checkD( str[last] ) ) {					// double ?
+		size = 1;
+	} else if ( checkL( str[last] ) ) {					// long double ?
+		size = 2;
+	} // if
+	if ( ! complx && checkI( str[last - 1] ) ) {		// imaginary ?
+		complx = true;
+	} // if
+
+	return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ), nullptr ) );
+} // makeConstantFloat
+
+ConstantNode *makeConstantChar( std::string & str ) {
+	return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ), nullptr ) );
+} // makeConstantChar
+
+ConstantNode *makeConstantStr( std::string & str ) {
 	// string should probably be a primitive type
 	ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ),
 								   new ConstantExpr(
 									   Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),
-												 toString( str->size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
+												 toString( str.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
 								   false, false );
-	return new ConstantNode( new ConstantExpr( Constant( at, *str ), nullptr ) );
-}
+	return new ConstantNode( new ConstantExpr( Constant( at, str ), nullptr ) );
+} // makeConstantStr
 
 
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision 5d125e49aa2f2ff1eefe1c255ce478ca86a872a5)
+++ src/Parser/ParseNode.h	(revision c967ef905a6c69ef3a11863962ad5778f9d23faf)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul 12 20:50:21 2016
-// Update Count     : 261
+// Last Modified On : Sun Jul 24 02:17:00 2016
+// Update Count     : 269
 //
 
@@ -141,6 +141,8 @@
 };
 
-ConstantNode *makeConstant( ConstantNode::Type, std::string * );
-ConstantNode *makeConstantStr( ConstantNode::Type type, std::string *str );
+ConstantNode *makeConstantInteger( std::string & );
+ConstantNode *makeConstantFloat( std::string & );
+ConstantNode *makeConstantChar( std::string & );
+ConstantNode *makeConstantStr( std::string & );
 
 class VarRefNode : public ExpressionNode {
Index: src/Parser/parser.cc
===================================================================
--- src/Parser/parser.cc	(revision 5d125e49aa2f2ff1eefe1c255ce478ca86a872a5)
+++ src/Parser/parser.cc	(revision c967ef905a6c69ef3a11863962ad5778f9d23faf)
@@ -5235,5 +5235,5 @@
 /* Line 1806 of yacc.c  */
 #line 305 "parser.yy"
-    { (yyval.constant) = makeConstant( ConstantNode::Integer, (yyvsp[(1) - (1)].tok) ); }
+    { (yyval.constant) = makeConstantInteger( *(yyvsp[(1) - (1)].tok) ); }
     break;
 
@@ -5242,5 +5242,5 @@
 /* Line 1806 of yacc.c  */
 #line 306 "parser.yy"
-    { (yyval.constant) = makeConstant( ConstantNode::Float, (yyvsp[(1) - (1)].tok) ); }
+    { (yyval.constant) = makeConstantFloat( *(yyvsp[(1) - (1)].tok) ); }
     break;
 
@@ -5249,5 +5249,5 @@
 /* Line 1806 of yacc.c  */
 #line 307 "parser.yy"
-    { (yyval.constant) = makeConstant( ConstantNode::Character, (yyvsp[(1) - (1)].tok) ); }
+    { (yyval.constant) = makeConstantChar( *(yyvsp[(1) - (1)].tok) ); }
     break;
 
@@ -5256,5 +5256,5 @@
 /* Line 1806 of yacc.c  */
 #line 332 "parser.yy"
-    { (yyval.constant) = makeConstantStr( ConstantNode::String, (yyvsp[(1) - (1)].tok) ); }
+    { (yyval.constant) = makeConstantStr( *(yyvsp[(1) - (1)].tok) ); }
     break;
 
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 5d125e49aa2f2ff1eefe1c255ce478ca86a872a5)
+++ src/Parser/parser.yy	(revision c967ef905a6c69ef3a11863962ad5778f9d23faf)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul 12 20:52:53 2016
-// Update Count     : 1661
+// Last Modified On : Sat Jul 23 17:01:30 2016
+// Update Count     : 1668
 //
 
@@ -303,7 +303,7 @@
 constant:
 		// ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
-INTEGERconstant									{ $$ = makeConstant( ConstantNode::Integer, $1 ); }
-	| FLOATINGconstant							{ $$ = makeConstant( ConstantNode::Float, $1 ); }
-	| CHARACTERconstant							{ $$ = makeConstant( ConstantNode::Character, $1 ); }
+INTEGERconstant									{ $$ = makeConstantInteger( *$1 ); }
+	| FLOATINGconstant							{ $$ = makeConstantFloat( *$1 ); }
+	| CHARACTERconstant							{ $$ = makeConstantChar( *$1 ); }
 	;
 
@@ -330,5 +330,5 @@
 
 string_literal_list:									// juxtaposed strings are concatenated
-	STRINGliteral								{ $$ = makeConstantStr( ConstantNode::String, $1 ); }
+	STRINGliteral								{ $$ = makeConstantStr( *$1 ); }
 	| string_literal_list STRINGliteral			{ $$ = $1->appendstr( $2 ); }
 	;
