Index: translator/Parser/lex.l
===================================================================
--- translator/Parser/lex.l	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/lex.l	(revision b87a5edee8b2aa6c36e184150ebd60baf4c64251)
@@ -1,7 +1,7 @@
-/*                               -*- Mode: C -*- 
- * 
- * CForall Lexer Version 1.0, Copyright (C) Peter A. Buhr 2001 -- Permission is granted to copy this
- *	grammar and to use it within software systems.  THIS GRAMMAR IS PROVIDED "AS IS" AND WITHOUT
- *	ANY EXPRESS OR IMPLIED WARRANTIES.
+/*
+ * Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+ *
+ * The contents of this file are covered under the licence agreement in the
+ * file "LICENCE" distributed with Cforall.
  * 
  * lex.l -- 
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Wed Jan 21 08:43:59 2015
- * Update Count     : 320
+ * Last Modified On : Sat May 16 12:14:18 2015
+ * Update Count     : 330
  */
 
@@ -17,8 +17,7 @@
 
 %{
-// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor
-// directive have been performed and removed from the source. The only exceptions are preprocessor
-// directives passed to the compiler (e.g., line-number directives) and C/C++ style comments, which
-// are ignored.
+// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor directive
+// have been performed and removed from the source. The only exceptions are preprocessor directives passed to
+// the compiler (e.g., line-number directives) and C/C++ style comments, which are ignored.
 
 //**************************** Includes and Defines ****************************
@@ -28,41 +27,41 @@
 #include "lex.h"
 #include "ParseNode.h"
-#include "cfa.tab.h" // YACC generated definitions based on C++ grammar
+#include "cfa.tab.h"									// YACC generated definitions based on C++ grammar
 
 char *yyfilename;
-std::string *strtext;					// accumulate parts of character and string constant value
-
-#define WHITE_RETURN(x)					// do nothing
+std::string *strtext;									// accumulate parts of character and string constant value
+
+#define WHITE_RETURN(x)									// do nothing
 #define NEWLINE_RETURN()	WHITE_RETURN('\n')
 #define RETURN_VAL(x)		yylval.tok.str = new std::string(yytext); \
-                                yylval.tok.loc.file = yyfilename; \
-                                yylval.tok.loc.line = yylineno; \
-                                return(x)
+		                        yylval.tok.loc.file = yyfilename; \
+		                        yylval.tok.loc.line = yylineno; \
+		                        return(x)
 #define RETURN_STR(x)		yylval.tok.str = strtext; \
-                                yylval.tok.loc.file = yyfilename; \
-                                yylval.tok.loc.line = yylineno; \
-                                return(x)
-
-#define KEYWORD_RETURN(x)	RETURN_VAL(x)		// keyword
+		                        yylval.tok.loc.file = yyfilename; \
+		                        yylval.tok.loc.line = yylineno; \
+		                        return(x)
+
+#define KEYWORD_RETURN(x)	RETURN_VAL(x)				// keyword
 #define IDENTIFIER_RETURN()	RETURN_VAL((typedefTable.isIdentifier(yytext) ? IDENTIFIER : typedefTable.isTypedef(yytext) ? TYPEDEFname : TYPEGENname))
 //#define ATTRIBUTE_RETURN()	RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname))
 #define ATTRIBUTE_RETURN()	RETURN_VAL(ATTR_IDENTIFIER)
 
-#define ASCIIOP_RETURN()	RETURN_VAL((int)yytext[0]) // single character operator
-#define NAMEDOP_RETURN(x)	RETURN_VAL(x)		// multichar operator, with a name
+#define ASCIIOP_RETURN()	RETURN_VAL((int)yytext[0])	// single character operator
+#define NAMEDOP_RETURN(x)	RETURN_VAL(x)				// multichar operator, with a name
 
 #define NUMERIC_RETURN(x)	rm_underscore(); RETURN_VAL(x) // numeric constant
 
 void rm_underscore() {
-    // remove underscores in numeric constant
-    int j = 0;
-    for ( int i = 0; yytext[i] != '\0'; i += 1 ) {
-	if ( yytext[i] != '_' ) {
-	    yytext[j] = yytext[i];
-	    j += 1;
-	} // if
-    } // for
-    yyleng = j;
-    yytext[yyleng] = '\0';
+	// remove underscores in numeric constant
+	int j = 0;
+	for ( int i = 0; yytext[i] != '\0'; i += 1 ) {
+		if ( yytext[i] != '_' ) {
+			yytext[j] = yytext[i];
+			j += 1;
+		} // if
+	} // for
+	yyleng = j;
+	yytext[yyleng] = '\0';
 }
 
@@ -75,14 +74,14 @@
 universal_char "\\"((u"_"?{hex_quad})|(U"_"?{hex_quad}{2}))
 
-	// identifier, GCC: $ in identifier
+				// identifier, GCC: $ in identifier
 identifier ([a-zA-Z_$]|{universal_char})([0-9a-zA-Z_$]|{universal_char})*
 
-	// quoted identifier
+				// quoted identifier
 quoted_identifier "`"{identifier}"`"
 
-	// attribute identifier, GCC: $ in identifier
+				// attribute identifier, GCC: $ in identifier
 attr_identifier "@"{identifier}
 
-	// numeric constants, CFA: '_' in constant
+				// numeric constants, CFA: '_' in constant
 hex_quad {hex}("_"?{hex}){3}
 integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?)
