Index: src/Parser/lex.ll
===================================================================
--- src/Parser/lex.ll	(revision 8bcaf2153e69191156a09e255e9103b37ffc4249)
+++ src/Parser/lex.ll	(revision daf9671439895f6d3bdd15ca16d77fa736b00a4c)
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Thu May 18 09:03:49 2017
- * Update Count     : 513
+ * Last Modified On : Mon May 22 07:46:30 2017
+ * Update Count     : 525
  */
 
@@ -377,30 +377,30 @@
 "?"{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 "?()":
-
-	  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.
-
-	  The 4 remaining cases occur in expressions:
-
-	  i++?i:0;		// space required before '?'
-	  i--?i:0;		// space required before '?'
-	  i?++i:0;		// space required after '?'
-	  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.
+	  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. Therefore, there is
+	  a lexical look-ahead for the second case, with backtracking to return the leading unary operator and then
+	  reparsing the trailing operator identifier.  Otherwise a space is needed between the unary operator and operator
+	  identifier to disambiguate this common case.
+
+	  A similar issue occurs with the dereference, *?(...), and routine-call, ?()(...) identifiers.  The ambiguity
+	  occurs when the deference operator has no parameters, *?() and *?()(...), requiring arbitrary whitespace
+	  look-ahead for the routine-call parameter-list to disambiguate.  However, the dereference operator must have a
+	  parameter/argument to dereference *?(...).  Hence, always interpreting the string *?() as * ?() does not preclude
+	  any meaningful program.
+
+	  The remaining cases are with the increment/decrement operators and conditional expression:
+
+	  i++? ...(...);
+	  i?++ ...(...);
+
+	  requiring arbitrary whitespace look-ahead for the operator parameter-list, even though that interpretation is an
+      incorrect expression (juxtaposed identifiers).  Therefore, it is necessary to disambiguate these cases with a
+      space:
+
+	  i++ ? i : 0;
+	  i? ++i : 0;
 	*/
-{op_unary}"?"({op_unary_pre_post}|"[?]"|{op_binary_over}"?") {
+{op_unary}"?"({op_unary_pre_post}|"()"|"[?]"|{op_binary_over}"?") {
 	// 1 or 2 character unary operator ?
 	int i = yytext[1] == '?' ? 1 : 2;