python
diff --git a/‎Parser/lexer/lexer.c‎
Lines changed: 14 additions & 32 deletions b/‎Parser/lexer/lexer.c‎
Lines changed: 14 additions & 32 deletions
diff --git a/‎Parser/lexer/lexer_internal.h‎
Lines changed: 10 additions & 2 deletions b/‎Parser/lexer/lexer_internal.h‎
Lines changed: 10 additions & 2 deletions
diff --git a/‎Parser/lexer/string.c‎
Lines changed: 54 additions & 71 deletions b/‎Parser/lexer/string.c‎
Lines changed: 54 additions & 71 deletions
@@ -432,43 +432,25 @@ _PyLexer_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, str
     nonascii = 0;
     if (is_potential_identifier_start(c)) {
         /* Process the various legal combinations of b"", r"", u"", and f"". */
-        int saw_b = 0, saw_r = 0, saw_u = 0, saw_f = 0, saw_t = 0;
+        unsigned int prefixes = 0;
         while (1) {
-            if (!saw_b && (c == 'b' || c == 'B')) {
-                saw_b = 1;
-            }
-            /* Since this is a backwards compatibility support literal we don't
-               want to support it in arbitrary order like byte literals. */
-            else if (!saw_u && (c == 'u'|| c == 'U')) {
-                saw_u = 1;
-            }
-            /* ur"" and ru"" are not supported */
-            else if (!saw_r && (c == 'r' || c == 'R')) {
-                saw_r = 1;
-            }
-            else if (!saw_f && (c == 'f' || c == 'F')) {
-                saw_f = 1;
-            }
-            else if (!saw_t && (c == 't' || c == 'T')) {
-                saw_t = 1;
-            }
-            else {
+            unsigned int prefix;
+            switch (c) {
+                case 'b': case 'B': prefix = STRING_PREFIX_B; break;
+                case 'r': case 'R': prefix = STRING_PREFIX_R; break;
+                case 'u': case 'U': prefix = STRING_PREFIX_U; break;
+                case 'f': case 'F': prefix = STRING_PREFIX_F; break;
+                case 't': case 'T': prefix = STRING_PREFIX_T; break;
+                default: prefix = 0;
+            }
+            if (prefix == 0 || (prefixes & prefix)) {
                 break;
             }
+            prefixes |= prefix;
             c = tok_nextc(tok);
             if (c == '"' || c == '\'') {
-                // Raise error on incompatible string prefixes:
-                int status = _PyLexer_check_string_prefixes(
-                    tok, saw_b, saw_r, saw_u, saw_f, saw_t);
-                if (status < 0) {
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-
-                // Handle valid f or t string creation:
-                if (saw_f || saw_t) {
-                    return _PyLexer_scan_fstring_start(tok, token, c);
-                }
-                return _PyLexer_scan_string(tok, token, c);
+                return _PyLexer_scan_prefixed_string(
+                    tok, token, c, prefixes);
             }
         }
         while (is_potential_identifier_char(c)) {
 
@@ -17,6 +17,14 @@
                || c == '_'\
                || (c >= 128))
 
+enum string_prefix_flags {
+    STRING_PREFIX_B = 1 << 0,
+    STRING_PREFIX_R = 1 << 1,
+    STRING_PREFIX_U = 1 << 2,
+    STRING_PREFIX_F = 1 << 3,
+    STRING_PREFIX_T = 1 << 4,
+};
+
 #ifdef Py_DEBUG
 static inline tokenizer_mode *
 TOK_GET_MODE(struct tok_state *tok)
@@ -58,9 +66,9 @@ void _PyLexer_update_ftstring_expr(struct tok_state *, char);
 int _PyLexer_record_ftstring_comment(
     struct tok_state *, const char *, const char *);
 int _PyLexer_set_ftstring_expr_metadata(struct tok_state *, struct token *);
-int _PyLexer_check_string_prefixes(struct tok_state *, int, int, int, int, int);
 int _PyLexer_scan_number(struct tok_state *, struct token *, int, int);
-int _PyLexer_scan_fstring_start(struct tok_state *, struct token *, int);
+int _PyLexer_scan_prefixed_string(
+    struct tok_state *, struct token *, int, unsigned int);
 int _PyLexer_scan_string(struct tok_state *, struct token *, int);
 int _PyLexer_get_normal_mode(struct tok_state *, tokenizer_mode *, struct token *);
 int _PyLexer_get_fstring_mode(struct tok_state *, tokenizer_mode *, struct token *);
 
@@ -175,10 +175,9 @@ _PyLexer_update_ftstring_expr(struct tok_state *tok, char cur)
     }
 }
 
-int
-_PyLexer_check_string_prefixes(struct tok_state *tok,
-                                             int saw_b, int saw_r, int saw_u,
-                                             int saw_f, int saw_t) {
+static int
+check_string_prefixes(struct tok_state *tok, unsigned int prefixes)
+{
     // Supported: rb, rf, rt (in any order)
     // Unsupported: ub, ur, uf, ut, bf, bt, ft (in any order)
 
@@ -191,27 +190,27 @@ _PyLexer_check_string_prefixes(struct tok_state *tok,
         return -1;                                                        \
     } while (0)
 
-    if (saw_u && saw_b) {
+    if ((prefixes & STRING_PREFIX_U) && (prefixes & STRING_PREFIX_B)) {
         RETURN_SYNTAX_ERROR("u", "b");
     }
-    if (saw_u && saw_r) {
+    if ((prefixes & STRING_PREFIX_U) && (prefixes & STRING_PREFIX_R)) {
         RETURN_SYNTAX_ERROR("u", "r");
     }
-    if (saw_u && saw_f) {
+    if ((prefixes & STRING_PREFIX_U) && (prefixes & STRING_PREFIX_F)) {
         RETURN_SYNTAX_ERROR("u", "f");
     }
-    if (saw_u && saw_t) {
+    if ((prefixes & STRING_PREFIX_U) && (prefixes & STRING_PREFIX_T)) {
         RETURN_SYNTAX_ERROR("u", "t");
     }
 
-    if (saw_b && saw_f) {
+    if ((prefixes & STRING_PREFIX_B) && (prefixes & STRING_PREFIX_F)) {
         RETURN_SYNTAX_ERROR("b", "f");
     }
-    if (saw_b && saw_t) {
+    if ((prefixes & STRING_PREFIX_B) && (prefixes & STRING_PREFIX_T)) {
         RETURN_SYNTAX_ERROR("b", "t");
     }
 
-    if (saw_f && saw_t) {
+    if ((prefixes & STRING_PREFIX_F) && (prefixes & STRING_PREFIX_T)) {
         RETURN_SYNTAX_ERROR("f", "t");
     }
 
@@ -220,31 +219,37 @@ _PyLexer_check_string_prefixes(struct tok_state *tok,
     return 0;
 }
 
-int
-_PyLexer_scan_fstring_start(struct tok_state *tok, struct token *token, int c)
+static int
+scan_quote_size(struct tok_state *tok, int quote, int *end_quote_size)
+{
+    int first = tok_nextc(tok);
+    if (first != quote) {
+        tok_backup(tok, first);
+        return 1;
+    }
+    int second = tok_nextc(tok);
+    if (second == quote) {
+        return 3;
+    }
+    tok_backup(tok, second);
+    if (end_quote_size == NULL) {
+        tok_backup(tok, first);
+    }
+    else {
+        *end_quote_size = 1;
+    }
+    return 1;
+}
+
+static int
+scan_fstring_start(struct tok_state *tok, struct token *token, int c,
+                   unsigned int prefixes)
 {
     const char *p_start = NULL;
     const char *p_end = NULL;
 
     int quote = c;
-    int quote_size = 1;             /* 1 or 3 */
-
-    /* Find the quote size and start of string */
-    int after_quote = tok_nextc(tok);
-    if (after_quote == quote) {
-        int after_after_quote = tok_nextc(tok);
-        if (after_after_quote == quote) {
-            quote_size = 3;
-        }
-        else {
-            tok_backup(tok, after_after_quote);
-            tok_backup(tok, after_quote);
-        }
-    }
-    if (after_quote != quote) {
-        tok_backup(tok, after_quote);
-    }
-
+    int quote_size = scan_quote_size(tok, quote, NULL);
 
     p_start = tok->start;
     p_end = tok->cur;
@@ -262,61 +267,39 @@ _PyLexer_scan_fstring_start(struct tok_state *tok, struct token *token, int c)
     the_current_tok->in_debug = 0;
     the_current_tok->comments = NULL;
 
-    enum string_kind_t string_kind = FSTRING;
-    switch (*tok->start) {
-        case 'T':
-        case 't':
-            the_current_tok->raw = Py_TOLOWER(*(tok->start + 1)) == 'r';
-            string_kind = TSTRING;
-            break;
-        case 'F':
-        case 'f':
-            the_current_tok->raw = Py_TOLOWER(*(tok->start + 1)) == 'r';
-            break;
-        case 'R':
-        case 'r':
-            the_current_tok->raw = 1;
-            if (Py_TOLOWER(*(tok->start + 1)) == 't') {
-                string_kind = TSTRING;
-            }
-            break;
-        default:
-            Py_UNREACHABLE();
-    }
-
+    the_current_tok->raw = (prefixes & STRING_PREFIX_R) != 0;
+    enum string_kind_t string_kind =
+        prefixes & STRING_PREFIX_T ? TSTRING : FSTRING;
     the_current_tok->string_kind = string_kind;
     the_current_tok->curly_bracket_depth = 0;
     the_current_tok->curly_bracket_expr_start_depth = -1;
     return string_kind == TSTRING ? MAKE_TOKEN(TSTRING_START) : MAKE_TOKEN(FSTRING_START);
 }
 
+int
+_PyLexer_scan_prefixed_string(struct tok_state *tok, struct token *token,
+                              int quote, unsigned int prefixes)
+{
+    if (check_string_prefixes(tok, prefixes) < 0) {
+        return _PyLexer_token_setup(
+            tok, token, ERRORTOKEN, NULL, NULL);
+    }
+    if (prefixes & (STRING_PREFIX_F | STRING_PREFIX_T)) {
+        return scan_fstring_start(tok, token, quote, prefixes);
+    }
+    return _PyLexer_scan_string(tok, token, quote);
+}
+
 int
 _PyLexer_scan_string(struct tok_state *tok, struct token *token, int c)
 {
     const char *p_start = NULL;
     const char *p_end = NULL;
 
     int quote = c;
-    int quote_size = 1;             /* 1 or 3 */
     int end_quote_size = 0;
+    int quote_size = scan_quote_size(tok, quote, &end_quote_size);
     int has_escaped_quote = 0;
-
-    /* Find the quote size and start of string */
-    c = tok_nextc(tok);
-    if (c == quote) {
-        c = tok_nextc(tok);
-        if (c == quote) {
-            quote_size = 3;
-        }
-        else {
-            end_quote_size = 1;     /* empty string found */
-        }
-    }
-    if (c != quote) {
-        tok_backup(tok, c);
-    }
-
-    /* Get rest of string */
     while (end_quote_size != quote_size) {
         c = tok_nextc(tok);
         if (tok->done == E_ERROR) {