@@ -109,12 +108,12 @@
 hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})|({hex_digits}{binary_exponent})){floating_suffix}?
 
-	// character escape sequence, GCC: \e => esc character
+				// character escape sequence, GCC: \e => esc character
 simple_escape "\\"[abefnrtv'"?\\]
-	// ' stop highlighting
+				// ' stop highlighting
 octal_escape "\\"{octal}("_"?{octal}){0,2}
 hex_escape "\\""x""_"?{hex_digits}
 escape_seq {simple_escape}|{octal_escape}|{hex_escape}|{universal_char}
 
-	// display/white-space characters
+				// display/white-space characters
 h_tab [\011]
 form_feed [\014]
@@ -123,5 +122,5 @@
 h_white [ ]|{h_tab}
 
-	// operators
+				// operators
 op_unary_only "~"|"!"
 op_unary_binary "+"|"-"|"*"
@@ -140,5 +139,5 @@
 
 %%
-	/* line directives */
+				   /* line directives */
 ^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["][^\n]*"\n" {
 	/* " stop highlighting */
@@ -150,130 +149,130 @@
 	begin_string = strchr( end_num, '"' );
 	if ( begin_string ) {
-	    end_string = strchr( begin_string + 1, '"' );
-	    if ( end_string ) {
-		length = end_string - begin_string - 1;
-		filename = new char[ length + 1 ];
-		memcpy( filename, begin_string + 1, length );
-		filename[ length ] = '\0';
-		//std::cout << "file " << filename << " line " << lineno << std::endl;
-		yylineno = lineno;
-		yyfilename = filename;
-	    }
-	}
+		end_string = strchr( begin_string + 1, '"' );
+		if ( end_string ) {
+			length = end_string - begin_string - 1;
+			filename = new char[ length + 1 ];
+			memcpy( filename, begin_string + 1, length );
+			filename[ length ] = '\0';
+			//std::cout << "file " << filename << " line " << lineno << std::endl;
+			yylineno = lineno;
+			yyfilename = filename;
+		} // if
+	} // if
 }
 
-	/* ignore preprocessor directives (for now) */
+				/* ignore preprocessor directives (for now) */
 ^{h_white}*"#"[^\n]*"\n" ;
 
-	/* ignore C style comments */
+				/* ignore C style comments */
 "/*"			{ BEGIN COMMENT; }
 <COMMENT>.|\n		;
 <COMMENT>"*/"		{ BEGIN 0; }
 
-	/* ignore C++ style comments */
+				/* ignore C++ style comments */
 "//"[^\n]*"\n"		;
 
-	/* ignore whitespace */
+				/* ignore whitespace */
 {h_white}+		{ WHITE_RETURN(' '); }
 ({v_tab}|{c_return}|{form_feed})+ { WHITE_RETURN(' '); }
 ({h_white}|{v_tab}|{c_return}|{form_feed})*"\n" { NEWLINE_RETURN(); }
 
