Changeset b1e63ac5 for src/Parser/lex.ll

Timestamp:

Jul 4, 2017, 9:40:16 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

208e5be

Parents:

9c951e3 (diff), f7cb0bc (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into references

File:

• src/Parser/lex.ll (modified) (6 diffs)

src/Parser/lex.ll

@@ -5 +5 @@
  * file "LICENCE" distributed with Cforall.
  *
- * lex.l --
+ * lex.ll --
  *
  * Author           : Peter A. Buhr
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Mon Mar 13 08:36:17 2017
- * Update Count     : 506
+ * Last Modified On : Wed Jun 28 21:03:45 2017
+ * Update Count     : 529
  */
 
@@ -27 +27 @@
 #include <cstdio>                                                                               // FILENAME_MAX
 
-#include "lex.h"
-#include "parser.h"                                                                             // YACC generated definitions based on C++ grammar
 #include "ParseNode.h"
 #include "TypedefTable.h"
@@ -77 +75 @@
                                 // numeric constants, CFA: '_' in constant
 hex_quad {hex}("_"?{hex}){3}
-integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?)
+integer_suffix "_"?(([uU](("ll"|"LL"|[lL])[iI]|[iI]?("ll"|"LL"|[lL])?))|([iI](("ll"|"LL"|[lL])[uU]|[uU]?("ll"|"LL"|[lL])?))|(("ll"|"LL"|[lL])([iI][uU]|[uU]?[iI]?)))
 
 octal_digits ({octal})|({octal}({octal}|"_")*{octal})
@@ -91 +89 @@
 
 decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
-real_decimal {decimal_digits}"."
-real_fraction "."{decimal_digits}
-real_constant {decimal_digits}?{real_fraction}
+real_decimal {decimal_digits}"."{exponent}?{floating_suffix}?
+real_fraction "."{decimal_digits}{exponent}?{floating_suffix}?
+real_constant {decimal_digits}{real_fraction}
 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
-                                // GCC: D (double), DL (long double) and iI (imaginary) suffixes
-floating_suffix "_"?([fFdDlL][iI]?|"DL"|[iI][lLfFdD]?)
-                                //floating_suffix "_"?([fFdD]|[lL]|[D][L])|([iI][lLfFdD])|([lLfFdD][iI]))
+                                // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
+floating_suffix "_"?([fFdDlL][iI]?|[iI][lLfFdD]?|"DL")
 floating_constant (({real_constant}{exponent}?)|({decimal_digits}{exponent})){floating_suffix}?
 
@@ -236 +233 @@
 long                    { KEYWORD_RETURN(LONG); }
 lvalue                  { KEYWORD_RETURN(LVALUE); }                             // CFA
-monitor         { KEYWORD_RETURN(MONITOR); }                    // CFA
+monitor                 { KEYWORD_RETURN(MONITOR); }                    // CFA
 mutex                   { KEYWORD_RETURN(MUTEX); }                              // CFA
 _Noreturn               { KEYWORD_RETURN(NORETURN); }                   // C11
@@ -378 +375 @@
 "?"{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;