-	/* keywords */
-_Alignas		{ KEYWORD_RETURN(ALIGNAS); }	// C11
-_Alignof		{ KEYWORD_RETURN(ALIGNOF); }	// C11
-__alignof		{ KEYWORD_RETURN(ALIGNOF); }	// GCC
-__alignof__		{ KEYWORD_RETURN(ALIGNOF); }	// GCC
-asm			{ KEYWORD_RETURN(ASM); }
-__asm			{ KEYWORD_RETURN(ASM); }	// GCC
-__asm__			{ KEYWORD_RETURN(ASM); }	// GCC
-_Atomic			{ KEYWORD_RETURN(ATOMIC); }	// C11
-__attribute		{ KEYWORD_RETURN(ATTRIBUTE); }	// GCC
-__attribute__		{ KEYWORD_RETURN(ATTRIBUTE); }	// GCC
+				/* keywords */
+_Alignas		{ KEYWORD_RETURN(ALIGNAS); }			// C11
+_Alignof		{ KEYWORD_RETURN(ALIGNOF); }			// C11
+__alignof		{ KEYWORD_RETURN(ALIGNOF); }			// GCC
+__alignof__		{ KEYWORD_RETURN(ALIGNOF); }			// GCC
+asm				{ KEYWORD_RETURN(ASM); }
+__asm			{ KEYWORD_RETURN(ASM); }				// GCC
+__asm__			{ KEYWORD_RETURN(ASM); }				// GCC
+_Atomic			{ KEYWORD_RETURN(ATOMIC); }				// C11
+__attribute		{ KEYWORD_RETURN(ATTRIBUTE); }			// GCC
+__attribute__	{ KEYWORD_RETURN(ATTRIBUTE); }			// GCC
 auto			{ KEYWORD_RETURN(AUTO); }
-_Bool			{ KEYWORD_RETURN(BOOL); }	// C99
+_Bool			{ KEYWORD_RETURN(BOOL); }				// C99
 break			{ KEYWORD_RETURN(BREAK); }
 case			{ KEYWORD_RETURN(CASE); }
-catch			{ KEYWORD_RETURN(CATCH); }	// CFA
+catch			{ KEYWORD_RETURN(CATCH); }				// CFA
 char			{ KEYWORD_RETURN(CHAR); }
-choose			{ KEYWORD_RETURN(CHOOSE); }	// CFA
-_Complex		{ KEYWORD_RETURN(COMPLEX); }	// C99
-__complex		{ KEYWORD_RETURN(COMPLEX); }	// GCC
-__complex__		{ KEYWORD_RETURN(COMPLEX); }	// GCC
+choose			{ KEYWORD_RETURN(CHOOSE); }				// CFA
+_Complex		{ KEYWORD_RETURN(COMPLEX); }			// C99
+__complex		{ KEYWORD_RETURN(COMPLEX); }			// GCC
+__complex__		{ KEYWORD_RETURN(COMPLEX); }			// GCC
 const			{ KEYWORD_RETURN(CONST); }
-__const			{ KEYWORD_RETURN(CONST); }	// GCC
-__const__		{ KEYWORD_RETURN(CONST); }	// GCC
-context			{ KEYWORD_RETURN(CONTEXT); }	// CFA
+__const			{ KEYWORD_RETURN(CONST); }				// GCC
+__const__		{ KEYWORD_RETURN(CONST); }				// GCC
+context			{ KEYWORD_RETURN(CONTEXT); }			// CFA
 continue		{ KEYWORD_RETURN(CONTINUE); }
 default			{ KEYWORD_RETURN(DEFAULT); }
-do			{ KEYWORD_RETURN(DO); }
+do				{ KEYWORD_RETURN(DO); }
 double			{ KEYWORD_RETURN(DOUBLE); }
-dtype			{ KEYWORD_RETURN(DTYPE); }	// CFA
+dtype			{ KEYWORD_RETURN(DTYPE); }				// CFA
 else			{ KEYWORD_RETURN(ELSE); }
 enum			{ KEYWORD_RETURN(ENUM); }
-__extension__		{ KEYWORD_RETURN(EXTENSION); }	// GCC
+__extension__	{ KEYWORD_RETURN(EXTENSION); }			// GCC
 extern			{ KEYWORD_RETURN(EXTERN); }
-fallthru		{ KEYWORD_RETURN(FALLTHRU); }	// CFA
-finally			{ KEYWORD_RETURN(FINALLY); }	// CFA
+fallthru		{ KEYWORD_RETURN(FALLTHRU); }			// CFA
+finally			{ KEYWORD_RETURN(FINALLY); }			// CFA
 float			{ KEYWORD_RETURN(FLOAT); }
-__float128		{ KEYWORD_RETURN(FLOAT); }	// GCC
-for			{ KEYWORD_RETURN(FOR); }
-forall			{ KEYWORD_RETURN(FORALL); }	// CFA
+__float128		{ KEYWORD_RETURN(FLOAT); }				// GCC
+for				{ KEYWORD_RETURN(FOR); }
+forall			{ KEYWORD_RETURN(FORALL); }				// CFA
 fortran			{ KEYWORD_RETURN(FORTRAN); }
-ftype			{ KEYWORD_RETURN(FTYPE); }	// CFA
-_Generic		{ KEYWORD_RETURN(GENERIC); }	// C11
+ftype			{ KEYWORD_RETURN(FTYPE); }				// CFA
+_Generic		{ KEYWORD_RETURN(GENERIC); }			// C11
 goto			{ KEYWORD_RETURN(GOTO); }
-if			{ KEYWORD_RETURN(IF); }
-_Imaginary		{ KEYWORD_RETURN(IMAGINARY); }	// C99
-__imag			{ KEYWORD_RETURN(IMAGINARY); }	// GCC
-__imag__		{ KEYWORD_RETURN(IMAGINARY); }	// GCC
-inline			{ KEYWORD_RETURN(INLINE); }	// C99
-__inline		{ KEYWORD_RETURN(INLINE); }	// GCC
-__inline__		{ KEYWORD_RETURN(INLINE); }	// GCC
-int			{ KEYWORD_RETURN(INT); }
-__int128		{ KEYWORD_RETURN(INT); }	// GCC
-__label__		{ KEYWORD_RETURN(LABEL); }	// GCC
+if				{ KEYWORD_RETURN(IF); }
+_Imaginary		{ KEYWORD_RETURN(IMAGINARY); }			// C99
+__imag			{ KEYWORD_RETURN(IMAGINARY); }			// GCC
+__imag__		{ KEYWORD_RETURN(IMAGINARY); }			// GCC
+inline			{ KEYWORD_RETURN(INLINE); }				// C99
+__inline		{ KEYWORD_RETURN(INLINE); }				// GCC
+__inline__		{ KEYWORD_RETURN(INLINE); }				// GCC
+int				{ KEYWORD_RETURN(INT); }
+__int128		{ KEYWORD_RETURN(INT); }				// GCC
+__label__		{ KEYWORD_RETURN(LABEL); }				// GCC
 long			{ KEYWORD_RETURN(LONG); }
-lvalue			{ KEYWORD_RETURN(LVALUE); }	// CFA
-_Noreturn		{ KEYWORD_RETURN(NORETURN); }	// C11
+lvalue			{ KEYWORD_RETURN(LVALUE); }				// CFA
+_Noreturn		{ KEYWORD_RETURN(NORETURN); }			// C11
 register		{ KEYWORD_RETURN(REGISTER); }
-restrict		{ KEYWORD_RETURN(RESTRICT); }	// C99
-__restrict		{ KEYWORD_RETURN(RESTRICT); }	// GCC
-__restrict__		{ KEYWORD_RETURN(RESTRICT); }	// GCC
+restrict		{ KEYWORD_RETURN(RESTRICT); }			// C99
+__restrict		{ KEYWORD_RETURN(RESTRICT); }			// GCC
+__restrict__	{ KEYWORD_RETURN(RESTRICT); }			// GCC
 return			{ KEYWORD_RETURN(RETURN); }
 short			{ KEYWORD_RETURN(SHORT); }
 signed			{ KEYWORD_RETURN(SIGNED); }
-__signed		{ KEYWORD_RETURN(SIGNED); }	// GCC
-__signed__		{ KEYWORD_RETURN(SIGNED); }	// GCC
+__signed		{ KEYWORD_RETURN(SIGNED); }				// GCC
+__signed__		{ KEYWORD_RETURN(SIGNED); }				// GCC
 sizeof			{ KEYWORD_RETURN(SIZEOF); }
 static			{ KEYWORD_RETURN(STATIC); }
-_Static_assert		{ KEYWORD_RETURN(STATICASSERT); } // C11
+_Static_assert	{ KEYWORD_RETURN(STATICASSERT); }		// C11
 struct			{ KEYWORD_RETURN(STRUCT); }
 switch			{ KEYWORD_RETURN(SWITCH); }
-_Thread_local		{ KEYWORD_RETURN(THREADLOCAL); } // C11
-throw			{ KEYWORD_RETURN(THROW); }	// CFA
-try			{ KEYWORD_RETURN(TRY); }	// CFA
-type			{ KEYWORD_RETURN(TYPE); }	// CFA
+_Thread_local	{ KEYWORD_RETURN(THREADLOCAL); }		// C11
+throw			{ KEYWORD_RETURN(THROW); }				// CFA
+try				{ KEYWORD_RETURN(TRY); }				// CFA
+type			{ KEYWORD_RETURN(TYPE); }				// CFA
 typedef			{ KEYWORD_RETURN(TYPEDEF); }
-typeof			{ KEYWORD_RETURN(TYPEOF); }	// GCC
-__typeof		{ KEYWORD_RETURN(TYPEOF); }	// GCC
-__typeof__		{ KEYWORD_RETURN(TYPEOF); }	// GCC
+typeof			{ KEYWORD_RETURN(TYPEOF); }				// GCC
+__typeof		{ KEYWORD_RETURN(TYPEOF); }				// GCC
+__typeof__		{ KEYWORD_RETURN(TYPEOF); }				// GCC
 union			{ KEYWORD_RETURN(UNION); }
 unsigned		{ KEYWORD_RETURN(UNSIGNED); }
 void			{ KEYWORD_RETURN(VOID); }
 volatile		{ KEYWORD_RETURN(VOLATILE); }
-__volatile		{ KEYWORD_RETURN(VOLATILE); }	// GCC
-__volatile__		{ KEYWORD_RETURN(VOLATILE); }	// GCC
+__volatile		{ KEYWORD_RETURN(VOLATILE); }			// GCC
+__volatile__	{ KEYWORD_RETURN(VOLATILE); }			// GCC
 while			{ KEYWORD_RETURN(WHILE); }
 
-	/* identifier */
-{identifier}		{ IDENTIFIER_RETURN(); }
-{attr_identifier}	{ ATTRIBUTE_RETURN(); }
+				/* identifier */
+{identifier}	{ IDENTIFIER_RETURN(); }
+{attr_identifier} { ATTRIBUTE_RETURN(); }
 "`"			{ BEGIN BKQUOTE; }
-<BKQUOTE>{identifier}	{ IDENTIFIER_RETURN(); }
-<BKQUOTE>"`"		{ BEGIN 0; }
-
-	/* numeric constants */
-"0"			{ NUMERIC_RETURN(ZERO); }	// CFA
-"1"			{ NUMERIC_RETURN(ONE); }	// CFA
+<BKQUOTE>{identifier} { IDENTIFIER_RETURN(); }
+<BKQUOTE>"`"	{ BEGIN 0; }
+
+				/* numeric constants */
+"0"				{ NUMERIC_RETURN(ZERO); }				// CFA
+"1"				{ NUMERIC_RETURN(ONE); }				// CFA
 {decimal_constant}	{ NUMERIC_RETURN(INTEGERconstant); }
 {octal_constant}	{ NUMERIC_RETURN(INTEGERconstant); }
@@ -282,33 +281,33 @@
 {hex_floating_constant}	{ NUMERIC_RETURN(FLOATINGconstant); }
 
-	/* character constant, allows empty value */
+				/* character constant, allows empty value */
 "L"?"_"?[']		{ BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
-<QUOTE>[^'\\\n]*	{ *strtext += std::string( yytext ); }
-<QUOTE>['\n]		{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
-	/* ' stop highlighting */
-
-	/* string constant */
+<QUOTE>[^'\\\n]* { *strtext += std::string( yytext ); }
+<QUOTE>['\n]	{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
+				/* ' stop highlighting */
+
+				/* string constant */
 "L"?"_"?["]		{ BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
-<STRING>[^"\\\n]*	{ *strtext += std::string( yytext ); }
-<STRING>["\n]		{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(STRINGliteral); }
-	/* " stop highlighting */
+<STRING>[^"\\\n]* { *strtext += std::string( yytext ); }
+<STRING>["\n]	{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(STRINGliteral); }
+				/* " stop highlighting */
 
 <QUOTE,STRING>{escape_seq} { rm_underscore(); *strtext += std::string( yytext ); }
 <QUOTE,STRING>[\\]	{ *strtext += std::string( yytext ); } // unknown escape character
 
-	/* punctuation */
-"["			{ ASCIIOP_RETURN(); }
-"]"			{ ASCIIOP_RETURN(); }
-"("			{ ASCIIOP_RETURN(); }
-")"			{ ASCIIOP_RETURN(); }
-"{"			{ ASCIIOP_RETURN(); }
-"}"			{ ASCIIOP_RETURN(); }
-","			{ ASCIIOP_RETURN(); }		// also operator
-":"			{ ASCIIOP_RETURN(); }
-";"			{ ASCIIOP_RETURN(); }
-"."			{ ASCIIOP_RETURN(); }		// also operator
+				/* punctuation */
+"["				{ ASCIIOP_RETURN(); }
+"]"				{ ASCIIOP_RETURN(); }
+"("				{ ASCIIOP_RETURN(); }
+")"				{ ASCIIOP_RETURN(); }
+"{"				{ ASCIIOP_RETURN(); }
+"}"				{ ASCIIOP_RETURN(); }
+","				{ ASCIIOP_RETURN(); }					// also operator
+":"				{ ASCIIOP_RETURN(); }
+";"				{ ASCIIOP_RETURN(); }
+"."				{ ASCIIOP_RETURN(); }					// also operator
 "..."			{ NAMEDOP_RETURN(ELLIPSIS); }
 
-	/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
+				/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
 "<:"			{ RETURN_VAL('['); }
 ":>"			{ RETURN_VAL(']'); }
@@ -316,19 +315,19 @@
 "%>"			{ RETURN_VAL('}'); }
 
-	/* operators */
-"!"			{ ASCIIOP_RETURN(); }
-"+"			{ ASCIIOP_RETURN(); }
-"-"			{ ASCIIOP_RETURN(); }
-"*"			{ ASCIIOP_RETURN(); }
-"/"			{ ASCIIOP_RETURN(); }
-"%"			{ ASCIIOP_RETURN(); }
-"^"			{ ASCIIOP_RETURN(); }
-"~"			{ ASCIIOP_RETURN(); }
-"&"			{ ASCIIOP_RETURN(); }
-"|"			{ ASCIIOP_RETURN(); }
-"<"			{ ASCIIOP_RETURN(); }
-">"			{ ASCIIOP_RETURN(); }
-"="			{ ASCIIOP_RETURN(); }
-"?"			{ ASCIIOP_RETURN(); }
+				/* operators */
+"!"				{ ASCIIOP_RETURN(); }
+"+"				{ ASCIIOP_RETURN(); }
+"-"				{ ASCIIOP_RETURN(); }
+"*"				{ ASCIIOP_RETURN(); }
+"/"				{ ASCIIOP_RETURN(); }
+"%"				{ ASCIIOP_RETURN(); }
+"^"				{ ASCIIOP_RETURN(); }
+"~"				{ ASCIIOP_RETURN(); }
+"&"				{ ASCIIOP_RETURN(); }
+"|"				{ ASCIIOP_RETURN(); }
+"<"				{ ASCIIOP_RETURN(); }
+">"				{ ASCIIOP_RETURN(); }
+"="				{ ASCIIOP_RETURN(); }
+"?"				{ ASCIIOP_RETURN(); }
 
 "++"			{ NAMEDOP_RETURN(ICR); }
@@ -354,22 +353,20 @@
 ">>="			{ NAMEDOP_RETURN(RSassign); }
 
-	/* CFA, operator identifier */
-{op_unary}"?"		{ IDENTIFIER_RETURN(); }	// unary
+				/* CFA, operator identifier */
+{op_unary}"?"	{ IDENTIFIER_RETURN(); }				// unary
 "?"({op_unary_pre_post}|"()"|"[?]") { IDENTIFIER_RETURN(); }
-"?"{op_binary_over}"?"	{ IDENTIFIER_RETURN(); }	// binary
+"?"{op_binary_over}"?"	{ IDENTIFIER_RETURN(); }		// binary
 	/*
-	  This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the
-	  string "*?*?"  can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put
-	  a unary operator juxtaposed to an identifier, e.g., "*i", users will be annoyed if they
-	  cannot do this with respect to operator identifiers. Even with this special hack, there
-	  are 5 general cases that cannot be handled. The first case is for the function-call
-	  identifier "?()":
+	  This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the string "*?*?"
+	  can be lexed as "*"/"?*?" or "*?"/"*?". Since it is common practise to put a unary operator juxtaposed
+	  to an identifier, e.g., "*i", users will be annoyed if they cannot do this with respect to operator
+	  identifiers. Even with this special hack, there are 5 general cases that cannot be handled. The first
+	  case is for the function-call identifier "?()":
 
 	  int * ?()();	// declaration: space required after '*'
 	  * ?()();	// expression: space required after '*'
 
-	  Without the space, the string "*?()" is ambiguous without N character look ahead; it
-	  requires scanning ahead to determine if there is a '(', which is the start of an
-	  argument/parameter list.
+	  Without the space, the string "*?()" is ambiguous without N character look ahead; it requires scanning
+	  ahead to determine if there is a '(', which is the start of an argument/parameter list.
 
 	  The 4 remaining cases occur in expressions:
@@ -380,29 +377,30 @@
 	  i?--i:0;		// space required after '?'
 
-	  In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as
-	  "i"/"++?" or "i++"/"?"; it requires scanning ahead to determine if there is a '(', which
-	  is the start of an argument list.  In the second two cases, the string "?++x" is
-	  ambiguous, where this string can be lexed as "?++"/"x" or "?"/"++x"; it requires scanning
-	  ahead to determine if there is a '(', which is the start of an argument list.
+	  In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as "i"/"++?" or
+	  "i++"/"?"; it requires scanning ahead to determine if there is a '(', which is the start of an argument
+	  list.  In the second two cases, the string "?++x" is ambiguous, where this string can be lexed as
+	  "?++"/"x" or "?"/"++x"; it requires scanning ahead to determine if there is a '(', which is the start of
+	  an argument list.
 	*/
 {op_unary}"?"(({op_unary_pre_post}|"[?]")|({op_binary_over}"?")) {
-			    // 1 or 2 character unary operator ?
-			    int i = yytext[1] == '?' ? 1 : 2;
-			    yyless( i );		// put back characters up to first '?'
-			    if ( i > 1 ) {
-				NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR );
-			    } else {
-				ASCIIOP_RETURN();
-			    } // if
-			}
-
-	/* unknown characters */
+	// 1 or 2 character unary operator ?
+	int i = yytext[1] == '?' ? 1 : 2;
+	yyless( i );		// put back characters up to first '?'
+	if ( i > 1 ) {
+		NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR );
+	} else {
+		ASCIIOP_RETURN();
+	} // if
+}
+
+				/* unknown characters */
 .			{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
 
 %%
 
-
-// Local Variables:
-// fill-column: 100
-// compile-command: "make"
-// End:
+// Local Variables: //
+// fill-column: 110 //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
