Update Python 3 to 3.12.5

https://docs.python.org/release/3.12.5/whatsnew/changelog.html#python-3-12-5-final de86cdeacd3a8653b9ec36e87975886fafcf6dc2
author: shadchin <shadchin@yandex-team.com> 2024-08-17 21:51:59 +0300
committer: shadchin <shadchin@yandex-team.com> 2024-08-17 22:04:51 +0300
commit: ee9edbd8878888bafcd0eeb3b528f3ec4311560b (patch)
tree: d54d8138e50a446904f10a2092719be86af011b7 /contrib/tools/python3/Parser
parent: 72cbe4bad58add0912623ba51351ff1db8587249 (diff)
download: ydb-ee9edbd8878888bafcd0eeb3b528f3ec4311560b.tar.gz
5 files changed, 4131 insertions, 4324 deletions
diff --git a/contrib/tools/python3/Parser/action_helpers.c b/contrib/tools/python3/Parser/action_helpers.c
index e68a9cac25..45a32a0213 100644
--- a/contrib/tools/python3/Parser/action_helpers.c
+++ b/contrib/tools/python3/Parser/action_helpers.c
@@ -1,1680 +1,1600 @@
 #include <Python.h>
 
 #include "pegen.h"
-#include "tokenizer.h"
+#include "pycore_runtime.h" // _PyRuntime
 #include "string_parser.h"
-#include "pycore_runtime.h"         // _PyRuntime
+#include "tokenizer.h"
 
-void *
-_PyPegen_dummy_name(Parser *p, ...)
-{
-    return &_PyRuntime.parser.dummy_name;
+void *_PyPegen_dummy_name(Parser *p, ...) {
+  return &_PyRuntime.parser.dummy_name;
 }
 
 /* Creates a single-element asdl_seq* that contains a */
-asdl_seq *
-_PyPegen_singleton_seq(Parser *p, void *a)
-{
-    assert(a != NULL);
-    asdl_seq *seq = (asdl_seq*)_Py_asdl_generic_seq_new(1, p->arena);
-    if (!seq) {
-        return NULL;
-    }
-    asdl_seq_SET_UNTYPED(seq, 0, a);
-    return seq;
+asdl_seq *_PyPegen_singleton_seq(Parser *p, void *a) {
+  assert(a != NULL);
+  asdl_seq *seq = (asdl_seq *)_Py_asdl_generic_seq_new(1, p->arena);
+  if (!seq) {
+    return NULL;
+  }
+  asdl_seq_SET_UNTYPED(seq, 0, a);
+  return seq;
 }
 
 /* Creates a copy of seq and prepends a to it */
-asdl_seq *
-_PyPegen_seq_insert_in_front(Parser *p, void *a, asdl_seq *seq)
-{
-    assert(a != NULL);
-    if (!seq) {
-        return _PyPegen_singleton_seq(p, a);
-    }
+asdl_seq *_PyPegen_seq_insert_in_front(Parser *p, void *a, asdl_seq *seq) {
+  assert(a != NULL);
+  if (!seq) {
+    return _PyPegen_singleton_seq(p, a);
+  }
 
-    asdl_seq *new_seq = (asdl_seq*)_Py_asdl_generic_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
+  asdl_seq *new_seq =
+      (asdl_seq *)_Py_asdl_generic_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
 
-    asdl_seq_SET_UNTYPED(new_seq, 0, a);
-    for (Py_ssize_t i = 1, l = asdl_seq_LEN(new_seq); i < l; i++) {
-        asdl_seq_SET_UNTYPED(new_seq, i, asdl_seq_GET_UNTYPED(seq, i - 1));
-    }
-    return new_seq;
+  asdl_seq_SET_UNTYPED(new_seq, 0, a);
+  for (Py_ssize_t i = 1, l = asdl_seq_LEN(new_seq); i < l; i++) {
+    asdl_seq_SET_UNTYPED(new_seq, i, asdl_seq_GET_UNTYPED(seq, i - 1));
+  }
+  return new_seq;
 }
 
 /* Creates a copy of seq and appends a to it */
-asdl_seq *
-_PyPegen_seq_append_to_end(Parser *p, asdl_seq *seq, void *a)
-{
-    assert(a != NULL);
-    if (!seq) {
-        return _PyPegen_singleton_seq(p, a);
-    }
-
-    asdl_seq *new_seq = (asdl_seq*)_Py_asdl_generic_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(new_seq); i + 1 < l; i++) {
-        asdl_seq_SET_UNTYPED(new_seq, i, asdl_seq_GET_UNTYPED(seq, i));
-    }
-    asdl_seq_SET_UNTYPED(new_seq, asdl_seq_LEN(new_seq) - 1, a);
-    return new_seq;
-}
-
-static Py_ssize_t
-_get_flattened_seq_size(asdl_seq *seqs)
-{
-    Py_ssize_t size = 0;
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
-        asdl_seq *inner_seq = asdl_seq_GET_UNTYPED(seqs, i);
-        size += asdl_seq_LEN(inner_seq);
-    }
-    return size;
+asdl_seq *_PyPegen_seq_append_to_end(Parser *p, asdl_seq *seq, void *a) {
+  assert(a != NULL);
+  if (!seq) {
+    return _PyPegen_singleton_seq(p, a);
+  }
+
+  asdl_seq *new_seq =
+      (asdl_seq *)_Py_asdl_generic_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+
+  for (Py_ssize_t i = 0, l = asdl_seq_LEN(new_seq); i + 1 < l; i++) {
+    asdl_seq_SET_UNTYPED(new_seq, i, asdl_seq_GET_UNTYPED(seq, i));
+  }
+  asdl_seq_SET_UNTYPED(new_seq, asdl_seq_LEN(new_seq) - 1, a);
+  return new_seq;
+}
+
+static Py_ssize_t _get_flattened_seq_size(asdl_seq *seqs) {
+  Py_ssize_t size = 0;
+  for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
+    asdl_seq *inner_seq = asdl_seq_GET_UNTYPED(seqs, i);
+    size += asdl_seq_LEN(inner_seq);
+  }
+  return size;
 }
 
 /* Flattens an asdl_seq* of asdl_seq*s */
-asdl_seq *
-_PyPegen_seq_flatten(Parser *p, asdl_seq *seqs)
-{
-    Py_ssize_t flattened_seq_size = _get_flattened_seq_size(seqs);
-    assert(flattened_seq_size > 0);
-
-    asdl_seq *flattened_seq = (asdl_seq*)_Py_asdl_generic_seq_new(flattened_seq_size, p->arena);
-    if (!flattened_seq) {
-        return NULL;
-    }
+asdl_seq *_PyPegen_seq_flatten(Parser *p, asdl_seq *seqs) {
+  Py_ssize_t flattened_seq_size = _get_flattened_seq_size(seqs);
+  assert(flattened_seq_size > 0);
 
-    int flattened_seq_idx = 0;
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
-        asdl_seq *inner_seq = asdl_seq_GET_UNTYPED(seqs, i);
-        for (Py_ssize_t j = 0, li = asdl_seq_LEN(inner_seq); j < li; j++) {
-            asdl_seq_SET_UNTYPED(flattened_seq, flattened_seq_idx++, asdl_seq_GET_UNTYPED(inner_seq, j));
-        }
+  asdl_seq *flattened_seq =
+      (asdl_seq *)_Py_asdl_generic_seq_new(flattened_seq_size, p->arena);
+  if (!flattened_seq) {
+    return NULL;
+  }
+
+  int flattened_seq_idx = 0;
+  for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
+    asdl_seq *inner_seq = asdl_seq_GET_UNTYPED(seqs, i);
+    for (Py_ssize_t j = 0, li = asdl_seq_LEN(inner_seq); j < li; j++) {
+      asdl_seq_SET_UNTYPED(flattened_seq, flattened_seq_idx++,
+                           asdl_seq_GET_UNTYPED(inner_seq, j));
     }
-    assert(flattened_seq_idx == flattened_seq_size);
+  }
+  assert(flattened_seq_idx == flattened_seq_size);
 
-    return flattened_seq;
+  return flattened_seq;
 }
 
-void *
-_PyPegen_seq_last_item(asdl_seq *seq)
-{
-    Py_ssize_t len = asdl_seq_LEN(seq);
-    return asdl_seq_GET_UNTYPED(seq, len - 1);
+void *_PyPegen_seq_last_item(asdl_seq *seq) {
+  Py_ssize_t len = asdl_seq_LEN(seq);
+  return asdl_seq_GET_UNTYPED(seq, len - 1);
 }
 
-void *
-_PyPegen_seq_first_item(asdl_seq *seq)
-{
-    return asdl_seq_GET_UNTYPED(seq, 0);
+void *_PyPegen_seq_first_item(asdl_seq *seq) {
+  return asdl_seq_GET_UNTYPED(seq, 0);
 }
 
 /* Creates a new name of the form <first_name>.<second_name> */
-expr_ty
-_PyPegen_join_names_with_dot(Parser *p, expr_ty first_name, expr_ty second_name)
-{
-    assert(first_name != NULL && second_name != NULL);
-    PyObject *first_identifier = first_name->v.Name.id;
-    PyObject *second_identifier = second_name->v.Name.id;
-
-    if (PyUnicode_READY(first_identifier) == -1) {
-        return NULL;
-    }
-    if (PyUnicode_READY(second_identifier) == -1) {
-        return NULL;
-    }
-    const char *first_str = PyUnicode_AsUTF8(first_identifier);
-    if (!first_str) {
-        return NULL;
-    }
-    const char *second_str = PyUnicode_AsUTF8(second_identifier);
-    if (!second_str) {
-        return NULL;
-    }
-    Py_ssize_t len = strlen(first_str) + strlen(second_str) + 1;  // +1 for the dot
-
-    PyObject *str = PyBytes_FromStringAndSize(NULL, len);
-    if (!str) {
-        return NULL;
-    }
-
-    char *s = PyBytes_AS_STRING(str);
-    if (!s) {
-        return NULL;
-    }
-
-    strcpy(s, first_str);
-    s += strlen(first_str);
-    *s++ = '.';
-    strcpy(s, second_str);
-    s += strlen(second_str);
-    *s = '\0';
-
-    PyObject *uni = PyUnicode_DecodeUTF8(PyBytes_AS_STRING(str), PyBytes_GET_SIZE(str), NULL);
-    Py_DECREF(str);
-    if (!uni) {
-        return NULL;
-    }
-    PyUnicode_InternInPlace(&uni);
-    if (_PyArena_AddPyObject(p->arena, uni) < 0) {
-        Py_DECREF(uni);
-        return NULL;
-    }
-
-    return _PyAST_Name(uni, Load, EXTRA_EXPR(first_name, second_name));
+expr_ty _PyPegen_join_names_with_dot(Parser *p, expr_ty first_name,
+                                     expr_ty second_name) {
+  assert(first_name != NULL && second_name != NULL);
+  PyObject *first_identifier = first_name->v.Name.id;
+  PyObject *second_identifier = second_name->v.Name.id;
+
+  if (PyUnicode_READY(first_identifier) == -1) {
+    return NULL;
+  }
+  if (PyUnicode_READY(second_identifier) == -1) {
+    return NULL;
+  }
+  const char *first_str = PyUnicode_AsUTF8(first_identifier);
+  if (!first_str) {
+    return NULL;
+  }
+  const char *second_str = PyUnicode_AsUTF8(second_identifier);
+  if (!second_str) {
+    return NULL;
+  }
+  Py_ssize_t len = strlen(first_str) + strlen(second_str) + 1; // +1 for the dot
+
+  PyObject *str = PyBytes_FromStringAndSize(NULL, len);
+  if (!str) {
+    return NULL;
+  }
+
+  char *s = PyBytes_AS_STRING(str);
+  if (!s) {
+    return NULL;
+  }
+
+  strcpy(s, first_str);
+  s += strlen(first_str);
+  *s++ = '.';
+  strcpy(s, second_str);
+  s += strlen(second_str);
+  *s = '\0';
+
+  PyObject *uni =
+      PyUnicode_DecodeUTF8(PyBytes_AS_STRING(str), PyBytes_GET_SIZE(str), NULL);
+  Py_DECREF(str);
+  if (!uni) {
+    return NULL;
+  }
+  PyUnicode_InternInPlace(&uni);
+  if (_PyArena_AddPyObject(p->arena, uni) < 0) {
+    Py_DECREF(uni);
+    return NULL;
+  }
+
+  return _PyAST_Name(uni, Load, EXTRA_EXPR(first_name, second_name));
 }
 
 /* Counts the total number of dots in seq's tokens */
-int
-_PyPegen_seq_count_dots(asdl_seq *seq)
-{
-    int number_of_dots = 0;
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
-        Token *current_expr = asdl_seq_GET_UNTYPED(seq, i);
-        switch (current_expr->type) {
-            case ELLIPSIS:
-                number_of_dots += 3;
-                break;
-            case DOT:
-                number_of_dots += 1;
-                break;
-            default:
-                Py_UNREACHABLE();
-        }
+int _PyPegen_seq_count_dots(asdl_seq *seq) {
+  int number_of_dots = 0;
+  for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+    Token *current_expr = asdl_seq_GET_UNTYPED(seq, i);
+    switch (current_expr->type) {
+    case ELLIPSIS:
+      number_of_dots += 3;
+      break;
+    case DOT:
+      number_of_dots += 1;
+      break;
+    default:
+      Py_UNREACHABLE();
     }
+  }
 
-    return number_of_dots;
+  return number_of_dots;
 }
 
 /* Creates an alias with '*' as the identifier name */
-alias_ty
-_PyPegen_alias_for_star(Parser *p, int lineno, int col_offset, int end_lineno,
-                        int end_col_offset, PyArena *arena) {
-    PyObject *str = PyUnicode_InternFromString("*");
-    if (!str) {
-        return NULL;
-    }
-    if (_PyArena_AddPyObject(p->arena, str) < 0) {
-        Py_DECREF(str);
-        return NULL;
-    }
-    return _PyAST_alias(str, NULL, lineno, col_offset, end_lineno, end_col_offset, arena);
+alias_ty _PyPegen_alias_for_star(Parser *p, int lineno, int col_offset,
+                                 int end_lineno, int end_col_offset,
+                                 PyArena *arena) {
+  PyObject *str = PyUnicode_InternFromString("*");
+  if (!str) {
+    return NULL;
+  }
+  if (_PyArena_AddPyObject(p->arena, str) < 0) {
+    Py_DECREF(str);
+    return NULL;
+  }
+  return _PyAST_alias(str, NULL, lineno, col_offset, end_lineno, end_col_offset,
+                      arena);
 }
 
 /* Creates a new asdl_seq* with the identifiers of all the names in seq */
-asdl_identifier_seq *
-_PyPegen_map_names_to_ids(Parser *p, asdl_expr_seq *seq)
-{
-    Py_ssize_t len = asdl_seq_LEN(seq);
-    assert(len > 0);
-
-    asdl_identifier_seq *new_seq = _Py_asdl_identifier_seq_new(len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        expr_ty e = asdl_seq_GET(seq, i);
-        asdl_seq_SET(new_seq, i, e->v.Name.id);
-    }
-    return new_seq;
+asdl_identifier_seq *_PyPegen_map_names_to_ids(Parser *p, asdl_expr_seq *seq) {
+  Py_ssize_t len = asdl_seq_LEN(seq);
+  assert(len > 0);
+
+  asdl_identifier_seq *new_seq = _Py_asdl_identifier_seq_new(len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    expr_ty e = asdl_seq_GET(seq, i);
+    asdl_seq_SET(new_seq, i, e->v.Name.id);
+  }
+  return new_seq;
 }
 
 /* Constructs a CmpopExprPair */
-CmpopExprPair *
-_PyPegen_cmpop_expr_pair(Parser *p, cmpop_ty cmpop, expr_ty expr)
-{
-    assert(expr != NULL);
-    CmpopExprPair *a = _PyArena_Malloc(p->arena, sizeof(CmpopExprPair));
-    if (!a) {
-        return NULL;
-    }
-    a->cmpop = cmpop;
-    a->expr = expr;
-    return a;
+CmpopExprPair *_PyPegen_cmpop_expr_pair(Parser *p, cmpop_ty cmpop,
+                                        expr_ty expr) {
+  assert(expr != NULL);
+  CmpopExprPair *a = _PyArena_Malloc(p->arena, sizeof(CmpopExprPair));
+  if (!a) {
+    return NULL;
+  }
+  a->cmpop = cmpop;
+  a->expr = expr;
+  return a;
 }
 
-asdl_int_seq *
-_PyPegen_get_cmpops(Parser *p, asdl_seq *seq)
-{
-    Py_ssize_t len = asdl_seq_LEN(seq);
-    assert(len > 0);
+asdl_int_seq *_PyPegen_get_cmpops(Parser *p, asdl_seq *seq) {
+  Py_ssize_t len = asdl_seq_LEN(seq);
+  assert(len > 0);
 
-    asdl_int_seq *new_seq = _Py_asdl_int_seq_new(len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        CmpopExprPair *pair = asdl_seq_GET_UNTYPED(seq, i);
-        asdl_seq_SET(new_seq, i, pair->cmpop);
-    }
-    return new_seq;
+  asdl_int_seq *new_seq = _Py_asdl_int_seq_new(len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    CmpopExprPair *pair = asdl_seq_GET_UNTYPED(seq, i);
+    asdl_seq_SET(new_seq, i, pair->cmpop);
+  }
+  return new_seq;
 }
 
-asdl_expr_seq *
-_PyPegen_get_exprs(Parser *p, asdl_seq *seq)
-{
-    Py_ssize_t len = asdl_seq_LEN(seq);
-    assert(len > 0);
+asdl_expr_seq *_PyPegen_get_exprs(Parser *p, asdl_seq *seq) {
+  Py_ssize_t len = asdl_seq_LEN(seq);
+  assert(len > 0);
 
-    asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        CmpopExprPair *pair = asdl_seq_GET_UNTYPED(seq, i);
-        asdl_seq_SET(new_seq, i, pair->expr);
-    }
-    return new_seq;
+  asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    CmpopExprPair *pair = asdl_seq_GET_UNTYPED(seq, i);
+    asdl_seq_SET(new_seq, i, pair->expr);
+  }
+  return new_seq;
 }
 
-/* Creates an asdl_seq* where all the elements have been changed to have ctx as context */
-static asdl_expr_seq *
-_set_seq_context(Parser *p, asdl_expr_seq *seq, expr_context_ty ctx)
-{
-    Py_ssize_t len = asdl_seq_LEN(seq);
-    if (len == 0) {
-        return NULL;
-    }
+/* Creates an asdl_seq* where all the elements have been changed to have ctx as
+ * context */
+static asdl_expr_seq *_set_seq_context(Parser *p, asdl_expr_seq *seq,
+                                       expr_context_ty ctx) {
+  Py_ssize_t len = asdl_seq_LEN(seq);
+  if (len == 0) {
+    return NULL;
+  }
 
-    asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        expr_ty e = asdl_seq_GET(seq, i);
-        asdl_seq_SET(new_seq, i, _PyPegen_set_expr_context(p, e, ctx));
-    }
-    return new_seq;
+  asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    expr_ty e = asdl_seq_GET(seq, i);
+    asdl_seq_SET(new_seq, i, _PyPegen_set_expr_context(p, e, ctx));
+  }
+  return new_seq;
 }
 
-static expr_ty
-_set_name_context(Parser *p, expr_ty e, expr_context_ty ctx)
-{
-    return _PyAST_Name(e->v.Name.id, ctx, EXTRA_EXPR(e, e));
+static expr_ty _set_name_context(Parser *p, expr_ty e, expr_context_ty ctx) {
+  return _PyAST_Name(e->v.Name.id, ctx, EXTRA_EXPR(e, e));
 }
 
-static expr_ty
-_set_tuple_context(Parser *p, expr_ty e, expr_context_ty ctx)
-{
-    return _PyAST_Tuple(
-            _set_seq_context(p, e->v.Tuple.elts, ctx),
-            ctx,
-            EXTRA_EXPR(e, e));
+static expr_ty _set_tuple_context(Parser *p, expr_ty e, expr_context_ty ctx) {
+  return _PyAST_Tuple(_set_seq_context(p, e->v.Tuple.elts, ctx), ctx,
+                      EXTRA_EXPR(e, e));
 }
 
-static expr_ty
-_set_list_context(Parser *p, expr_ty e, expr_context_ty ctx)
-{
-    return _PyAST_List(
-            _set_seq_context(p, e->v.List.elts, ctx),
-            ctx,
-            EXTRA_EXPR(e, e));
+static expr_ty _set_list_context(Parser *p, expr_ty e, expr_context_ty ctx) {
+  return _PyAST_List(_set_seq_context(p, e->v.List.elts, ctx), ctx,
+                     EXTRA_EXPR(e, e));
 }
 
-static expr_ty
-_set_subscript_context(Parser *p, expr_ty e, expr_context_ty ctx)
-{
-    return _PyAST_Subscript(e->v.Subscript.value, e->v.Subscript.slice,
-                            ctx, EXTRA_EXPR(e, e));
+static expr_ty _set_subscript_context(Parser *p, expr_ty e,
+                                      expr_context_ty ctx) {
+  return _PyAST_Subscript(e->v.Subscript.value, e->v.Subscript.slice, ctx,
+                          EXTRA_EXPR(e, e));
 }
 
-static expr_ty
-_set_attribute_context(Parser *p, expr_ty e, expr_context_ty ctx)
-{
-    return _PyAST_Attribute(e->v.Attribute.value, e->v.Attribute.attr,
-                            ctx, EXTRA_EXPR(e, e));
+static expr_ty _set_attribute_context(Parser *p, expr_ty e,
+                                      expr_context_ty ctx) {
+  return _PyAST_Attribute(e->v.Attribute.value, e->v.Attribute.attr, ctx,
+                          EXTRA_EXPR(e, e));
 }
 
-static expr_ty
-_set_starred_context(Parser *p, expr_ty e, expr_context_ty ctx)
-{
-    return _PyAST_Starred(_PyPegen_set_expr_context(p, e->v.Starred.value, ctx),
-                          ctx, EXTRA_EXPR(e, e));
+static expr_ty _set_starred_context(Parser *p, expr_ty e, expr_context_ty ctx) {
+  return _PyAST_Starred(_PyPegen_set_expr_context(p, e->v.Starred.value, ctx),
+                        ctx, EXTRA_EXPR(e, e));
 }
 
 /* Creates an `expr_ty` equivalent to `expr` but with `ctx` as context */
-expr_ty
-_PyPegen_set_expr_context(Parser *p, expr_ty expr, expr_context_ty ctx)
-{
-    assert(expr != NULL);
-
-    expr_ty new = NULL;
-    switch (expr->kind) {
-        case Name_kind:
-            new = _set_name_context(p, expr, ctx);
-            break;
-        case Tuple_kind:
-            new = _set_tuple_context(p, expr, ctx);
-            break;
-        case List_kind:
-            new = _set_list_context(p, expr, ctx);
-            break;
-        case Subscript_kind:
-            new = _set_subscript_context(p, expr, ctx);
-            break;
-        case Attribute_kind:
-            new = _set_attribute_context(p, expr, ctx);
-            break;
-        case Starred_kind:
-            new = _set_starred_context(p, expr, ctx);
-            break;
-        default:
-            new = expr;
-    }
-    return new;
-}
-
-/* Constructs a KeyValuePair that is used when parsing a dict's key value pairs */
-KeyValuePair *
-_PyPegen_key_value_pair(Parser *p, expr_ty key, expr_ty value)
-{
-    KeyValuePair *a = _PyArena_Malloc(p->arena, sizeof(KeyValuePair));
-    if (!a) {
-        return NULL;
-    }
-    a->key = key;
-    a->value = value;
-    return a;
+expr_ty _PyPegen_set_expr_context(Parser *p, expr_ty expr,
+                                  expr_context_ty ctx) {
+  assert(expr != NULL);
+
+  expr_ty new = NULL;
+  switch (expr->kind) {
+  case Name_kind:
+    new = _set_name_context(p, expr, ctx);
+    break;
+  case Tuple_kind:
+    new = _set_tuple_context(p, expr, ctx);
+    break;
+  case List_kind:
+    new = _set_list_context(p, expr, ctx);
+    break;
+  case Subscript_kind:
+    new = _set_subscript_context(p, expr, ctx);
+    break;
+  case Attribute_kind:
+    new = _set_attribute_context(p, expr, ctx);
+    break;
+  case Starred_kind:
+    new = _set_starred_context(p, expr, ctx);
+    break;
+  default:
+    new = expr;
+  }
+  return new;
+}
+
+/* Constructs a KeyValuePair that is used when parsing a dict's key value pairs
+ */
+KeyValuePair *_PyPegen_key_value_pair(Parser *p, expr_ty key, expr_ty value) {
+  KeyValuePair *a = _PyArena_Malloc(p->arena, sizeof(KeyValuePair));
+  if (!a) {
+    return NULL;
+  }
+  a->key = key;
+  a->value = value;
+  return a;
 }
 
 /* Extracts all keys from an asdl_seq* of KeyValuePair*'s */
-asdl_expr_seq *
-_PyPegen_get_keys(Parser *p, asdl_seq *seq)
-{
-    Py_ssize_t len = asdl_seq_LEN(seq);
-    asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        KeyValuePair *pair = asdl_seq_GET_UNTYPED(seq, i);
-        asdl_seq_SET(new_seq, i, pair->key);
-    }
-    return new_seq;
+asdl_expr_seq *_PyPegen_get_keys(Parser *p, asdl_seq *seq) {
+  Py_ssize_t len = asdl_seq_LEN(seq);
+  asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    KeyValuePair *pair = asdl_seq_GET_UNTYPED(seq, i);
+    asdl_seq_SET(new_seq, i, pair->key);
+  }
+  return new_seq;
 }
 
 /* Extracts all values from an asdl_seq* of KeyValuePair*'s */
-asdl_expr_seq *
-_PyPegen_get_values(Parser *p, asdl_seq *seq)
-{
-    Py_ssize_t len = asdl_seq_LEN(seq);
-    asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        KeyValuePair *pair = asdl_seq_GET_UNTYPED(seq, i);
-        asdl_seq_SET(new_seq, i, pair->value);
-    }
-    return new_seq;
-}
-
-/* Constructs a KeyPatternPair that is used when parsing mapping & class patterns */
-KeyPatternPair *
-_PyPegen_key_pattern_pair(Parser *p, expr_ty key, pattern_ty pattern)
-{
-    KeyPatternPair *a = _PyArena_Malloc(p->arena, sizeof(KeyPatternPair));
-    if (!a) {
-        return NULL;
-    }
-    a->key = key;
-    a->pattern = pattern;
-    return a;
+asdl_expr_seq *_PyPegen_get_values(Parser *p, asdl_seq *seq) {
+  Py_ssize_t len = asdl_seq_LEN(seq);
+  asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    KeyValuePair *pair = asdl_seq_GET_UNTYPED(seq, i);
+    asdl_seq_SET(new_seq, i, pair->value);
+  }
+  return new_seq;
+}
+
+/* Constructs a KeyPatternPair that is used when parsing mapping & class
+ * patterns */
+KeyPatternPair *_PyPegen_key_pattern_pair(Parser *p, expr_ty key,
+                                          pattern_ty pattern) {
+  KeyPatternPair *a = _PyArena_Malloc(p->arena, sizeof(KeyPatternPair));
+  if (!a) {
+    return NULL;
+  }
+  a->key = key;
+  a->pattern = pattern;
+  return a;
 }
 
 /* Extracts all keys from an asdl_seq* of KeyPatternPair*'s */
-asdl_expr_seq *
-_PyPegen_get_pattern_keys(Parser *p, asdl_seq *seq)
-{
-    Py_ssize_t len = asdl_seq_LEN(seq);
-    asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        KeyPatternPair *pair = asdl_seq_GET_UNTYPED(seq, i);
-        asdl_seq_SET(new_seq, i, pair->key);
-    }
-    return new_seq;
+asdl_expr_seq *_PyPegen_get_pattern_keys(Parser *p, asdl_seq *seq) {
+  Py_ssize_t len = asdl_seq_LEN(seq);
+  asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    KeyPatternPair *pair = asdl_seq_GET_UNTYPED(seq, i);
+    asdl_seq_SET(new_seq, i, pair->key);
+  }
+  return new_seq;
 }
 
 /* Extracts all patterns from an asdl_seq* of KeyPatternPair*'s */
-asdl_pattern_seq *
-_PyPegen_get_patterns(Parser *p, asdl_seq *seq)
-{
-    Py_ssize_t len = asdl_seq_LEN(seq);
-    asdl_pattern_seq *new_seq = _Py_asdl_pattern_seq_new(len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        KeyPatternPair *pair = asdl_seq_GET_UNTYPED(seq, i);
-        asdl_seq_SET(new_seq, i, pair->pattern);
-    }
-    return new_seq;
+asdl_pattern_seq *_PyPegen_get_patterns(Parser *p, asdl_seq *seq) {
+  Py_ssize_t len = asdl_seq_LEN(seq);
+  asdl_pattern_seq *new_seq = _Py_asdl_pattern_seq_new(len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    KeyPatternPair *pair = asdl_seq_GET_UNTYPED(seq, i);
+    asdl_seq_SET(new_seq, i, pair->pattern);
+  }
+  return new_seq;
 }
 
 /* Constructs a NameDefaultPair */
-NameDefaultPair *
-_PyPegen_name_default_pair(Parser *p, arg_ty arg, expr_ty value, Token *tc)
-{
-    NameDefaultPair *a = _PyArena_Malloc(p->arena, sizeof(NameDefaultPair));
-    if (!a) {
-        return NULL;
-    }
-    a->arg = _PyPegen_add_type_comment_to_arg(p, arg, tc);
-    a->value = value;
-    return a;
+NameDefaultPair *_PyPegen_name_default_pair(Parser *p, arg_ty arg,
+                                            expr_ty value, Token *tc) {
+  NameDefaultPair *a = _PyArena_Malloc(p->arena, sizeof(NameDefaultPair));
+  if (!a) {
+    return NULL;
+  }
+  a->arg = _PyPegen_add_type_comment_to_arg(p, arg, tc);
+  a->value = value;
+  return a;
 }
 
 /* Constructs a SlashWithDefault */
-SlashWithDefault *
-_PyPegen_slash_with_default(Parser *p, asdl_arg_seq *plain_names, asdl_seq *names_with_defaults)
-{
-    SlashWithDefault *a = _PyArena_Malloc(p->arena, sizeof(SlashWithDefault));
-    if (!a) {
-        return NULL;
-    }
-    a->plain_names = plain_names;
-    a->names_with_defaults = names_with_defaults;
-    return a;
+SlashWithDefault *_PyPegen_slash_with_default(Parser *p,
+                                              asdl_arg_seq *plain_names,
+                                              asdl_seq *names_with_defaults) {
+  SlashWithDefault *a = _PyArena_Malloc(p->arena, sizeof(SlashWithDefault));
+  if (!a) {
+    return NULL;
+  }
+  a->plain_names = plain_names;
+  a->names_with_defaults = names_with_defaults;
+  return a;
 }
 
 /* Constructs a StarEtc */
-StarEtc *
-_PyPegen_star_etc(Parser *p, arg_ty vararg, asdl_seq *kwonlyargs, arg_ty kwarg)
-{
-    StarEtc *a = _PyArena_Malloc(p->arena, sizeof(StarEtc));
-    if (!a) {
-        return NULL;
-    }
-    a->vararg = vararg;
-    a->kwonlyargs = kwonlyargs;
-    a->kwarg = kwarg;
-    return a;
-}
-
-asdl_seq *
-_PyPegen_join_sequences(Parser *p, asdl_seq *a, asdl_seq *b)
-{
-    Py_ssize_t first_len = asdl_seq_LEN(a);
-    Py_ssize_t second_len = asdl_seq_LEN(b);
-    asdl_seq *new_seq = (asdl_seq*)_Py_asdl_generic_seq_new(first_len + second_len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-
-    int k = 0;
-    for (Py_ssize_t i = 0; i < first_len; i++) {
-        asdl_seq_SET_UNTYPED(new_seq, k++, asdl_seq_GET_UNTYPED(a, i));
-    }
-    for (Py_ssize_t i = 0; i < second_len; i++) {
-        asdl_seq_SET_UNTYPED(new_seq, k++, asdl_seq_GET_UNTYPED(b, i));
-    }
-
-    return new_seq;
-}
-
-static asdl_arg_seq*
-_get_names(Parser *p, asdl_seq *names_with_defaults)
-{
-    Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
-    asdl_arg_seq *seq = _Py_asdl_arg_seq_new(len, p->arena);
-    if (!seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        NameDefaultPair *pair = asdl_seq_GET_UNTYPED(names_with_defaults, i);
-        asdl_seq_SET(seq, i, pair->arg);
-    }
-    return seq;
-}
-
-static asdl_expr_seq *
-_get_defaults(Parser *p, asdl_seq *names_with_defaults)
-{
-    Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
-    asdl_expr_seq *seq = _Py_asdl_expr_seq_new(len, p->arena);
-    if (!seq) {
-        return NULL;
-    }
-    for (Py_ssize_t i = 0; i < len; i++) {
-        NameDefaultPair *pair = asdl_seq_GET_UNTYPED(names_with_defaults, i);
-        asdl_seq_SET(seq, i, pair->value);
-    }
-    return seq;
-}
-
-static int
-_make_posonlyargs(Parser *p,
-                  asdl_arg_seq *slash_without_default,
-                  SlashWithDefault *slash_with_default,
-                  asdl_arg_seq **posonlyargs) {
-    if (slash_without_default != NULL) {
-        *posonlyargs = slash_without_default;
-    }
-    else if (slash_with_default != NULL) {
-        asdl_arg_seq *slash_with_default_names =
-                _get_names(p, slash_with_default->names_with_defaults);
-        if (!slash_with_default_names) {
-            return -1;
-        }
-        *posonlyargs = (asdl_arg_seq*)_PyPegen_join_sequences(
-                p,
-                (asdl_seq*)slash_with_default->plain_names,
-                (asdl_seq*)slash_with_default_names);
-    }
-    else {
-        *posonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
-    }
-    return *posonlyargs == NULL ? -1 : 0;
-}
-
-static int
-_make_posargs(Parser *p,
-              asdl_arg_seq *plain_names,
-              asdl_seq *names_with_default,
-              asdl_arg_seq **posargs) {
-    if (plain_names != NULL && names_with_default != NULL) {
-        asdl_arg_seq *names_with_default_names = _get_names(p, names_with_default);
-        if (!names_with_default_names) {
-            return -1;
-        }
-        *posargs = (asdl_arg_seq*)_PyPegen_join_sequences(
-                p,(asdl_seq*)plain_names, (asdl_seq*)names_with_default_names);
-    }
-    else if (plain_names == NULL && names_with_default != NULL) {
-        *posargs = _get_names(p, names_with_default);
-    }
-    else if (plain_names != NULL && names_with_default == NULL) {
-        *posargs = plain_names;
-    }
-    else {
-        *posargs = _Py_asdl_arg_seq_new(0, p->arena);
-    }
-    return *posargs == NULL ? -1 : 0;
-}
-
-static int
-_make_posdefaults(Parser *p,
-                  SlashWithDefault *slash_with_default,
-                  asdl_seq *names_with_default,
-                  asdl_expr_seq **posdefaults) {
-    if (slash_with_default != NULL && names_with_default != NULL) {
-        asdl_expr_seq *slash_with_default_values =
-                _get_defaults(p, slash_with_default->names_with_defaults);
-        if (!slash_with_default_values) {
-            return -1;
-        }
-        asdl_expr_seq *names_with_default_values = _get_defaults(p, names_with_default);
-        if (!names_with_default_values) {
-            return -1;
-        }
-        *posdefaults = (asdl_expr_seq*)_PyPegen_join_sequences(
-                p,
-                (asdl_seq*)slash_with_default_values,
-                (asdl_seq*)names_with_default_values);
-    }
-    else if (slash_with_default == NULL && names_with_default != NULL) {
-        *posdefaults = _get_defaults(p, names_with_default);
-    }
-    else if (slash_with_default != NULL && names_with_default == NULL) {
-        *posdefaults = _get_defaults(p, slash_with_default->names_with_defaults);
-    }
-    else {
-        *posdefaults = _Py_asdl_expr_seq_new(0, p->arena);
-    }
-    return *posdefaults == NULL ? -1 : 0;
-}
-
-static int
-_make_kwargs(Parser *p, StarEtc *star_etc,
-             asdl_arg_seq **kwonlyargs,
-             asdl_expr_seq **kwdefaults) {
-    if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
-        *kwonlyargs = _get_names(p, star_etc->kwonlyargs);
-    }
-    else {
-        *kwonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
-    }
-
-    if (*kwonlyargs == NULL) {
-        return -1;
-    }
-
-    if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
-        *kwdefaults = _get_defaults(p, star_etc->kwonlyargs);
-    }
-    else {
-        *kwdefaults = _Py_asdl_expr_seq_new(0, p->arena);
-    }
-
-    if (*kwdefaults == NULL) {
-        return -1;
-    }
-
-    return 0;
-}
-
-/* Constructs an arguments_ty object out of all the parsed constructs in the parameters rule */
-arguments_ty
-_PyPegen_make_arguments(Parser *p, asdl_arg_seq *slash_without_default,
-                        SlashWithDefault *slash_with_default, asdl_arg_seq *plain_names,
-                        asdl_seq *names_with_default, StarEtc *star_etc)
-{
-    asdl_arg_seq *posonlyargs;
-    if (_make_posonlyargs(p, slash_without_default, slash_with_default, &posonlyargs) == -1) {
-        return NULL;
-    }
-
-    asdl_arg_seq *posargs;
-    if (_make_posargs(p, plain_names, names_with_default, &posargs) == -1) {
-        return NULL;
-    }
-
-    asdl_expr_seq *posdefaults;
-    if (_make_posdefaults(p,slash_with_default, names_with_default, &posdefaults) == -1) {
-        return NULL;
-    }
-
-    arg_ty vararg = NULL;
-    if (star_etc != NULL && star_etc->vararg != NULL) {
-        vararg = star_etc->vararg;
-    }
-
-    asdl_arg_seq *kwonlyargs;
-    asdl_expr_seq *kwdefaults;
-    if (_make_kwargs(p, star_etc, &kwonlyargs, &kwdefaults) == -1) {
-        return NULL;
-    }
-
-    arg_ty kwarg = NULL;
-    if (star_etc != NULL && star_etc->kwarg != NULL) {
-        kwarg = star_etc->kwarg;
-    }
-
-    return _PyAST_arguments(posonlyargs, posargs, vararg, kwonlyargs,
-                            kwdefaults, kwarg, posdefaults, p->arena);
-}
-
-
-/* Constructs an empty arguments_ty object, that gets used when a function accepts no
- * arguments. */
-arguments_ty
-_PyPegen_empty_arguments(Parser *p)
-{
-    asdl_arg_seq *posonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
-    if (!posonlyargs) {
-        return NULL;
-    }
-    asdl_arg_seq *posargs = _Py_asdl_arg_seq_new(0, p->arena);
-    if (!posargs) {
-        return NULL;
-    }
-    asdl_expr_seq *posdefaults = _Py_asdl_expr_seq_new(0, p->arena);
-    if (!posdefaults) {
-        return NULL;
-    }
-    asdl_arg_seq *kwonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
-    if (!kwonlyargs) {
-        return NULL;
-    }
-    asdl_expr_seq *kwdefaults = _Py_asdl_expr_seq_new(0, p->arena);
-    if (!kwdefaults) {
-        return NULL;
-    }
-
-    return _PyAST_arguments(posonlyargs, posargs, NULL, kwonlyargs,
-                            kwdefaults, NULL, posdefaults, p->arena);
+StarEtc *_PyPegen_star_etc(Parser *p, arg_ty vararg, asdl_seq *kwonlyargs,
+                           arg_ty kwarg) {
+  StarEtc *a = _PyArena_Malloc(p->arena, sizeof(StarEtc));
+  if (!a) {
+    return NULL;
+  }
+  a->vararg = vararg;
+  a->kwonlyargs = kwonlyargs;
+  a->kwarg = kwarg;
+  return a;
+}
+
+asdl_seq *_PyPegen_join_sequences(Parser *p, asdl_seq *a, asdl_seq *b) {
+  Py_ssize_t first_len = asdl_seq_LEN(a);
+  Py_ssize_t second_len = asdl_seq_LEN(b);
+  asdl_seq *new_seq =
+      (asdl_seq *)_Py_asdl_generic_seq_new(first_len + second_len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+
+  int k = 0;
+  for (Py_ssize_t i = 0; i < first_len; i++) {
+    asdl_seq_SET_UNTYPED(new_seq, k++, asdl_seq_GET_UNTYPED(a, i));
+  }
+  for (Py_ssize_t i = 0; i < second_len; i++) {
+    asdl_seq_SET_UNTYPED(new_seq, k++, asdl_seq_GET_UNTYPED(b, i));
+  }
+
+  return new_seq;
+}
+
+static asdl_arg_seq *_get_names(Parser *p, asdl_seq *names_with_defaults) {
+  Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
+  asdl_arg_seq *seq = _Py_asdl_arg_seq_new(len, p->arena);
+  if (!seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    NameDefaultPair *pair = asdl_seq_GET_UNTYPED(names_with_defaults, i);
+    asdl_seq_SET(seq, i, pair->arg);
+  }
+  return seq;
+}
+
+static asdl_expr_seq *_get_defaults(Parser *p, asdl_seq *names_with_defaults) {
+  Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
+  asdl_expr_seq *seq = _Py_asdl_expr_seq_new(len, p->arena);
+  if (!seq) {
+    return NULL;
+  }
+  for (Py_ssize_t i = 0; i < len; i++) {
+    NameDefaultPair *pair = asdl_seq_GET_UNTYPED(names_with_defaults, i);
+    asdl_seq_SET(seq, i, pair->value);
+  }
+  return seq;
+}
+
+static int _make_posonlyargs(Parser *p, asdl_arg_seq *slash_without_default,
+                             SlashWithDefault *slash_with_default,
+                             asdl_arg_seq **posonlyargs) {
+  if (slash_without_default != NULL) {
+    *posonlyargs = slash_without_default;
+  } else if (slash_with_default != NULL) {
+    asdl_arg_seq *slash_with_default_names =
+        _get_names(p, slash_with_default->names_with_defaults);
+    if (!slash_with_default_names) {
+      return -1;
+    }
+    *posonlyargs = (asdl_arg_seq *)_PyPegen_join_sequences(
+        p, (asdl_seq *)slash_with_default->plain_names,
+        (asdl_seq *)slash_with_default_names);
+  } else {
+    *posonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
+  }
+  return *posonlyargs == NULL ? -1 : 0;
+}
+
+static int _make_posargs(Parser *p, asdl_arg_seq *plain_names,
+                         asdl_seq *names_with_default, asdl_arg_seq **posargs) {
+  if (plain_names != NULL && names_with_default != NULL) {
+    asdl_arg_seq *names_with_default_names = _get_names(p, names_with_default);
+    if (!names_with_default_names) {
+      return -1;
+    }
+    *posargs = (asdl_arg_seq *)_PyPegen_join_sequences(
+        p, (asdl_seq *)plain_names, (asdl_seq *)names_with_default_names);
+  } else if (plain_names == NULL && names_with_default != NULL) {
+    *posargs = _get_names(p, names_with_default);
+  } else if (plain_names != NULL && names_with_default == NULL) {
+    *posargs = plain_names;
+  } else {
+    *posargs = _Py_asdl_arg_seq_new(0, p->arena);
+  }
+  return *posargs == NULL ? -1 : 0;
+}
+
+static int _make_posdefaults(Parser *p, SlashWithDefault *slash_with_default,
+                             asdl_seq *names_with_default,
+                             asdl_expr_seq **posdefaults) {
+  if (slash_with_default != NULL && names_with_default != NULL) {
+    asdl_expr_seq *slash_with_default_values =
+        _get_defaults(p, slash_with_default->names_with_defaults);
+    if (!slash_with_default_values) {
+      return -1;
+    }
+    asdl_expr_seq *names_with_default_values =
+        _get_defaults(p, names_with_default);
+    if (!names_with_default_values) {
+      return -1;
+    }
+    *posdefaults = (asdl_expr_seq *)_PyPegen_join_sequences(
+        p, (asdl_seq *)slash_with_default_values,
+        (asdl_seq *)names_with_default_values);
+  } else if (slash_with_default == NULL && names_with_default != NULL) {
+    *posdefaults = _get_defaults(p, names_with_default);
+  } else if (slash_with_default != NULL && names_with_default == NULL) {
+    *posdefaults = _get_defaults(p, slash_with_default->names_with_defaults);
+  } else {
+    *posdefaults = _Py_asdl_expr_seq_new(0, p->arena);
+  }
+  return *posdefaults == NULL ? -1 : 0;
+}
+
+static int _make_kwargs(Parser *p, StarEtc *star_etc, asdl_arg_seq **kwonlyargs,
+                        asdl_expr_seq **kwdefaults) {
+  if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
+    *kwonlyargs = _get_names(p, star_etc->kwonlyargs);
+  } else {
+    *kwonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
+  }
+
+  if (*kwonlyargs == NULL) {
+    return -1;
+  }
+
+  if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
+    *kwdefaults = _get_defaults(p, star_etc->kwonlyargs);
+  } else {
+    *kwdefaults = _Py_asdl_expr_seq_new(0, p->arena);
+  }
+
+  if (*kwdefaults == NULL) {
+    return -1;
+  }
+
+  return 0;
+}
+
+/* Constructs an arguments_ty object out of all the parsed constructs in the
+ * parameters rule */
+arguments_ty _PyPegen_make_arguments(Parser *p,
+                                     asdl_arg_seq *slash_without_default,
+                                     SlashWithDefault *slash_with_default,
+                                     asdl_arg_seq *plain_names,
+                                     asdl_seq *names_with_default,
+                                     StarEtc *star_etc) {
+  asdl_arg_seq *posonlyargs;
+  if (_make_posonlyargs(p, slash_without_default, slash_with_default,
+                        &posonlyargs) == -1) {
+    return NULL;
+  }
+
+  asdl_arg_seq *posargs;
+  if (_make_posargs(p, plain_names, names_with_default, &posargs) == -1) {
+    return NULL;
+  }
+
+  asdl_expr_seq *posdefaults;
+  if (_make_posdefaults(p, slash_with_default, names_with_default,
+                        &posdefaults) == -1) {
+    return NULL;
+  }
+
+  arg_ty vararg = NULL;
+  if (star_etc != NULL && star_etc->vararg != NULL) {
+    vararg = star_etc->vararg;
+  }
+
+  asdl_arg_seq *kwonlyargs;
+  asdl_expr_seq *kwdefaults;
+  if (_make_kwargs(p, star_etc, &kwonlyargs, &kwdefaults) == -1) {
+    return NULL;
+  }
+
+  arg_ty kwarg = NULL;
+  if (star_etc != NULL && star_etc->kwarg != NULL) {
+    kwarg = star_etc->kwarg;
+  }
+
+  return _PyAST_arguments(posonlyargs, posargs, vararg, kwonlyargs, kwdefaults,
+                          kwarg, posdefaults, p->arena);
+}
+
+/* Constructs an empty arguments_ty object, that gets used when a function
+ * accepts no arguments. */
+arguments_ty _PyPegen_empty_arguments(Parser *p) {
+  asdl_arg_seq *posonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
+  if (!posonlyargs) {
+    return NULL;
+  }
+  asdl_arg_seq *posargs = _Py_asdl_arg_seq_new(0, p->arena);
+  if (!posargs) {
+    return NULL;
+  }
+  asdl_expr_seq *posdefaults = _Py_asdl_expr_seq_new(0, p->arena);
+  if (!posdefaults) {
+    return NULL;
+  }
+  asdl_arg_seq *kwonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
+  if (!kwonlyargs) {
+    return NULL;
+  }
+  asdl_expr_seq *kwdefaults = _Py_asdl_expr_seq_new(0, p->arena);
+  if (!kwdefaults) {
+    return NULL;
+  }
+
+  return _PyAST_arguments(posonlyargs, posargs, NULL, kwonlyargs, kwdefaults,
+                          NULL, posdefaults, p->arena);
 }
 
 /* Encapsulates the value of an operator_ty into an AugOperator struct */
-AugOperator *
-_PyPegen_augoperator(Parser *p, operator_ty kind)
-{
-    AugOperator *a = _PyArena_Malloc(p->arena, sizeof(AugOperator));
-    if (!a) {
-        return NULL;
-    }
-    a->kind = kind;
-    return a;
+AugOperator *_PyPegen_augoperator(Parser *p, operator_ty kind) {
+  AugOperator *a = _PyArena_Malloc(p->arena, sizeof(AugOperator));
+  if (!a) {
+    return NULL;
+  }
+  a->kind = kind;
+  return a;
 }
 
 /* Construct a FunctionDef equivalent to function_def, but with decorators */
-stmt_ty
-_PyPegen_function_def_decorators(Parser *p, asdl_expr_seq *decorators, stmt_ty function_def)
-{
-    assert(function_def != NULL);
-    if (function_def->kind == AsyncFunctionDef_kind) {
-        return _PyAST_AsyncFunctionDef(
-            function_def->v.AsyncFunctionDef.name,
-            function_def->v.AsyncFunctionDef.args,
-            function_def->v.AsyncFunctionDef.body, decorators,
-            function_def->v.AsyncFunctionDef.returns,
-            function_def->v.AsyncFunctionDef.type_comment,
-            function_def->v.AsyncFunctionDef.type_params,
-            function_def->lineno, function_def->col_offset,
-            function_def->end_lineno, function_def->end_col_offset, p->arena);
-    }
-
-    return _PyAST_FunctionDef(
-        function_def->v.FunctionDef.name,
-        function_def->v.FunctionDef.args,
-        function_def->v.FunctionDef.body, decorators,
-        function_def->v.FunctionDef.returns,
-        function_def->v.FunctionDef.type_comment,
-        function_def->v.FunctionDef.type_params,
-        function_def->lineno, function_def->col_offset,
-        function_def->end_lineno, function_def->end_col_offset, p->arena);
+stmt_ty _PyPegen_function_def_decorators(Parser *p, asdl_expr_seq *decorators,
+                                         stmt_ty function_def) {
+  assert(function_def != NULL);
+  if (function_def->kind == AsyncFunctionDef_kind) {
+    return _PyAST_AsyncFunctionDef(
+        function_def->v.AsyncFunctionDef.name,
+        function_def->v.AsyncFunctionDef.args,
+        function_def->v.AsyncFunctionDef.body, decorators,
+        function_def->v.AsyncFunctionDef.returns,
+        function_def->v.AsyncFunctionDef.type_comment,
+        function_def->v.AsyncFunctionDef.type_params, function_def->lineno,
+        function_def->col_offset, function_def->end_lineno,
+        function_def->end_col_offset, p->arena);
+  }
+
+  return _PyAST_FunctionDef(
+      function_def->v.FunctionDef.name, function_def->v.FunctionDef.args,
+      function_def->v.FunctionDef.body, decorators,
+      function_def->v.FunctionDef.returns,
+      function_def->v.FunctionDef.type_comment,
+      function_def->v.FunctionDef.type_params, function_def->lineno,
+      function_def->col_offset, function_def->end_lineno,
+      function_def->end_col_offset, p->arena);
 }
 
 /* Construct a ClassDef equivalent to class_def, but with decorators */
-stmt_ty
-_PyPegen_class_def_decorators(Parser *p, asdl_expr_seq *decorators, stmt_ty class_def)
-{
-    assert(class_def != NULL);
-    return _PyAST_ClassDef(
-        class_def->v.ClassDef.name,
-        class_def->v.ClassDef.bases, class_def->v.ClassDef.keywords,
-        class_def->v.ClassDef.body, decorators,
-        class_def->v.ClassDef.type_params,
-        class_def->lineno, class_def->col_offset, class_def->end_lineno,
-        class_def->end_col_offset, p->arena);
+stmt_ty _PyPegen_class_def_decorators(Parser *p, asdl_expr_seq *decorators,
+                                      stmt_ty class_def) {
+  assert(class_def != NULL);
+  return _PyAST_ClassDef(
+      class_def->v.ClassDef.name, class_def->v.ClassDef.bases,
+      class_def->v.ClassDef.keywords, class_def->v.ClassDef.body, decorators,
+      class_def->v.ClassDef.type_params, class_def->lineno,
+      class_def->col_offset, class_def->end_lineno, class_def->end_col_offset,
+      p->arena);
 }
 
 /* Construct a KeywordOrStarred */
-KeywordOrStarred *
-_PyPegen_keyword_or_starred(Parser *p, void *element, int is_keyword)
-{
-    KeywordOrStarred *a = _PyArena_Malloc(p->arena, sizeof(KeywordOrStarred));
-    if (!a) {
-        return NULL;
-    }
-    a->element = element;
-    a->is_keyword = is_keyword;
-    return a;
-}
-
-/* Get the number of starred expressions in an asdl_seq* of KeywordOrStarred*s */
-static int
-_seq_number_of_starred_exprs(asdl_seq *seq)
-{
-    int n = 0;
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
-        KeywordOrStarred *k = asdl_seq_GET_UNTYPED(seq, i);
-        if (!k->is_keyword) {
-            n++;
-        }
-    }
-    return n;
+KeywordOrStarred *_PyPegen_keyword_or_starred(Parser *p, void *element,
+                                              int is_keyword) {
+  KeywordOrStarred *a = _PyArena_Malloc(p->arena, sizeof(KeywordOrStarred));
+  if (!a) {
+    return NULL;
+  }
+  a->element = element;
+  a->is_keyword = is_keyword;
+  return a;
+}
+
+/* Get the number of starred expressions in an asdl_seq* of KeywordOrStarred*s
+ */
+static int _seq_number_of_starred_exprs(asdl_seq *seq) {
+  int n = 0;
+  for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+    KeywordOrStarred *k = asdl_seq_GET_UNTYPED(seq, i);
+    if (!k->is_keyword) {
+      n++;
+    }
+  }
+  return n;
 }
 
 /* Extract the starred expressions of an asdl_seq* of KeywordOrStarred*s */
-asdl_expr_seq *
-_PyPegen_seq_extract_starred_exprs(Parser *p, asdl_seq *kwargs)
-{
-    int new_len = _seq_number_of_starred_exprs(kwargs);
-    if (new_len == 0) {
-        return NULL;
-    }
-    asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(new_len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-
-    int idx = 0;
-    for (Py_ssize_t i = 0, len = asdl_seq_LEN(kwargs); i < len; i++) {
-        KeywordOrStarred *k = asdl_seq_GET_UNTYPED(kwargs, i);
-        if (!k->is_keyword) {
-            asdl_seq_SET(new_seq, idx++, k->element);
-        }
-    }
-    return new_seq;
+asdl_expr_seq *_PyPegen_seq_extract_starred_exprs(Parser *p, asdl_seq *kwargs) {
+  int new_len = _seq_number_of_starred_exprs(kwargs);
+  if (new_len == 0) {
+    return NULL;
+  }
+  asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(new_len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+
+  int idx = 0;
+  for (Py_ssize_t i = 0, len = asdl_seq_LEN(kwargs); i < len; i++) {
+    KeywordOrStarred *k = asdl_seq_GET_UNTYPED(kwargs, i);
+    if (!k->is_keyword) {
+      asdl_seq_SET(new_seq, idx++, k->element);
+    }
+  }
+  return new_seq;
 }
 
 /* Return a new asdl_seq* with only the keywords in kwargs */
-asdl_keyword_seq*
-_PyPegen_seq_delete_starred_exprs(Parser *p, asdl_seq *kwargs)
-{
-    Py_ssize_t len = asdl_seq_LEN(kwargs);
-    Py_ssize_t new_len = len - _seq_number_of_starred_exprs(kwargs);
-    if (new_len == 0) {
-        return NULL;
-    }
-    asdl_keyword_seq *new_seq = _Py_asdl_keyword_seq_new(new_len, p->arena);
-    if (!new_seq) {
-        return NULL;
-    }
-
-    int idx = 0;
-    for (Py_ssize_t i = 0; i < len; i++) {
-        KeywordOrStarred *k = asdl_seq_GET_UNTYPED(kwargs, i);
-        if (k->is_keyword) {
-            asdl_seq_SET(new_seq, idx++, k->element);
-        }
-    }
-    return new_seq;
-}
-
-expr_ty
-_PyPegen_ensure_imaginary(Parser *p, expr_ty exp)
-{
-    if (exp->kind != Constant_kind || !PyComplex_CheckExact(exp->v.Constant.value)) {
-        RAISE_SYNTAX_ERROR_KNOWN_LOCATION(exp, "imaginary number required in complex literal");
-        return NULL;
-    }
-    return exp;
-}
-
-expr_ty
-_PyPegen_ensure_real(Parser *p, expr_ty exp)
-{
-    if (exp->kind != Constant_kind || PyComplex_CheckExact(exp->v.Constant.value)) {
-        RAISE_SYNTAX_ERROR_KNOWN_LOCATION(exp, "real number required in complex literal");
-        return NULL;
-    }
-    return exp;
-}
-
-mod_ty
-_PyPegen_make_module(Parser *p, asdl_stmt_seq *a) {
-    asdl_type_ignore_seq *type_ignores = NULL;
-    Py_ssize_t num = p->type_ignore_comments.num_items;
-    if (num > 0) {
-        // Turn the raw (comment, lineno) pairs into TypeIgnore objects in the arena
-        type_ignores = _Py_asdl_type_ignore_seq_new(num, p->arena);
-        if (type_ignores == NULL) {
-            return NULL;
-        }
-        for (int i = 0; i < num; i++) {
-            PyObject *tag = _PyPegen_new_type_comment(p, p->type_ignore_comments.items[i].comment);
-            if (tag == NULL) {
-                return NULL;
-            }
-            type_ignore_ty ti = _PyAST_TypeIgnore(p->type_ignore_comments.items[i].lineno,
-                                                  tag, p->arena);
-            if (ti == NULL) {
-                return NULL;
-            }
-            asdl_seq_SET(type_ignores, i, ti);
-        }
-    }
-    return _PyAST_Module(a, type_ignores, p->arena);
-}
-
-PyObject *
-_PyPegen_new_type_comment(Parser *p, const char *s)
-{
-    PyObject *res = PyUnicode_DecodeUTF8(s, strlen(s), NULL);
-    if (res == NULL) {
-        return NULL;
-    }
-    if (_PyArena_AddPyObject(p->arena, res) < 0) {
-        Py_DECREF(res);
-        return NULL;
-    }
-    return res;
-}
-
-arg_ty
-_PyPegen_add_type_comment_to_arg(Parser *p, arg_ty a, Token *tc)
-{
-    if (tc == NULL) {
-        return a;
-    }
-    const char *bytes = PyBytes_AsString(tc->bytes);
-    if (bytes == NULL) {
-        return NULL;
-    }
-    PyObject *tco = _PyPegen_new_type_comment(p, bytes);
-    if (tco == NULL) {
-        return NULL;
-    }
-    return _PyAST_arg(a->arg, a->annotation, tco,
-                      a->lineno, a->col_offset, a->end_lineno, a->end_col_offset,
-                      p->arena);
+asdl_keyword_seq *_PyPegen_seq_delete_starred_exprs(Parser *p,
+                                                    asdl_seq *kwargs) {
+  Py_ssize_t len = asdl_seq_LEN(kwargs);
+  Py_ssize_t new_len = len - _seq_number_of_starred_exprs(kwargs);
+  if (new_len == 0) {
+    return NULL;
+  }
+  asdl_keyword_seq *new_seq = _Py_asdl_keyword_seq_new(new_len, p->arena);
+  if (!new_seq) {
+    return NULL;
+  }
+
+  int idx = 0;
+  for (Py_ssize_t i = 0; i < len; i++) {
+    KeywordOrStarred *k = asdl_seq_GET_UNTYPED(kwargs, i);
+    if (k->is_keyword) {
+      asdl_seq_SET(new_seq, idx++, k->element);
+    }
+  }
+  return new_seq;
+}
+
+expr_ty _PyPegen_ensure_imaginary(Parser *p, expr_ty exp) {
+  if (exp->kind != Constant_kind ||
+      !PyComplex_CheckExact(exp->v.Constant.value)) {
+    RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
+        exp, "imaginary number required in complex literal");
+    return NULL;
+  }
+  return exp;
+}
+
+expr_ty _PyPegen_ensure_real(Parser *p, expr_ty exp) {
+  if (exp->kind != Constant_kind ||
+      PyComplex_CheckExact(exp->v.Constant.value)) {
+    RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
+        exp, "real number required in complex literal");
+    return NULL;
+  }
+  return exp;
+}
+
+mod_ty _PyPegen_make_module(Parser *p, asdl_stmt_seq *a) {
+  asdl_type_ignore_seq *type_ignores = NULL;
+  Py_ssize_t num = p->type_ignore_comments.num_items;
+  if (num > 0) {
+    // Turn the raw (comment, lineno) pairs into TypeIgnore objects in the arena
+    type_ignores = _Py_asdl_type_ignore_seq_new(num, p->arena);
+    if (type_ignores == NULL) {
+      return NULL;
+    }
+    for (int i = 0; i < num; i++) {
+      PyObject *tag = _PyPegen_new_type_comment(
+          p, p->type_ignore_comments.items[i].comment);
+      if (tag == NULL) {
+        return NULL;
+      }
+      type_ignore_ty ti = _PyAST_TypeIgnore(
+          p->type_ignore_comments.items[i].lineno, tag, p->arena);
+      if (ti == NULL) {
+        return NULL;
+      }
+      asdl_seq_SET(type_ignores, i, ti);
+    }
+  }
+  return _PyAST_Module(a, type_ignores, p->arena);
+}
+
+PyObject *_PyPegen_new_type_comment(Parser *p, const char *s) {
+  PyObject *res = PyUnicode_DecodeUTF8(s, strlen(s), NULL);
+  if (res == NULL) {
+    return NULL;
+  }
+  if (_PyArena_AddPyObject(p->arena, res) < 0) {
+    Py_DECREF(res);
+    return NULL;
+  }
+  return res;
+}
+
+arg_ty _PyPegen_add_type_comment_to_arg(Parser *p, arg_ty a, Token *tc) {
+  if (tc == NULL) {
+    return a;
+  }
+  const char *bytes = PyBytes_AsString(tc->bytes);
+  if (bytes == NULL) {
+    return NULL;
+  }
+  PyObject *tco = _PyPegen_new_type_comment(p, bytes);
+  if (tco == NULL) {
+    return NULL;
+  }
+  return _PyAST_arg(a->arg, a->annotation, tco, a->lineno, a->col_offset,
+                    a->end_lineno, a->end_col_offset, p->arena);
 }
 
 /* Checks if the NOTEQUAL token is valid given the current parser flags
 0 indicates success and nonzero indicates failure (an exception may be set) */
-int
-_PyPegen_check_barry_as_flufl(Parser *p, Token* t) {
-    assert(t->bytes != NULL);
-    assert(t->type == NOTEQUAL);
-
-    const char* tok_str = PyBytes_AS_STRING(t->bytes);
-    if (p->flags & PyPARSE_BARRY_AS_BDFL && strcmp(tok_str, "<>") != 0) {
-        RAISE_SYNTAX_ERROR("with Barry as BDFL, use '<>' instead of '!='");
-        return -1;
-    }
-    if (!(p->flags & PyPARSE_BARRY_AS_BDFL)) {
-        return strcmp(tok_str, "!=");
-    }
+int _PyPegen_check_barry_as_flufl(Parser *p, Token *t) {
+  assert(t->bytes != NULL);
+  assert(t->type == NOTEQUAL);
+
+  const char *tok_str = PyBytes_AS_STRING(t->bytes);
+  if (p->flags & PyPARSE_BARRY_AS_BDFL && strcmp(tok_str, "<>") != 0) {
+    RAISE_SYNTAX_ERROR("with Barry as BDFL, use '<>' instead of '!='");
+    return -1;
+  }
+  if (!(p->flags & PyPARSE_BARRY_AS_BDFL)) {
+    return strcmp(tok_str, "!=");
+  }
+  return 0;
+}
+
+int _PyPegen_check_legacy_stmt(Parser *p, expr_ty name) {
+  if (name->kind != Name_kind) {
     return 0;
-}
-
-int
-_PyPegen_check_legacy_stmt(Parser *p, expr_ty name) {
-    if (name->kind != Name_kind) {
-        return 0;
-    }
-    const char* candidates[2] = {"print", "exec"};
-    for (int i=0; i<2; i++) {
-        if (PyUnicode_CompareWithASCIIString(name->v.Name.id, candidates[i]) == 0) {
-            return 1;
-        }
+  }
+  const char *candidates[2] = {"print", "exec"};
+  for (int i = 0; i < 2; i++) {
+    if (PyUnicode_CompareWithASCIIString(name->v.Name.id, candidates[i]) == 0) {
+      return 1;
     }
-    return 0;
+  }
+  return 0;
 }
 
 static ResultTokenWithMetadata *
-result_token_with_metadata(Parser *p, void *result, PyObject *metadata)
-{
-    ResultTokenWithMetadata *res = _PyArena_Malloc(p->arena, sizeof(ResultTokenWithMetadata));
-    if (res == NULL) {
-        return NULL;
-    }
-    res->metadata = metadata;
-    res->result = result;
-    return res;
+result_token_with_metadata(Parser *p, void *result, PyObject *metadata) {
+  ResultTokenWithMetadata *res =
+      _PyArena_Malloc(p->arena, sizeof(ResultTokenWithMetadata));
+  if (res == NULL) {
+    return NULL;
+  }
+  res->metadata = metadata;
+  res->result = result;
+  return res;
 }
 
 ResultTokenWithMetadata *
-_PyPegen_check_fstring_conversion(Parser *p, Token* conv_token, expr_ty conv)
-{
-    if (conv_token->lineno != conv->lineno || conv_token->end_col_offset != conv->col_offset) {
-        return RAISE_SYNTAX_ERROR_KNOWN_RANGE(
-            conv_token, conv,
-            "f-string: conversion type must come right after the exclamanation mark"
-        );
-    }
-    return result_token_with_metadata(p, conv, conv_token->metadata);
+_PyPegen_check_fstring_conversion(Parser *p, Token *conv_token, expr_ty conv) {
+  if (conv_token->lineno != conv->lineno ||
+      conv_token->end_col_offset != conv->col_offset) {
+    return RAISE_SYNTAX_ERROR_KNOWN_RANGE(conv_token, conv,
+                                          "f-string: conversion type must come "
+                                          "right after the exclamanation mark");
+  }
+  return result_token_with_metadata(p, conv, conv_token->metadata);
 }
 
+static asdl_expr_seq *
+unpack_top_level_joined_strs(Parser *p, asdl_expr_seq *raw_expressions);
 ResultTokenWithMetadata *
-_PyPegen_setup_full_format_spec(Parser *p, Token *colon, asdl_expr_seq *spec, int lineno, int col_offset,
-                                int end_lineno, int end_col_offset, PyArena *arena)
-{
-    if (!spec) {
-        return NULL;
-    }
-
-    // This is needed to keep compatibility with 3.11, where an empty format spec is parsed
-    // as an *empty* JoinedStr node, instead of having an empty constant in it.
-    if (asdl_seq_LEN(spec) == 1) {
-        expr_ty e = asdl_seq_GET(spec, 0);
-        if (e->kind == Constant_kind
-                && PyUnicode_Check(e->v.Constant.value)
-                && PyUnicode_GetLength(e->v.Constant.value) == 0) {
-            spec = _Py_asdl_expr_seq_new(0, arena);
-        }
-    }
-
-    expr_ty res = _PyAST_JoinedStr(spec, lineno, col_offset, end_lineno, end_col_offset, p->arena);
-    if (!res) {
-        return NULL;
-    }
-    return result_token_with_metadata(p, res, colon->metadata);
-}
-
-const char *
-_PyPegen_get_expr_name(expr_ty e)
-{
-    assert(e != NULL);
-    switch (e->kind) {
-        case Attribute_kind:
-            return "attribute";
-        case Subscript_kind:
-            return "subscript";
-        case Starred_kind:
-            return "starred";
-        case Name_kind:
-            return "name";
-        case List_kind:
-            return "list";
-        case Tuple_kind:
-            return "tuple";
-        case Lambda_kind:
-            return "lambda";
-        case Call_kind:
-            return "function call";
-        case BoolOp_kind:
-        case BinOp_kind:
-        case UnaryOp_kind:
-            return "expression";
-        case GeneratorExp_kind:
-            return "generator expression";
-        case Yield_kind:
-        case YieldFrom_kind:
-            return "yield expression";
-        case Await_kind:
-            return "await expression";
-        case ListComp_kind:
-            return "list comprehension";
-        case SetComp_kind:
-            return "set comprehension";
-        case DictComp_kind:
-            return "dict comprehension";
-        case Dict_kind:
-            return "dict literal";
-        case Set_kind:
-            return "set display";
-        case JoinedStr_kind:
-        case FormattedValue_kind:
-            return "f-string expression";
-        case Constant_kind: {
-            PyObject *value = e->v.Constant.value;
-            if (value == Py_None) {
-                return "None";
-            }
-            if (value == Py_False) {
-                return "False";
-            }
-            if (value == Py_True) {
-                return "True";
-            }
-            if (value == Py_Ellipsis) {
-                return "ellipsis";
-            }
-            return "literal";
-        }
-        case Compare_kind:
-            return "comparison";
-        case IfExp_kind:
-            return "conditional expression";
-        case NamedExpr_kind:
-            return "named expression";
-        default:
-            PyErr_Format(PyExc_SystemError,
-                         "unexpected expression in assignment %d (line %d)",
-                         e->kind, e->lineno);
-            return NULL;
-    }
-}
-
-expr_ty
-_PyPegen_get_last_comprehension_item(comprehension_ty comprehension) {
-    if (comprehension->ifs == NULL || asdl_seq_LEN(comprehension->ifs) == 0) {
-        return comprehension->iter;
-    }
-    return PyPegen_last_item(comprehension->ifs, expr_ty);
+_PyPegen_setup_full_format_spec(Parser *p, Token *colon, asdl_expr_seq *spec,
+                                int lineno, int col_offset, int end_lineno,
+                                int end_col_offset, PyArena *arena) {
+  if (!spec) {
+    return NULL;
+  }
+
+  // This is needed to keep compatibility with 3.11, where an empty format spec
+  // is parsed as an *empty* JoinedStr node, instead of having an empty constant
+  // in it.
+  if (asdl_seq_LEN(spec) == 1) {
+    expr_ty e = asdl_seq_GET(spec, 0);
+    if (e->kind == Constant_kind && PyUnicode_Check(e->v.Constant.value) &&
+        PyUnicode_GetLength(e->v.Constant.value) == 0) {
+      spec = _Py_asdl_expr_seq_new(0, arena);
+    }
+  }
+  expr_ty res;
+  Py_ssize_t n = asdl_seq_LEN(spec);
+  if (n == 0 || (n == 1 && asdl_seq_GET(spec, 0)->kind == Constant_kind)) {
+    res = _PyAST_JoinedStr(spec, lineno, col_offset, end_lineno, end_col_offset,
+                           p->arena);
+  } else {
+    res = _PyPegen_concatenate_strings(p, spec, lineno, col_offset, end_lineno,
+                                       end_col_offset, arena);
+  }
+  if (!res) {
+    return NULL;
+  }
+  return result_token_with_metadata(p, res, colon->metadata);
+}
+
+const char *_PyPegen_get_expr_name(expr_ty e) {
+  assert(e != NULL);
+  switch (e->kind) {
+  case Attribute_kind:
+    return "attribute";
+  case Subscript_kind:
+    return "subscript";
+  case Starred_kind:
+    return "starred";
+  case Name_kind:
+    return "name";
+  case List_kind:
+    return "list";
+  case Tuple_kind:
+    return "tuple";
+  case Lambda_kind:
+    return "lambda";
+  case Call_kind:
+    return "function call";
+  case BoolOp_kind:
+  case BinOp_kind:
+  case UnaryOp_kind:
+    return "expression";
+  case GeneratorExp_kind:
+    return "generator expression";
+  case Yield_kind:
+  case YieldFrom_kind:
+    return "yield expression";
+  case Await_kind:
+    return "await expression";
+  case ListComp_kind:
+    return "list comprehension";
+  case SetComp_kind:
+    return "set comprehension";
+  case DictComp_kind:
+    return "dict comprehension";
+  case Dict_kind:
+    return "dict literal";
+  case Set_kind:
+    return "set display";
+  case JoinedStr_kind:
+  case FormattedValue_kind:
+    return "f-string expression";
+  case Constant_kind: {
+    PyObject *value = e->v.Constant.value;
+    if (value == Py_None) {
+      return "None";
+    }
+    if (value == Py_False) {
+      return "False";
+    }
+    if (value == Py_True) {
+      return "True";
+    }
+    if (value == Py_Ellipsis) {
+      return "ellipsis";
+    }
+    return "literal";
+  }
+  case Compare_kind:
+    return "comparison";
+  case IfExp_kind:
+    return "conditional expression";
+  case NamedExpr_kind:
+    return "named expression";
+  default:
+    PyErr_Format(PyExc_SystemError,
+                 "unexpected expression in assignment %d (line %d)", e->kind,
+                 e->lineno);
+    return NULL;
+  }
+}
+
+expr_ty _PyPegen_get_last_comprehension_item(comprehension_ty comprehension) {
+  if (comprehension->ifs == NULL || asdl_seq_LEN(comprehension->ifs) == 0) {
+    return comprehension->iter;
+  }
+  return PyPegen_last_item(comprehension->ifs, expr_ty);
 }
 
 expr_ty _PyPegen_collect_call_seqs(Parser *p, asdl_expr_seq *a, asdl_seq *b,
-                     int lineno, int col_offset, int end_lineno,
-                     int end_col_offset, PyArena *arena) {
-    Py_ssize_t args_len = asdl_seq_LEN(a);
-    Py_ssize_t total_len = args_len;
+                                   int lineno, int col_offset, int end_lineno,
+                                   int end_col_offset, PyArena *arena) {
+  Py_ssize_t args_len = asdl_seq_LEN(a);
+  Py_ssize_t total_len = args_len;
 
-    if (b == NULL) {
-        return _PyAST_Call(_PyPegen_dummy_name(p), a, NULL, lineno, col_offset,
-                        end_lineno, end_col_offset, arena);
+  if (b == NULL) {
+    return _PyAST_Call(_PyPegen_dummy_name(p), a, NULL, lineno, col_offset,
+                       end_lineno, end_col_offset, arena);
+  }
 
-    }
+  asdl_expr_seq *starreds = _PyPegen_seq_extract_starred_exprs(p, b);
+  asdl_keyword_seq *keywords = _PyPegen_seq_delete_starred_exprs(p, b);
 
-    asdl_expr_seq *starreds = _PyPegen_seq_extract_starred_exprs(p, b);
-    asdl_keyword_seq *keywords = _PyPegen_seq_delete_starred_exprs(p, b);
+  if (starreds) {
+    total_len += asdl_seq_LEN(starreds);
+  }
 
-    if (starreds) {
-        total_len += asdl_seq_LEN(starreds);
-    }
+  asdl_expr_seq *args = _Py_asdl_expr_seq_new(total_len, arena);
 
-    asdl_expr_seq *args = _Py_asdl_expr_seq_new(total_len, arena);
-
-    Py_ssize_t i = 0;
-    for (i = 0; i < args_len; i++) {
-        asdl_seq_SET(args, i, asdl_seq_GET(a, i));
-    }
-    for (; i < total_len; i++) {
-        asdl_seq_SET(args, i, asdl_seq_GET(starreds, i - args_len));
-    }
+  Py_ssize_t i = 0;
+  for (i = 0; i < args_len; i++) {
+    asdl_seq_SET(args, i, asdl_seq_GET(a, i));
+  }
+  for (; i < total_len; i++) {
+    asdl_seq_SET(args, i, asdl_seq_GET(starreds, i - args_len));
+  }
 
-    return _PyAST_Call(_PyPegen_dummy_name(p), args, keywords, lineno,
-                       col_offset, end_lineno, end_col_offset, arena);
+  return _PyAST_Call(_PyPegen_dummy_name(p), args, keywords, lineno, col_offset,
+                     end_lineno, end_col_offset, arena);
 }
 
 // AST Error reporting helpers
 
-expr_ty
-_PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type)
-{
-    if (e == NULL) {
-        return NULL;
-    }
-
-#define VISIT_CONTAINER(CONTAINER, TYPE) do { \
-        Py_ssize_t len = asdl_seq_LEN((CONTAINER)->v.TYPE.elts);\
-        for (Py_ssize_t i = 0; i < len; i++) {\
-            expr_ty other = asdl_seq_GET((CONTAINER)->v.TYPE.elts, i);\
-            expr_ty child = _PyPegen_get_invalid_target(other, targets_type);\
-            if (child != NULL) {\
-                return child;\
-            }\
-        }\
-    } while (0)
-
-    // We only need to visit List and Tuple nodes recursively as those
-    // are the only ones that can contain valid names in targets when
-    // they are parsed as expressions. Any other kind of expression
-    // that is a container (like Sets or Dicts) is directly invalid and
-    // we don't need to visit it recursively.
-
-    switch (e->kind) {
-        case List_kind:
-            VISIT_CONTAINER(e, List);
-            return NULL;
-        case Tuple_kind:
-            VISIT_CONTAINER(e, Tuple);
-            return NULL;
-        case Starred_kind:
-            if (targets_type == DEL_TARGETS) {
-                return e;
-            }
-            return _PyPegen_get_invalid_target(e->v.Starred.value, targets_type);
-        case Compare_kind:
-            // This is needed, because the `a in b` in `for a in b` gets parsed
-            // as a comparison, and so we need to search the left side of the comparison
-            // for invalid targets.
-            if (targets_type == FOR_TARGETS) {
-                cmpop_ty cmpop = (cmpop_ty) asdl_seq_GET(e->v.Compare.ops, 0);
-                if (cmpop == In) {
-                    return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type);
-                }
-                return NULL;
-            }
-            return e;
-        case Name_kind:
-        case Subscript_kind:
-        case Attribute_kind:
-            return NULL;
-        default:
-            return e;
-    }
+expr_ty _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type) {
+  if (e == NULL) {
+    return NULL;
+  }
+
+#define VISIT_CONTAINER(CONTAINER, TYPE)                                       \
+  do {                                                                         \
+    Py_ssize_t len = asdl_seq_LEN((CONTAINER)->v.TYPE.elts);                   \
+    for (Py_ssize_t i = 0; i < len; i++) {                                     \
+      expr_ty other = asdl_seq_GET((CONTAINER)->v.TYPE.elts, i);               \
+      expr_ty child = _PyPegen_get_invalid_target(other, targets_type);        \
+      if (child != NULL) {                                                     \
+        return child;                                                          \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+
+  // We only need to visit List and Tuple nodes recursively as those
+  // are the only ones that can contain valid names in targets when
+  // they are parsed as expressions. Any other kind of expression
+  // that is a container (like Sets or Dicts) is directly invalid and
+  // we don't need to visit it recursively.
+
+  switch (e->kind) {
+  case List_kind:
+    VISIT_CONTAINER(e, List);
+    return NULL;
+  case Tuple_kind:
+    VISIT_CONTAINER(e, Tuple);
+    return NULL;
+  case Starred_kind:
+    if (targets_type == DEL_TARGETS) {
+      return e;
+    }
+    return _PyPegen_get_invalid_target(e->v.Starred.value, targets_type);
+  case Compare_kind:
+    // This is needed, because the `a in b` in `for a in b` gets parsed
+    // as a comparison, and so we need to search the left side of the comparison
+    // for invalid targets.
+    if (targets_type == FOR_TARGETS) {
+      cmpop_ty cmpop = (cmpop_ty)asdl_seq_GET(e->v.Compare.ops, 0);
+      if (cmpop == In) {
+        return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type);
+      }
+      return NULL;
+    }
+    return e;
+  case Name_kind:
+  case Subscript_kind:
+  case Attribute_kind:
+    return NULL;
+  default:
+    return e;
+  }
 }
 
 void *_PyPegen_arguments_parsing_error(Parser *p, expr_ty e) {
-    int kwarg_unpacking = 0;
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(e->v.Call.keywords); i < l; i++) {
-        keyword_ty keyword = asdl_seq_GET(e->v.Call.keywords, i);
-        if (!keyword->arg) {
-            kwarg_unpacking = 1;
-        }
-    }
-
-    const char *msg = NULL;
-    if (kwarg_unpacking) {
-        msg = "positional argument follows keyword argument unpacking";
-    } else {
-        msg = "positional argument follows keyword argument";
-    }
-
-    return RAISE_SYNTAX_ERROR(msg);
-}
-
-void *
-_PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args, asdl_comprehension_seq *comprehensions)
-{
-    /* The rule that calls this function is 'args for_if_clauses'.
-       For the input f(L, x for x in y), L and x are in args and
-       the for is parsed as a for_if_clause. We have to check if
-       len <= 1, so that input like dict((a, b) for a, b in x)
-       gets successfully parsed and then we pass the last
-       argument (x in the above example) as the location of the
-       error */
-    Py_ssize_t len = asdl_seq_LEN(args->v.Call.args);
-    if (len <= 1) {
-        return NULL;
-    }
-
-    comprehension_ty last_comprehension = PyPegen_last_item(comprehensions, comprehension_ty);
-
-    return RAISE_SYNTAX_ERROR_KNOWN_RANGE(
-        (expr_ty) asdl_seq_GET(args->v.Call.args, len - 1),
-        _PyPegen_get_last_comprehension_item(last_comprehension),
-        "Generator expression must be parenthesized"
-    );
+  int kwarg_unpacking = 0;
+  for (Py_ssize_t i = 0, l = asdl_seq_LEN(e->v.Call.keywords); i < l; i++) {
+    keyword_ty keyword = asdl_seq_GET(e->v.Call.keywords, i);
+    if (!keyword->arg) {
+      kwarg_unpacking = 1;
+    }
+  }
+
+  const char *msg = NULL;
+  if (kwarg_unpacking) {
+    msg = "positional argument follows keyword argument unpacking";
+  } else {
+    msg = "positional argument follows keyword argument";
+  }
+
+  return RAISE_SYNTAX_ERROR(msg);
+}
+
+void *_PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args,
+                                       asdl_comprehension_seq *comprehensions) {
+  /* The rule that calls this function is 'args for_if_clauses'.
+     For the input f(L, x for x in y), L and x are in args and
+     the for is parsed as a for_if_clause. We have to check if
+     len <= 1, so that input like dict((a, b) for a, b in x)
+     gets successfully parsed and then we pass the last
+     argument (x in the above example) as the location of the
+     error */
+  Py_ssize_t len = asdl_seq_LEN(args->v.Call.args);
+  if (len <= 1) {
+    return NULL;
+  }
+
+  comprehension_ty last_comprehension =
+      PyPegen_last_item(comprehensions, comprehension_ty);
+
+  return RAISE_SYNTAX_ERROR_KNOWN_RANGE(
+      (expr_ty)asdl_seq_GET(args->v.Call.args, len - 1),
+      _PyPegen_get_last_comprehension_item(last_comprehension),
+      "Generator expression must be parenthesized");
 }
 
 // Fstring stuff
 
-static expr_ty
-_PyPegen_decode_fstring_part(Parser* p, int is_raw, expr_ty constant, Token* token) {
-    assert(PyUnicode_CheckExact(constant->v.Constant.value));
-
-    const char* bstr = PyUnicode_AsUTF8(constant->v.Constant.value);
-    if (bstr == NULL) {
-        return NULL;
-    }
-
-    size_t len;
-    if (strcmp(bstr, "{{") == 0 || strcmp(bstr, "}}") == 0) {
-        len = 1;
-    } else {
-        len = strlen(bstr);
-    }
-
-    is_raw = is_raw || strchr(bstr, '\\') == NULL;
-    PyObject *str = _PyPegen_decode_string(p, is_raw, bstr, len, token);
-    if (str == NULL) {
-        _Pypegen_raise_decode_error(p);
-        return NULL;
-    }
-    if (_PyArena_AddPyObject(p->arena, str) < 0) {
-        Py_DECREF(str);
-        return NULL;
-    }
-    return _PyAST_Constant(str, NULL, constant->lineno, constant->col_offset,
-                           constant->end_lineno, constant->end_col_offset,
-                           p->arena);
+static expr_ty _PyPegen_decode_fstring_part(Parser *p, int is_raw,
+                                            expr_ty constant, Token *token) {
+  assert(PyUnicode_CheckExact(constant->v.Constant.value));
+
+  const char *bstr = PyUnicode_AsUTF8(constant->v.Constant.value);
+  if (bstr == NULL) {
+    return NULL;
+  }
+
+  size_t len;
+  if (strcmp(bstr, "{{") == 0 || strcmp(bstr, "}}") == 0) {
+    len = 1;
+  } else {
+    len = strlen(bstr);
+  }
+
+  is_raw = is_raw || strchr(bstr, '\\') == NULL;
+  PyObject *str = _PyPegen_decode_string(p, is_raw, bstr, len, token);
+  if (str == NULL) {
+    _Pypegen_raise_decode_error(p);
+    return NULL;
+  }
+  if (_PyArena_AddPyObject(p->arena, str) < 0) {
+    Py_DECREF(str);
+    return NULL;
+  }
+  return _PyAST_Constant(str, NULL, constant->lineno, constant->col_offset,
+                         constant->end_lineno, constant->end_col_offset,
+                         p->arena);
 }
 
 static asdl_expr_seq *
-unpack_top_level_joined_strs(Parser *p, asdl_expr_seq *raw_expressions)
-{
-    /* The parser might put multiple f-string values into an individual
-     * JoinedStr node at the top level due to stuff like f-string debugging
-     * expressions. This function flattens those and promotes them to the
-     * upper level. Only simplifies AST, but the compiler already takes care
-     * of the regular output, so this is not necessary if you are not going
-     * to expose the output AST to Python level. */
-
-    Py_ssize_t i, req_size, raw_size;
-
-    req_size = raw_size = asdl_seq_LEN(raw_expressions);
-    expr_ty expr;
-    for (i = 0; i < raw_size; i++) {
-        expr = asdl_seq_GET(raw_expressions, i);
-        if (expr->kind == JoinedStr_kind) {
-            req_size += asdl_seq_LEN(expr->v.JoinedStr.values) - 1;
-        }
-    }
-
-    asdl_expr_seq *expressions = _Py_asdl_expr_seq_new(req_size, p->arena);
-
-    Py_ssize_t raw_index, req_index = 0;
-    for (raw_index = 0; raw_index < raw_size; raw_index++) {
-        expr = asdl_seq_GET(raw_expressions, raw_index);
-        if (expr->kind == JoinedStr_kind) {
-            asdl_expr_seq *values = expr->v.JoinedStr.values;
-            for (Py_ssize_t n = 0; n < asdl_seq_LEN(values); n++) {
-                asdl_seq_SET(expressions, req_index, asdl_seq_GET(values, n));
-                req_index++;
-            }
-        } else {
-            asdl_seq_SET(expressions, req_index, expr);
-            req_index++;
-        }
-    }
-    return expressions;
-}
-
-expr_ty
-_PyPegen_joined_str(Parser *p, Token* a, asdl_expr_seq* raw_expressions, Token*b) {
-    asdl_expr_seq *expr = unpack_top_level_joined_strs(p, raw_expressions);
-    Py_ssize_t n_items = asdl_seq_LEN(expr);
-
-    const char* quote_str = PyBytes_AsString(a->bytes);
-    if (quote_str == NULL) {
-        return NULL;
-    }
-    int is_raw = strpbrk(quote_str, "rR") != NULL;
-
-    asdl_expr_seq *seq = _Py_asdl_expr_seq_new(n_items, p->arena);
-    if (seq == NULL) {
-        return NULL;
-    }
-
-    Py_ssize_t index = 0;
-    for (Py_ssize_t i = 0; i < n_items; i++) {
-        expr_ty item = asdl_seq_GET(expr, i);
-        if (item->kind == Constant_kind) {
-            item = _PyPegen_decode_fstring_part(p, is_raw, item, b);
-            if (item == NULL) {
-                return NULL;
-            }
-
-            /* Tokenizer emits string parts even when the underlying string
-            might become an empty value (e.g. FSTRING_MIDDLE with the value \\n)
-            so we need to check for them and simplify it here. */
-            if (PyUnicode_CheckExact(item->v.Constant.value)
-                && PyUnicode_GET_LENGTH(item->v.Constant.value) == 0) {
-                continue;
-            }
-        }
-        asdl_seq_SET(seq, index++, item);
-    }
-
-    asdl_expr_seq *resized_exprs;
-    if (index != n_items) {
-        resized_exprs = _Py_asdl_expr_seq_new(index, p->arena);
-        if (resized_exprs == NULL) {
-            return NULL;
-        }
-        for (Py_ssize_t i = 0; i < index; i++) {
-            asdl_seq_SET(resized_exprs, i, asdl_seq_GET(seq, i));
-        }
-    }
-    else {
-        resized_exprs = seq;
-    }
-
-    return _PyAST_JoinedStr(resized_exprs, a->lineno, a->col_offset,
-                            b->end_lineno, b->end_col_offset,
-                            p->arena);
-}
-
-expr_ty _PyPegen_decoded_constant_from_token(Parser* p, Token* tok) {
-    Py_ssize_t bsize;
-    char* bstr;
-    if (PyBytes_AsStringAndSize(tok->bytes, &bstr, &bsize) == -1) {
-        return NULL;
-    }
-    PyObject* str = _PyPegen_decode_string(p, 0, bstr, bsize, tok);
-    if (str == NULL) {
-        return NULL;
-    }
-    if (_PyArena_AddPyObject(p->arena, str) < 0) {
-        Py_DECREF(str);
-        return NULL;
-    }
-    return _PyAST_Constant(str, NULL, tok->lineno, tok->col_offset,
-                           tok->end_lineno, tok->end_col_offset,
-                           p->arena);
-}
-
-expr_ty _PyPegen_constant_from_token(Parser* p, Token* tok) {
-    char* bstr = PyBytes_AsString(tok->bytes);
-    if (bstr == NULL) {
-        return NULL;
-    }
-    PyObject* str = PyUnicode_FromString(bstr);
-    if (str == NULL) {
-        return NULL;
-    }
-    if (_PyArena_AddPyObject(p->arena, str) < 0) {
-        Py_DECREF(str);
-        return NULL;
-    }
-    return _PyAST_Constant(str, NULL, tok->lineno, tok->col_offset,
-                           tok->end_lineno, tok->end_col_offset,
-                           p->arena);
-}
-
-expr_ty _PyPegen_constant_from_string(Parser* p, Token* tok) {
-    char* the_str = PyBytes_AsString(tok->bytes);
-    if (the_str == NULL) {
-        return NULL;
-    }
-    PyObject *s = _PyPegen_parse_string(p, tok);
-    if (s == NULL) {
-        _Pypegen_raise_decode_error(p);
-        return NULL;
-    }
-    if (_PyArena_AddPyObject(p->arena, s) < 0) {
-        Py_DECREF(s);
-        return NULL;
-    }
-    PyObject *kind = NULL;
-    if (the_str && the_str[0] == 'u') {
-        kind = _PyPegen_new_identifier(p, "u");
-        if (kind == NULL) {
-            return NULL;
-        }
-    }
-    return _PyAST_Constant(s, kind, tok->lineno, tok->col_offset, tok->end_lineno, tok->end_col_offset, p->arena);
-}
-
-expr_ty _PyPegen_formatted_value(Parser *p, expr_ty expression, Token *debug, ResultTokenWithMetadata *conversion,
-                                 ResultTokenWithMetadata *format, Token *closing_brace, int lineno, int col_offset,
-                                 int end_lineno, int end_col_offset, PyArena *arena) {
-    int conversion_val = -1;
-    if (conversion != NULL) {
-        expr_ty conversion_expr = (expr_ty) conversion->result;
-        assert(conversion_expr->kind == Name_kind);
-        Py_UCS4 first = PyUnicode_READ_CHAR(conversion_expr->v.Name.id, 0);
-
-        if (PyUnicode_GET_LENGTH(conversion_expr->v.Name.id) > 1 ||
-            !(first == 's' || first == 'r' || first == 'a')) {
-            RAISE_SYNTAX_ERROR_KNOWN_LOCATION(conversion_expr,
-                                              "f-string: invalid conversion character %R: expected 's', 'r', or 'a'",
-                                              conversion_expr->v.Name.id);
-            return NULL;
-        }
-
-        conversion_val = Py_SAFE_DOWNCAST(first, Py_UCS4, int);
-    }
-    else if (debug && !format) {
-        /* If no conversion is specified, use !r for debug expressions */
-        conversion_val = (int)'r';
-    }
-
-    expr_ty formatted_value = _PyAST_FormattedValue(
-        expression, conversion_val, format ? (expr_ty) format->result : NULL,
-        lineno, col_offset, end_lineno,
-        end_col_offset, arena
-    );
-
-    if (debug) {
-        /* Find the non whitespace token after the "=" */
-        int debug_end_line, debug_end_offset;
-        PyObject *debug_metadata;
-
-        if (conversion) {
-            debug_end_line = ((expr_ty) conversion->result)->lineno;
-            debug_end_offset = ((expr_ty) conversion->result)->col_offset;
-            debug_metadata = conversion->metadata;
-        }
-        else if (format) {
-            debug_end_line = ((expr_ty) format->result)->lineno;
-            debug_end_offset = ((expr_ty) format->result)->col_offset + 1;
-            debug_metadata = format->metadata;
-        }
-        else {
-            debug_end_line = end_lineno;
-            debug_end_offset = end_col_offset;
-            debug_metadata = closing_brace->metadata;
-        }
-
-        expr_ty debug_text = _PyAST_Constant(debug_metadata, NULL, lineno, col_offset + 1, debug_end_line,
-                                             debug_end_offset - 1, p->arena);
-        if (!debug_text) {
-            return NULL;
-        }
-
-        asdl_expr_seq *values = _Py_asdl_expr_seq_new(2, arena);
-        asdl_seq_SET(values, 0, debug_text);
-        asdl_seq_SET(values, 1, formatted_value);
-        return _PyAST_JoinedStr(values, lineno, col_offset, debug_end_line, debug_end_offset, p->arena);
-    }
-    else {
-        return formatted_value;
-    }
-}
-
-expr_ty
-_PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings,
-                             int lineno, int col_offset, int end_lineno,
-                             int end_col_offset, PyArena *arena)
-{
-    Py_ssize_t len = asdl_seq_LEN(strings);
-    assert(len > 0);
-
-    int f_string_found = 0;
-    int unicode_string_found = 0;
-    int bytes_found = 0;
-
-    Py_ssize_t i = 0;
-    Py_ssize_t n_flattened_elements = 0;
+unpack_top_level_joined_strs(Parser *p, asdl_expr_seq *raw_expressions) {
+  /* The parser might put multiple f-string values into an individual
+   * JoinedStr node at the top level due to stuff like f-string debugging
+   * expressions. This function flattens those and promotes them to the
+   * upper level. Only simplifies AST, but the compiler already takes care
+   * of the regular output, so this is not necessary if you are not going
+   * to expose the output AST to Python level. */
+
+  Py_ssize_t i, req_size, raw_size;
+
+  req_size = raw_size = asdl_seq_LEN(raw_expressions);
+  expr_ty expr;
+  for (i = 0; i < raw_size; i++) {
+    expr = asdl_seq_GET(raw_expressions, i);
+    if (expr->kind == JoinedStr_kind) {
+      req_size += asdl_seq_LEN(expr->v.JoinedStr.values) - 1;
+    }
+  }
+
+  asdl_expr_seq *expressions = _Py_asdl_expr_seq_new(req_size, p->arena);
+
+  Py_ssize_t raw_index, req_index = 0;
+  for (raw_index = 0; raw_index < raw_size; raw_index++) {
+    expr = asdl_seq_GET(raw_expressions, raw_index);
+    if (expr->kind == JoinedStr_kind) {
+      asdl_expr_seq *values = expr->v.JoinedStr.values;
+      for (Py_ssize_t n = 0; n < asdl_seq_LEN(values); n++) {
+        asdl_seq_SET(expressions, req_index, asdl_seq_GET(values, n));
+        req_index++;
+      }
+    } else {
+      asdl_seq_SET(expressions, req_index, expr);
+      req_index++;
+    }
+  }
+  return expressions;
+}
+
+expr_ty _PyPegen_joined_str(Parser *p, Token *a, asdl_expr_seq *raw_expressions,
+                            Token *b) {
+
+  asdl_expr_seq *expr = unpack_top_level_joined_strs(p, raw_expressions);
+  Py_ssize_t n_items = asdl_seq_LEN(expr);
+
+  const char *quote_str = PyBytes_AsString(a->bytes);
+  if (quote_str == NULL) {
+    return NULL;
+  }
+  int is_raw = strpbrk(quote_str, "rR") != NULL;
+
+  asdl_expr_seq *seq = _Py_asdl_expr_seq_new(n_items, p->arena);
+  if (seq == NULL) {
+    return NULL;
+  }
+
+  Py_ssize_t index = 0;
+  for (Py_ssize_t i = 0; i < n_items; i++) {
+    expr_ty item = asdl_seq_GET(expr, i);
+    if (item->kind == Constant_kind) {
+      item = _PyPegen_decode_fstring_part(p, is_raw, item, b);
+      if (item == NULL) {
+        return NULL;
+      }
+
+      /* Tokenizer emits string parts even when the underlying string
+      might become an empty value (e.g. FSTRING_MIDDLE with the value \\n)
+      so we need to check for them and simplify it here. */
+      if (PyUnicode_CheckExact(item->v.Constant.value) &&
+          PyUnicode_GET_LENGTH(item->v.Constant.value) == 0) {
+        continue;
+      }
+    }
+    asdl_seq_SET(seq, index++, item);
+  }
+
+  asdl_expr_seq *resized_exprs;
+  if (index != n_items) {
+    resized_exprs = _Py_asdl_expr_seq_new(index, p->arena);
+    if (resized_exprs == NULL) {
+      return NULL;
+    }
+    for (Py_ssize_t i = 0; i < index; i++) {
+      asdl_seq_SET(resized_exprs, i, asdl_seq_GET(seq, i));
+    }
+  } else {
+    resized_exprs = seq;
+  }
+
+  return _PyAST_JoinedStr(resized_exprs, a->lineno, a->col_offset,
+                          b->end_lineno, b->end_col_offset, p->arena);
+}
+
+expr_ty _PyPegen_decoded_constant_from_token(Parser *p, Token *tok) {
+  Py_ssize_t bsize;
+  char *bstr;
+  if (PyBytes_AsStringAndSize(tok->bytes, &bstr, &bsize) == -1) {
+    return NULL;
+  }
+  PyObject *str = _PyPegen_decode_string(p, 0, bstr, bsize, tok);
+  if (str == NULL) {
+    return NULL;
+  }
+  if (_PyArena_AddPyObject(p->arena, str) < 0) {
+    Py_DECREF(str);
+    return NULL;
+  }
+  return _PyAST_Constant(str, NULL, tok->lineno, tok->col_offset,
+                         tok->end_lineno, tok->end_col_offset, p->arena);
+}
+
+expr_ty _PyPegen_constant_from_token(Parser *p, Token *tok) {
+  char *bstr = PyBytes_AsString(tok->bytes);
+  if (bstr == NULL) {
+    return NULL;
+  }
+  PyObject *str = PyUnicode_FromString(bstr);
+  if (str == NULL) {
+    return NULL;
+  }
+  if (_PyArena_AddPyObject(p->arena, str) < 0) {
+    Py_DECREF(str);
+    return NULL;
+  }
+  return _PyAST_Constant(str, NULL, tok->lineno, tok->col_offset,
+                         tok->end_lineno, tok->end_col_offset, p->arena);
+}
+
+expr_ty _PyPegen_constant_from_string(Parser *p, Token *tok) {
+  char *the_str = PyBytes_AsString(tok->bytes);
+  if (the_str == NULL) {
+    return NULL;
+  }
+  PyObject *s = _PyPegen_parse_string(p, tok);
+  if (s == NULL) {
+    _Pypegen_raise_decode_error(p);
+    return NULL;
+  }
+  if (_PyArena_AddPyObject(p->arena, s) < 0) {
+    Py_DECREF(s);
+    return NULL;
+  }
+  PyObject *kind = NULL;
+  if (the_str && the_str[0] == 'u') {
+    kind = _PyPegen_new_identifier(p, "u");
+    if (kind == NULL) {
+      return NULL;
+    }
+  }
+  return _PyAST_Constant(s, kind, tok->lineno, tok->col_offset, tok->end_lineno,
+                         tok->end_col_offset, p->arena);
+}
+
+expr_ty _PyPegen_formatted_value(Parser *p, expr_ty expression, Token *debug,
+                                 ResultTokenWithMetadata *conversion,
+                                 ResultTokenWithMetadata *format,
+                                 Token *closing_brace, int lineno,
+                                 int col_offset, int end_lineno,
+                                 int end_col_offset, PyArena *arena) {
+  int conversion_val = -1;
+  if (conversion != NULL) {
+    expr_ty conversion_expr = (expr_ty)conversion->result;
+    assert(conversion_expr->kind == Name_kind);
+    Py_UCS4 first = PyUnicode_READ_CHAR(conversion_expr->v.Name.id, 0);
+
+    if (PyUnicode_GET_LENGTH(conversion_expr->v.Name.id) > 1 ||
+        !(first == 's' || first == 'r' || first == 'a')) {
+      RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
+          conversion_expr,
+          "f-string: invalid conversion character %R: expected 's', 'r', or "
+          "'a'",
+          conversion_expr->v.Name.id);
+      return NULL;
+    }
+
+    conversion_val = Py_SAFE_DOWNCAST(first, Py_UCS4, int);
+  } else if (debug && !format) {
+    /* If no conversion is specified, use !r for debug expressions */
+    conversion_val = (int)'r';
+  }
+
+  expr_ty formatted_value = _PyAST_FormattedValue(
+      expression, conversion_val, format ? (expr_ty)format->result : NULL,
+      lineno, col_offset, end_lineno, end_col_offset, arena);
+
+  if (debug) {
+    /* Find the non whitespace token after the "=" */
+    int debug_end_line, debug_end_offset;
+    PyObject *debug_metadata;
+
+    if (conversion) {
+      debug_end_line = ((expr_ty)conversion->result)->lineno;
+      debug_end_offset = ((expr_ty)conversion->result)->col_offset;
+      debug_metadata = conversion->metadata;
+    } else if (format) {
+      debug_end_line = ((expr_ty)format->result)->lineno;
+      debug_end_offset = ((expr_ty)format->result)->col_offset + 1;
+      debug_metadata = format->metadata;
+    } else {
+      debug_end_line = end_lineno;
+      debug_end_offset = end_col_offset;
+      debug_metadata = closing_brace->metadata;
+    }
+    expr_ty debug_text =
+        _PyAST_Constant(debug_metadata, NULL, lineno, col_offset + 1,
+                        debug_end_line, debug_end_offset - 1, p->arena);
+    if (!debug_text) {
+      return NULL;
+    }
+
+    asdl_expr_seq *values = _Py_asdl_expr_seq_new(2, arena);
+    asdl_seq_SET(values, 0, debug_text);
+    asdl_seq_SET(values, 1, formatted_value);
+    return _PyAST_JoinedStr(values, lineno, col_offset, debug_end_line,
+                            debug_end_offset, p->arena);
+  } else {
+    return formatted_value;
+  }
+}
+
+expr_ty _PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings,
+                                     int lineno, int col_offset, int end_lineno,
+                                     int end_col_offset, PyArena *arena) {
+  Py_ssize_t len = asdl_seq_LEN(strings);
+  assert(len > 0);
+
+  int f_string_found = 0;
+  int unicode_string_found = 0;
+  int bytes_found = 0;
+
+  Py_ssize_t i = 0;
+  Py_ssize_t n_flattened_elements = 0;
+  for (i = 0; i < len; i++) {
+    expr_ty elem = asdl_seq_GET(strings, i);
+    switch (elem->kind) {
+    case Constant_kind:
+      if (PyBytes_CheckExact(elem->v.Constant.value)) {
+        bytes_found = 1;
+      } else {
+        unicode_string_found = 1;
+      }
+      n_flattened_elements++;
+      break;
+    case JoinedStr_kind:
+      n_flattened_elements += asdl_seq_LEN(elem->v.JoinedStr.values);
+      f_string_found = 1;
+      break;
+    default:
+      n_flattened_elements++;
+      f_string_found = 1;
+      break;
+    }
+  }
+
+  if ((unicode_string_found || f_string_found) && bytes_found) {
+    RAISE_SYNTAX_ERROR("cannot mix bytes and nonbytes literals");
+    return NULL;
+  }
+
+  if (bytes_found) {
+    PyObject *res = PyBytes_FromString("");
+
+    /* Bytes literals never get a kind, but just for consistency
+       since they are represented as Constant nodes, we'll mirror
+       the same behavior as unicode strings for determining the
+       kind. */
+    PyObject *kind = asdl_seq_GET(strings, 0)->v.Constant.kind;
     for (i = 0; i < len; i++) {
-        expr_ty elem = asdl_seq_GET(strings, i);
-        if (elem->kind == Constant_kind) {
-            if (PyBytes_CheckExact(elem->v.Constant.value)) {
-                bytes_found = 1;
-            } else {
-                unicode_string_found = 1;
+      expr_ty elem = asdl_seq_GET(strings, i);
+      PyBytes_Concat(&res, elem->v.Constant.value);
+    }
+    if (!res || _PyArena_AddPyObject(arena, res) < 0) {
+      Py_XDECREF(res);
+      return NULL;
+    }
+    return _PyAST_Constant(res, kind, lineno, col_offset, end_lineno,
+                           end_col_offset, p->arena);
+  }
+
+  if (!f_string_found && len == 1) {
+    return asdl_seq_GET(strings, 0);
+  }
+
+  asdl_expr_seq *flattened =
+      _Py_asdl_expr_seq_new(n_flattened_elements, p->arena);
+  if (flattened == NULL) {
+    return NULL;
+  }
+
+  /* build flattened list */
+  Py_ssize_t current_pos = 0;
+  Py_ssize_t j = 0;
+  for (i = 0; i < len; i++) {
+    expr_ty elem = asdl_seq_GET(strings, i);
+    switch (elem->kind) {
+    case JoinedStr_kind:
+      for (j = 0; j < asdl_seq_LEN(elem->v.JoinedStr.values); j++) {
+        expr_ty subvalue = asdl_seq_GET(elem->v.JoinedStr.values, j);
+        if (subvalue == NULL) {
+          return NULL;
+        }
+        asdl_seq_SET(flattened, current_pos++, subvalue);
+      }
+      break;
+    default:
+      asdl_seq_SET(flattened, current_pos++, elem);
+      break;
+    }
+  }
+
+  /* calculate folded element count */
+  Py_ssize_t n_elements = 0;
+  int prev_is_constant = 0;
+  for (i = 0; i < n_flattened_elements; i++) {
+    expr_ty elem = asdl_seq_GET(flattened, i);
+
+    /* The concatenation of a FormattedValue and an empty Contant should
+       lead to the FormattedValue itself. Thus, we will not take any empty
+       constants into account, just as in `_PyPegen_joined_str` */
+    if (f_string_found && elem->kind == Constant_kind &&
+        PyUnicode_CheckExact(elem->v.Constant.value) &&
+        PyUnicode_GET_LENGTH(elem->v.Constant.value) == 0)
+      continue;
+
+    if (!prev_is_constant || elem->kind != Constant_kind) {
+      n_elements++;
+    }
+    prev_is_constant = elem->kind == Constant_kind;
+  }
+
+  asdl_expr_seq *values = _Py_asdl_expr_seq_new(n_elements, p->arena);
+  if (values == NULL) {
+    return NULL;
+  }
+
+  /* build folded list */
+  _PyUnicodeWriter writer;
+  current_pos = 0;
+  for (i = 0; i < n_flattened_elements; i++) {
+    expr_ty elem = asdl_seq_GET(flattened, i);
+
+    /* if the current elem and the following are constants,
+       fold them and all consequent constants */
+    if (elem->kind == Constant_kind) {
+      if (i + 1 < n_flattened_elements &&
+          asdl_seq_GET(flattened, i + 1)->kind == Constant_kind) {
+        expr_ty first_elem = elem;
+
+        /* When a string is getting concatenated, the kind of the string
+           is determined by the first string in the concatenation
+           sequence.
+
+           u"abc" "def" -> u"abcdef"
+           "abc" u"abc" ->  "abcabc" */
+        PyObject *kind = elem->v.Constant.kind;
+
+        _PyUnicodeWriter_Init(&writer);
+        expr_ty last_elem = elem;
+        for (j = i; j < n_flattened_elements; j++) {
+          expr_ty current_elem = asdl_seq_GET(flattened, j);
+          if (current_elem->kind == Constant_kind) {
+            if (_PyUnicodeWriter_WriteStr(&writer,
+                                          current_elem->v.Constant.value)) {
+              _PyUnicodeWriter_Dealloc(&writer);
+              return NULL;
             }
-            n_flattened_elements++;
-        } else {
-            n_flattened_elements += asdl_seq_LEN(elem->v.JoinedStr.values);
-            f_string_found = 1;
+            last_elem = current_elem;
+          } else {
+            break;
+          }
         }
-    }
-
-    if ((unicode_string_found || f_string_found) && bytes_found) {
-        RAISE_SYNTAX_ERROR("cannot mix bytes and nonbytes literals");
-        return NULL;
-    }
+        i = j - 1;
 
-    if (bytes_found) {
-        PyObject* res = PyBytes_FromString("");
-
-        /* Bytes literals never get a kind, but just for consistency
-           since they are represented as Constant nodes, we'll mirror
-           the same behavior as unicode strings for determining the
-           kind. */
-        PyObject* kind = asdl_seq_GET(strings, 0)->v.Constant.kind;
-        for (i = 0; i < len; i++) {
-            expr_ty elem = asdl_seq_GET(strings, i);
-            PyBytes_Concat(&res, elem->v.Constant.value);
+        PyObject *concat_str = _PyUnicodeWriter_Finish(&writer);
+        if (concat_str == NULL) {
+          _PyUnicodeWriter_Dealloc(&writer);
+          return NULL;
         }
-        if (!res || _PyArena_AddPyObject(arena, res) < 0) {
-            Py_XDECREF(res);
-            return NULL;
+        if (_PyArena_AddPyObject(p->arena, concat_str) < 0) {
+          Py_DECREF(concat_str);
+          return NULL;
         }
-        return _PyAST_Constant(res, kind, lineno, col_offset, end_lineno, end_col_offset, p->arena);
-    }
-
-    if (!f_string_found && len == 1) {
-        return asdl_seq_GET(strings, 0);
-    }
-
-    asdl_expr_seq* flattened = _Py_asdl_expr_seq_new(n_flattened_elements, p->arena);
-    if (flattened == NULL) {
-        return NULL;
-    }
-
-    /* build flattened list */
-    Py_ssize_t current_pos = 0;
-    Py_ssize_t j = 0;
-    for (i = 0; i < len; i++) {
-        expr_ty elem = asdl_seq_GET(strings, i);
-        if (elem->kind == Constant_kind) {
-            asdl_seq_SET(flattened, current_pos++, elem);
-        } else {
-            for (j = 0; j < asdl_seq_LEN(elem->v.JoinedStr.values); j++) {
-                expr_ty subvalue = asdl_seq_GET(elem->v.JoinedStr.values, j);
-                if (subvalue == NULL) {
-                    return NULL;
-                }
-                asdl_seq_SET(flattened, current_pos++, subvalue);
-            }
+        elem = _PyAST_Constant(concat_str, kind, first_elem->lineno,
+                               first_elem->col_offset, last_elem->end_lineno,
+                               last_elem->end_col_offset, p->arena);
+        if (elem == NULL) {
+          return NULL;
         }
-    }
-
-    /* calculate folded element count */
-    Py_ssize_t n_elements = 0;
-    int prev_is_constant = 0;
-    for (i = 0; i < n_flattened_elements; i++) {
-        expr_ty elem = asdl_seq_GET(flattened, i);
-
-        /* The concatenation of a FormattedValue and an empty Contant should
-           lead to the FormattedValue itself. Thus, we will not take any empty
-           constants into account, just as in `_PyPegen_joined_str` */
-        if (f_string_found && elem->kind == Constant_kind &&
-            PyUnicode_CheckExact(elem->v.Constant.value) &&
-            PyUnicode_GET_LENGTH(elem->v.Constant.value) == 0)
-            continue;
-
-        if (!prev_is_constant || elem->kind != Constant_kind) {
-            n_elements++;
-        }
-        prev_is_constant = elem->kind == Constant_kind;
-    }
+      }
 
-    asdl_expr_seq* values = _Py_asdl_expr_seq_new(n_elements, p->arena);
-    if (values == NULL) {
-        return NULL;
+      /* Drop all empty contanst strings */
+      if (f_string_found && PyUnicode_CheckExact(elem->v.Constant.value) &&
+          PyUnicode_GET_LENGTH(elem->v.Constant.value) == 0) {
+        continue;
+      }
     }
 
-    /* build folded list */
-    _PyUnicodeWriter writer;
-    current_pos = 0;
-    for (i = 0; i < n_flattened_elements; i++) {
-        expr_ty elem = asdl_seq_GET(flattened, i);
-
-        /* if the current elem and the following are constants,
-           fold them and all consequent constants */
-        if (elem->kind == Constant_kind) {
-            if (i + 1 < n_flattened_elements &&
-                asdl_seq_GET(flattened, i + 1)->kind == Constant_kind) {
-                expr_ty first_elem = elem;
-
-                /* When a string is getting concatenated, the kind of the string
-                   is determined by the first string in the concatenation
-                   sequence.
-
-                   u"abc" "def" -> u"abcdef"
-                   "abc" u"abc" ->  "abcabc" */
-                PyObject *kind = elem->v.Constant.kind;
-
-                _PyUnicodeWriter_Init(&writer);
-                expr_ty last_elem = elem;
-                for (j = i; j < n_flattened_elements; j++) {
-                    expr_ty current_elem = asdl_seq_GET(flattened, j);
-                    if (current_elem->kind == Constant_kind) {
-                        if (_PyUnicodeWriter_WriteStr(
-                                &writer, current_elem->v.Constant.value)) {
-                            _PyUnicodeWriter_Dealloc(&writer);
-                            return NULL;
-                        }
-                        last_elem = current_elem;
-                    } else {
-                        break;
-                    }
-                }
-                i = j - 1;
-
-                PyObject *concat_str = _PyUnicodeWriter_Finish(&writer);
-                if (concat_str == NULL) {
-                    _PyUnicodeWriter_Dealloc(&writer);
-                    return NULL;
-                }
-                if (_PyArena_AddPyObject(p->arena, concat_str) < 0) {
-                    Py_DECREF(concat_str);
-                    return NULL;
-                }
-                elem = _PyAST_Constant(concat_str, kind, first_elem->lineno,
-                                       first_elem->col_offset,
-                                       last_elem->end_lineno,
-                                       last_elem->end_col_offset, p->arena);
-                if (elem == NULL) {
-                    return NULL;
-                }
-            }
-
-            /* Drop all empty contanst strings */
-            if (f_string_found &&
-                PyUnicode_CheckExact(elem->v.Constant.value) &&
-                PyUnicode_GET_LENGTH(elem->v.Constant.value) == 0) {
-                continue;
-            }
-        }
-
-        asdl_seq_SET(values, current_pos++, elem);
-    }
+    asdl_seq_SET(values, current_pos++, elem);
+  }
 
-    if (!f_string_found) {
-        assert(n_elements == 1);
-        expr_ty elem = asdl_seq_GET(values, 0);
-        assert(elem->kind == Constant_kind);
-        return elem;
-    }
+  if (!f_string_found) {
+    assert(n_elements == 1);
+    expr_ty elem = asdl_seq_GET(values, 0);
+    assert(elem->kind == Constant_kind);
+    return elem;
+  }
 
-    assert(current_pos == n_elements);
-    return _PyAST_JoinedStr(values, lineno, col_offset, end_lineno, end_col_offset, p->arena);
+  assert(current_pos == n_elements);
+  return _PyAST_JoinedStr(values, lineno, col_offset, end_lineno,
+                          end_col_offset, p->arena);
 }
diff --git a/contrib/tools/python3/Parser/pegen.c b/contrib/tools/python3/Parser/pegen.c
index 5460fbb2ff..8c36c6779b 100644
--- a/contrib/tools/python3/Parser/pegen.c
+++ b/contrib/tools/python3/Parser/pegen.c
@@ -394,7 +394,7 @@ _PyPegen_is_memoized(Parser *p, int type, void *pres)
 
     for (Memo *m = t->memo; m != NULL; m = m->next) {
         if (m->type == type) {
-#if defined(PY_DEBUG)
+#if defined(Py_DEBUG)
             if (0 <= type && type < NSTATISTICS) {
                 long count = m->mark - p->mark;
                 // A memoized negative result counts for one.
diff --git a/contrib/tools/python3/Parser/string_parser.c b/contrib/tools/python3/Parser/string_parser.c
index 65c320c217..164f715e15 100644
--- a/contrib/tools/python3/Parser/string_parser.c
+++ b/contrib/tools/python3/Parser/string_parser.c
@@ -226,9 +226,14 @@ _PyPegen_parse_string(Parser *p, Token *t)
         PyErr_BadInternalCall();
         return NULL;
     }
+
     /* Skip the leading quote char. */
     s++;
     len = strlen(s);
+    // gh-120155: 's' contains at least the trailing quote,
+    // so the code '--len' below is safe.
+    assert(len >= 1);
+
     if (len > INT_MAX) {
         PyErr_SetString(PyExc_OverflowError, "string to parse is too long");
         return NULL;
diff --git a/contrib/tools/python3/Parser/tokenizer.c b/contrib/tools/python3/Parser/tokenizer.c
index 27d49c6f89..f3b2bbde74 100644
--- a/contrib/tools/python3/Parser/tokenizer.c
+++ b/contrib/tools/python3/Parser/tokenizer.c
@@ -3,53 +3,48 @@
 
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
-#include "pycore_call.h"          // _PyObject_CallNoArgs()
+#include "pycore_call.h" // _PyObject_CallNoArgs()
 
-#include <ctype.h>
 #include <assert.h>
+#include <ctype.h>
 
-#include "tokenizer.h"
 #include "errcode.h"
+#include "tokenizer.h"
 
 /* Alternate tab spacing */
 #define ALTTABSIZE 1
 
-#define is_potential_identifier_start(c) (\
-              (c >= 'a' && c <= 'z')\
-               || (c >= 'A' && c <= 'Z')\
-               || c == '_'\
-               || (c >= 128))
-
-#define is_potential_identifier_char(c) (\
-              (c >= 'a' && c <= 'z')\
-               || (c >= 'A' && c <= 'Z')\
-               || (c >= '0' && c <= '9')\
-               || c == '_'\
-               || (c >= 128))
+#define is_potential_identifier_start(c)                                       \
+  ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || (c >= 128))
 
+#define is_potential_identifier_char(c)                                        \
+  ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||                         \
+   (c >= '0' && c <= '9') || c == '_' || (c >= 128))
 
 /* Don't ever change this -- it would break the portability of Python code */
 #define TABSIZE 8
 
-#define MAKE_TOKEN(token_type) token_setup(tok, token, token_type, p_start, p_end)
-#define MAKE_TYPE_COMMENT_TOKEN(token_type, col_offset, end_col_offset) (\
-                type_comment_token_setup(tok, token, token_type, col_offset, end_col_offset, p_start, p_end))
-#define ADVANCE_LINENO() \
-            tok->lineno++; \
-            tok->col_offset = 0;
+#define MAKE_TOKEN(token_type)                                                 \
+  token_setup(tok, token, token_type, p_start, p_end)
+#define MAKE_TYPE_COMMENT_TOKEN(token_type, col_offset, end_col_offset)        \
+  (type_comment_token_setup(tok, token, token_type, col_offset,                \
+                            end_col_offset, p_start, p_end))
+#define ADVANCE_LINENO()                                                       \
+  tok->lineno++;                                                               \
+  tok->col_offset = 0;
 
 #define INSIDE_FSTRING(tok) (tok->tok_mode_stack_index > 0)
 #define INSIDE_FSTRING_EXPR(tok) (tok->curly_bracket_expr_start_depth >= 0)
 #ifdef Py_DEBUG
-static inline tokenizer_mode* TOK_GET_MODE(struct tok_state* tok) {
-    assert(tok->tok_mode_stack_index >= 0);
-    assert(tok->tok_mode_stack_index < MAXFSTRINGLEVEL);
-    return &(tok->tok_mode_stack[tok->tok_mode_stack_index]);
+static inline tokenizer_mode *TOK_GET_MODE(struct tok_state *tok) {
+  assert(tok->tok_mode_stack_index >= 0);
+  assert(tok->tok_mode_stack_index < MAXFSTRINGLEVEL);
+  return &(tok->tok_mode_stack[tok->tok_mode_stack_index]);
 }
-static inline tokenizer_mode* TOK_NEXT_MODE(struct tok_state* tok) {
-    assert(tok->tok_mode_stack_index >= 0);
-    assert(tok->tok_mode_stack_index + 1 < MAXFSTRINGLEVEL);
-    return &(tok->tok_mode_stack[++tok->tok_mode_stack_index]);
+static inline tokenizer_mode *TOK_NEXT_MODE(struct tok_state *tok) {
+  assert(tok->tok_mode_stack_index >= 0);
+  assert(tok->tok_mode_stack_index + 1 < MAXFSTRINGLEVEL);
+  return &(tok->tok_mode_stack[++tok->tok_mode_stack_index]);
 }
 #else
 #define TOK_GET_MODE(tok) (&(tok->tok_mode_stack[tok->tok_mode_stack_index]))
@@ -64,171 +59,164 @@ static int syntaxerror(struct tok_state *tok, const char *format, ...);
 
 /* Spaces in this constant are treated as "zero or more spaces or tabs" when
    tokenizing. */
-static const char* type_comment_prefix = "# type: ";
+static const char *type_comment_prefix = "# type: ";
 
 /* Create and initialize a new tok_state structure */
 
-static struct tok_state *
-tok_new(void)
-{
-    struct tok_state *tok = (struct tok_state *)PyMem_Malloc(
-                                            sizeof(struct tok_state));
-    if (tok == NULL)
-        return NULL;
-    tok->buf = tok->cur = tok->inp = NULL;
-    tok->fp_interactive = 0;
-    tok->interactive_src_start = NULL;
-    tok->interactive_src_end = NULL;
-    tok->start = NULL;
-    tok->end = NULL;
-    tok->done = E_OK;
-    tok->fp = NULL;
-    tok->input = NULL;
-    tok->tabsize = TABSIZE;
-    tok->indent = 0;
-    tok->indstack[0] = 0;
-    tok->atbol = 1;
-    tok->pendin = 0;
-    tok->prompt = tok->nextprompt = NULL;
-    tok->lineno = 0;
-    tok->starting_col_offset = -1;
-    tok->col_offset = -1;
-    tok->level = 0;
-    tok->altindstack[0] = 0;
-    tok->decoding_state = STATE_INIT;
-    tok->decoding_erred = 0;
-    tok->enc = NULL;
-    tok->encoding = NULL;
-    tok->cont_line = 0;
-    tok->filename = NULL;
-    tok->decoding_readline = NULL;
-    tok->decoding_buffer = NULL;
-    tok->readline = NULL;
-    tok->type_comments = 0;
-    tok->async_hacks = 0;
-    tok->async_def = 0;
-    tok->async_def_indent = 0;
-    tok->async_def_nl = 0;
-    tok->interactive_underflow = IUNDERFLOW_NORMAL;
-    tok->str = NULL;
-    tok->report_warnings = 1;
-    tok->tok_extra_tokens = 0;
-    tok->comment_newline = 0;
-    tok->implicit_newline = 0;
-    tok->tok_mode_stack[0] = (tokenizer_mode){.kind =TOK_REGULAR_MODE, .f_string_quote='\0', .f_string_quote_size = 0, .f_string_debug=0};
-    tok->tok_mode_stack_index = 0;
+static struct tok_state *tok_new(void) {
+  struct tok_state *tok =
+      (struct tok_state *)PyMem_Malloc(sizeof(struct tok_state));
+  if (tok == NULL)
+    return NULL;
+  tok->buf = tok->cur = tok->inp = NULL;
+  tok->fp_interactive = 0;
+  tok->interactive_src_start = NULL;
+  tok->interactive_src_end = NULL;
+  tok->start = NULL;
+  tok->end = NULL;
+  tok->done = E_OK;
+  tok->fp = NULL;
+  tok->input = NULL;
+  tok->tabsize = TABSIZE;
+  tok->indent = 0;
+  tok->indstack[0] = 0;
+  tok->atbol = 1;
+  tok->pendin = 0;
+  tok->prompt = tok->nextprompt = NULL;
+  tok->lineno = 0;
+  tok->starting_col_offset = -1;
+  tok->col_offset = -1;
+  tok->level = 0;
+  tok->altindstack[0] = 0;
+  tok->decoding_state = STATE_INIT;
+  tok->decoding_erred = 0;
+  tok->enc = NULL;
+  tok->encoding = NULL;
+  tok->cont_line = 0;
+  tok->filename = NULL;
+  tok->decoding_readline = NULL;
+  tok->decoding_buffer = NULL;
+  tok->readline = NULL;
+  tok->type_comments = 0;
+  tok->async_hacks = 0;
+  tok->async_def = 0;
+  tok->async_def_indent = 0;
+  tok->async_def_nl = 0;
+  tok->interactive_underflow = IUNDERFLOW_NORMAL;
+  tok->str = NULL;
+  tok->report_warnings = 1;
+  tok->tok_extra_tokens = 0;
+  tok->comment_newline = 0;
+  tok->implicit_newline = 0;
+  tok->tok_mode_stack[0] = (tokenizer_mode){.kind = TOK_REGULAR_MODE,
+                                            .f_string_quote = '\0',
+                                            .f_string_quote_size = 0,
+                                            .f_string_debug = 0};
+  tok->tok_mode_stack_index = 0;
 #ifdef Py_DEBUG
-    tok->debug = _Py_GetConfig()->parser_debug;
+  tok->debug = _Py_GetConfig()->parser_debug;
 #endif
-    return tok;
+  return tok;
 }
 
-static char *
-new_string(const char *s, Py_ssize_t len, struct tok_state *tok)
-{
-    char* result = (char *)PyMem_Malloc(len + 1);
-    if (!result) {
-        tok->done = E_NOMEM;
-        return NULL;
-    }
-    memcpy(result, s, len);
-    result[len] = '\0';
-    return result;
+static char *new_string(const char *s, Py_ssize_t len, struct tok_state *tok) {
+  char *result = (char *)PyMem_Malloc(len + 1);
+  if (!result) {
+    tok->done = E_NOMEM;
+    return NULL;
+  }
+  memcpy(result, s, len);
+  result[len] = '\0';
+  return result;
 }
 
-static char *
-error_ret(struct tok_state *tok) /* XXX */
+static char *error_ret(struct tok_state *tok) /* XXX */
 {
-    tok->decoding_erred = 1;
-    if ((tok->fp != NULL || tok->readline != NULL) && tok->buf != NULL) {/* see _PyTokenizer_Free */
-        PyMem_Free(tok->buf);
-    }
-    tok->buf = tok->cur = tok->inp = NULL;
-    tok->start = NULL;
-    tok->end = NULL;
-    tok->done = E_DECODE;
-    return NULL;                /* as if it were EOF */
-}
-
-
-static const char *
-get_normal_name(const char *s)  /* for utf-8 and latin-1 */
+  tok->decoding_erred = 1;
+  if ((tok->fp != NULL || tok->readline != NULL) &&
+      tok->buf != NULL) { /* see _PyTokenizer_Free */
+    PyMem_Free(tok->buf);
+  }
+  tok->buf = tok->cur = tok->inp = NULL;
+  tok->start = NULL;
+  tok->end = NULL;
+  tok->done = E_DECODE;
+  return NULL; /* as if it were EOF */
+}
+
+static const char *get_normal_name(const char *s) /* for utf-8 and latin-1 */
 {
-    char buf[13];
-    int i;
-    for (i = 0; i < 12; i++) {
-        int c = s[i];
-        if (c == '\0')
-            break;
-        else if (c == '_')
-            buf[i] = '-';
-        else
-            buf[i] = tolower(c);
-    }
-    buf[i] = '\0';
-    if (strcmp(buf, "utf-8") == 0 ||
-        strncmp(buf, "utf-8-", 6) == 0)
-        return "utf-8";
-    else if (strcmp(buf, "latin-1") == 0 ||
-             strcmp(buf, "iso-8859-1") == 0 ||
-             strcmp(buf, "iso-latin-1") == 0 ||
-             strncmp(buf, "latin-1-", 8) == 0 ||
-             strncmp(buf, "iso-8859-1-", 11) == 0 ||
-             strncmp(buf, "iso-latin-1-", 12) == 0)
-        return "iso-8859-1";
+  char buf[13];
+  int i;
+  for (i = 0; i < 12; i++) {
+    int c = s[i];
+    if (c == '\0')
+      break;
+    else if (c == '_')
+      buf[i] = '-';
     else
-        return s;
+      buf[i] = tolower(c);
+  }
+  buf[i] = '\0';
+  if (strcmp(buf, "utf-8") == 0 || strncmp(buf, "utf-8-", 6) == 0)
+    return "utf-8";
+  else if (strcmp(buf, "latin-1") == 0 || strcmp(buf, "iso-8859-1") == 0 ||
+           strcmp(buf, "iso-latin-1") == 0 ||
+           strncmp(buf, "latin-1-", 8) == 0 ||
+           strncmp(buf, "iso-8859-1-", 11) == 0 ||
+           strncmp(buf, "iso-latin-1-", 12) == 0)
+    return "iso-8859-1";
+  else
+    return s;
 }
 
 /* Return the coding spec in S, or NULL if none is found.  */
 
-static int
-get_coding_spec(const char *s, char **spec, Py_ssize_t size, struct tok_state *tok)
-{
-    Py_ssize_t i;
-    *spec = NULL;
-    /* Coding spec must be in a comment, and that comment must be
-     * the only statement on the source code line. */
-    for (i = 0; i < size - 6; i++) {
-        if (s[i] == '#')
-            break;
-        if (s[i] != ' ' && s[i] != '\t' && s[i] != '\014')
-            return 1;
-    }
-    for (; i < size - 6; i++) { /* XXX inefficient search */
-        const char* t = s + i;
-        if (memcmp(t, "coding", 6) == 0) {
-            const char* begin = NULL;
-            t += 6;
-            if (t[0] != ':' && t[0] != '=')
-                continue;
-            do {
-                t++;
-            } while (t[0] == ' ' || t[0] == '\t');
-
-            begin = t;
-            while (Py_ISALNUM(t[0]) ||
-                   t[0] == '-' || t[0] == '_' || t[0] == '.')
-                t++;
-
-            if (begin < t) {
-                char* r = new_string(begin, t - begin, tok);
-                const char* q;
-                if (!r)
-                    return 0;
-                q = get_normal_name(r);
-                if (r != q) {
-                    PyMem_Free(r);
-                    r = new_string(q, strlen(q), tok);
-                    if (!r)
-                        return 0;
-                }
-                *spec = r;
-                break;
-            }
+static int get_coding_spec(const char *s, char **spec, Py_ssize_t size,
+                           struct tok_state *tok) {
+  Py_ssize_t i;
+  *spec = NULL;
+  /* Coding spec must be in a comment, and that comment must be
+   * the only statement on the source code line. */
+  for (i = 0; i < size - 6; i++) {
+    if (s[i] == '#')
+      break;
+    if (s[i] != ' ' && s[i] != '\t' && s[i] != '\014')
+      return 1;
+  }
+  for (; i < size - 6; i++) { /* XXX inefficient search */
+    const char *t = s + i;
+    if (memcmp(t, "coding", 6) == 0) {
+      const char *begin = NULL;
+      t += 6;
+      if (t[0] != ':' && t[0] != '=')
+        continue;
+      do {
+        t++;
+      } while (t[0] == ' ' || t[0] == '\t');
+
+      begin = t;
+      while (Py_ISALNUM(t[0]) || t[0] == '-' || t[0] == '_' || t[0] == '.')
+        t++;
+
+      if (begin < t) {
+        char *r = new_string(begin, t - begin, tok);
+        const char *q;
+        if (!r)
+          return 0;
+        q = get_normal_name(r);
+        if (r != q) {
+          PyMem_Free(r);
+          r = new_string(q, strlen(q), tok);
+          if (!r)
+            return 0;
         }
+        *spec = r;
+        break;
+      }
     }
-    return 1;
+  }
+  return 1;
 }
 
 /* Check whether the line contains a coding spec. If it does,
@@ -237,299 +225,288 @@ get_coding_spec(const char *s, char **spec, Py_ssize_t size, struct tok_state *t
    Return 1 on success, 0 on failure.  */
 
 static int
-check_coding_spec(const char* line, Py_ssize_t size, struct tok_state *tok,
-                  int set_readline(struct tok_state *, const char *))
-{
-    char *cs;
-    if (tok->cont_line) {
-        /* It's a continuation line, so it can't be a coding spec. */
-        tok->decoding_state = STATE_NORMAL;
-        return 1;
-    }
-    if (!get_coding_spec(line, &cs, size, tok)) {
-        return 0;
-    }
-    if (!cs) {
-        Py_ssize_t i;
-        for (i = 0; i < size; i++) {
-            if (line[i] == '#' || line[i] == '\n' || line[i] == '\r')
-                break;
-            if (line[i] != ' ' && line[i] != '\t' && line[i] != '\014') {
-                /* Stop checking coding spec after a line containing
-                 * anything except a comment. */
-                tok->decoding_state = STATE_NORMAL;
-                break;
-            }
-        }
-        return 1;
-    }
+check_coding_spec(const char *line, Py_ssize_t size, struct tok_state *tok,
+                  int set_readline(struct tok_state *, const char *)) {
+  char *cs;
+  if (tok->cont_line) {
+    /* It's a continuation line, so it can't be a coding spec. */
     tok->decoding_state = STATE_NORMAL;
-    if (tok->encoding == NULL) {
-        assert(tok->decoding_readline == NULL);
-        if (strcmp(cs, "utf-8") != 0 && !set_readline(tok, cs)) {
-            error_ret(tok);
-            PyErr_Format(PyExc_SyntaxError, "encoding problem: %s", cs);
-            PyMem_Free(cs);
-            return 0;
-        }
-        tok->encoding = cs;
-    } else {                /* then, compare cs with BOM */
-        if (strcmp(tok->encoding, cs) != 0) {
-            error_ret(tok);
-            PyErr_Format(PyExc_SyntaxError,
-                         "encoding problem: %s with BOM", cs);
-            PyMem_Free(cs);
-            return 0;
-        }
-        PyMem_Free(cs);
+    return 1;
+  }
+  if (!get_coding_spec(line, &cs, size, tok)) {
+    return 0;
+  }
+  if (!cs) {
+    Py_ssize_t i;
+    for (i = 0; i < size; i++) {
+      if (line[i] == '#' || line[i] == '\n' || line[i] == '\r')
+        break;
+      if (line[i] != ' ' && line[i] != '\t' && line[i] != '\014') {
+        /* Stop checking coding spec after a line containing
+         * anything except a comment. */
+        tok->decoding_state = STATE_NORMAL;
+        break;
+      }
     }
     return 1;
+  }
+  tok->decoding_state = STATE_NORMAL;
+  if (tok->encoding == NULL) {
+    assert(tok->decoding_readline == NULL);
+    if (strcmp(cs, "utf-8") != 0 && !set_readline(tok, cs)) {
+      error_ret(tok);
+      PyErr_Format(PyExc_SyntaxError, "encoding problem: %s", cs);
+      PyMem_Free(cs);
+      return 0;
+    }
+    tok->encoding = cs;
+  } else { /* then, compare cs with BOM */
+    if (strcmp(tok->encoding, cs) != 0) {
+      error_ret(tok);
+      PyErr_Format(PyExc_SyntaxError, "encoding problem: %s with BOM", cs);
+      PyMem_Free(cs);
+      return 0;
+    }
+    PyMem_Free(cs);
+  }
+  return 1;
 }
 
 /* See whether the file starts with a BOM. If it does,
    invoke the set_readline function with the new encoding.
    Return 1 on success, 0 on failure.  */
 
-static int
-check_bom(int get_char(struct tok_state *),
-          void unget_char(int, struct tok_state *),
-          int set_readline(struct tok_state *, const char *),
-          struct tok_state *tok)
-{
-    int ch1, ch2, ch3;
-    ch1 = get_char(tok);
-    tok->decoding_state = STATE_SEEK_CODING;
-    if (ch1 == EOF) {
-        return 1;
-    } else if (ch1 == 0xEF) {
-        ch2 = get_char(tok);
-        if (ch2 != 0xBB) {
-            unget_char(ch2, tok);
-            unget_char(ch1, tok);
-            return 1;
-        }
-        ch3 = get_char(tok);
-        if (ch3 != 0xBF) {
-            unget_char(ch3, tok);
-            unget_char(ch2, tok);
-            unget_char(ch1, tok);
-            return 1;
-        }
-    } else {
-        unget_char(ch1, tok);
-        return 1;
-    }
-    if (tok->encoding != NULL)
-        PyMem_Free(tok->encoding);
-    tok->encoding = new_string("utf-8", 5, tok);
-    if (!tok->encoding)
-        return 0;
-    /* No need to set_readline: input is already utf-8 */
+static int check_bom(int get_char(struct tok_state *),
+                     void unget_char(int, struct tok_state *),
+                     int set_readline(struct tok_state *, const char *),
+                     struct tok_state *tok) {
+  int ch1, ch2, ch3;
+  ch1 = get_char(tok);
+  tok->decoding_state = STATE_SEEK_CODING;
+  if (ch1 == EOF) {
     return 1;
+  } else if (ch1 == 0xEF) {
+    ch2 = get_char(tok);
+    if (ch2 != 0xBB) {
+      unget_char(ch2, tok);
+      unget_char(ch1, tok);
+      return 1;
+    }
+    ch3 = get_char(tok);
+    if (ch3 != 0xBF) {
+      unget_char(ch3, tok);
+      unget_char(ch2, tok);
+      unget_char(ch1, tok);
+      return 1;
+    }
+  } else {
+    unget_char(ch1, tok);
+    return 1;
+  }
+  if (tok->encoding != NULL)
+    PyMem_Free(tok->encoding);
+  tok->encoding = new_string("utf-8", 5, tok);
+  if (!tok->encoding)
+    return 0;
+  /* No need to set_readline: input is already utf-8 */
+  return 1;
 }
 
-static int
-tok_concatenate_interactive_new_line(struct tok_state *tok, const char *line) {
-    assert(tok->fp_interactive);
-
-    if (!line) {
-        return 0;
-    }
-
-    Py_ssize_t current_size = tok->interactive_src_end - tok->interactive_src_start;
-    Py_ssize_t line_size = strlen(line);
-    char last_char = line[line_size > 0 ? line_size - 1 : line_size];
-    if (last_char != '\n') {
-        line_size += 1;
-    }
-    char* new_str = tok->interactive_src_start;
+static int tok_concatenate_interactive_new_line(struct tok_state *tok,
+                                                const char *line) {
+  assert(tok->fp_interactive);
 
-    new_str = PyMem_Realloc(new_str, current_size + line_size + 1);
-    if (!new_str) {
-        if (tok->interactive_src_start) {
-            PyMem_Free(tok->interactive_src_start);
-        }
-        tok->interactive_src_start = NULL;
-        tok->interactive_src_end = NULL;
-        tok->done = E_NOMEM;
-        return -1;
-    }
-    strcpy(new_str + current_size, line);
-    tok->implicit_newline = 0;
-    if (last_char != '\n') {
-        /* Last line does not end in \n, fake one */
-        new_str[current_size + line_size - 1] = '\n';
-        new_str[current_size + line_size] = '\0';
-        tok->implicit_newline = 1;
-    }
-    tok->interactive_src_start = new_str;
-    tok->interactive_src_end = new_str + current_size + line_size;
+  if (!line) {
     return 0;
+  }
+
+  Py_ssize_t current_size =
+      tok->interactive_src_end - tok->interactive_src_start;
+  Py_ssize_t line_size = strlen(line);
+  char last_char = line[line_size > 0 ? line_size - 1 : line_size];
+  if (last_char != '\n') {
+    line_size += 1;
+  }
+  char *new_str = tok->interactive_src_start;
+
+  new_str = PyMem_Realloc(new_str, current_size + line_size + 1);
+  if (!new_str) {
+    if (tok->interactive_src_start) {
+      PyMem_Free(tok->interactive_src_start);
+    }
+    tok->interactive_src_start = NULL;
+    tok->interactive_src_end = NULL;
+    tok->done = E_NOMEM;
+    return -1;
+  }
+  strcpy(new_str + current_size, line);
+  tok->implicit_newline = 0;
+  if (last_char != '\n') {
+    /* Last line does not end in \n, fake one */
+    new_str[current_size + line_size - 1] = '\n';
+    new_str[current_size + line_size] = '\0';
+    tok->implicit_newline = 1;
+  }
+  tok->interactive_src_start = new_str;
+  tok->interactive_src_end = new_str + current_size + line_size;
+  return 0;
 }
 
 /* Traverse and remember all f-string buffers, in order to be able to restore
    them after reallocating tok->buf */
-static void
-remember_fstring_buffers(struct tok_state *tok)
-{
-    int index;
-    tokenizer_mode *mode;
+static void remember_fstring_buffers(struct tok_state *tok) {
+  int index;
+  tokenizer_mode *mode;
 
-    for (index = tok->tok_mode_stack_index; index >= 0; --index) {
-        mode = &(tok->tok_mode_stack[index]);
-        mode->f_string_start_offset = mode->f_string_start - tok->buf;
-        mode->f_string_multi_line_start_offset = mode->f_string_multi_line_start - tok->buf;
-    }
+  for (index = tok->tok_mode_stack_index; index >= 0; --index) {
+    mode = &(tok->tok_mode_stack[index]);
+    mode->f_string_start_offset = mode->f_string_start - tok->buf;
+    mode->f_string_multi_line_start_offset =
+        mode->f_string_multi_line_start - tok->buf;
+  }
 }
 
 /* Traverse and restore all f-string buffers after reallocating tok->buf */
-static void
-restore_fstring_buffers(struct tok_state *tok)
-{
-    int index;
-    tokenizer_mode *mode;
+static void restore_fstring_buffers(struct tok_state *tok) {
+  int index;
+  tokenizer_mode *mode;
 
-    for (index = tok->tok_mode_stack_index; index >= 0; --index) {
-        mode = &(tok->tok_mode_stack[index]);
-        mode->f_string_start = tok->buf + mode->f_string_start_offset;
-        mode->f_string_multi_line_start = tok->buf + mode->f_string_multi_line_start_offset;
-    }
+  for (index = tok->tok_mode_stack_index; index >= 0; --index) {
+    mode = &(tok->tok_mode_stack[index]);
+    mode->f_string_start = tok->buf + mode->f_string_start_offset;
+    mode->f_string_multi_line_start =
+        tok->buf + mode->f_string_multi_line_start_offset;
+  }
 }
 
-static int
-set_fstring_expr(struct tok_state* tok, struct token *token, char c) {
-    assert(token != NULL);
-    assert(c == '}' || c == ':' || c == '!');
-    tokenizer_mode *tok_mode = TOK_GET_MODE(tok);
+static int set_fstring_expr(struct tok_state *tok, struct token *token,
+                            char c) {
+  assert(token != NULL);
+  assert(c == '}' || c == ':' || c == '!');
+  tokenizer_mode *tok_mode = TOK_GET_MODE(tok);
 
-    if (!tok_mode->f_string_debug || token->metadata) {
-        return 0;
-    }
+  if (!tok_mode->f_string_debug || token->metadata) {
+    return 0;
+  }
 
-    PyObject *res = NULL;
+  PyObject *res = NULL;
 
-    // Check if there is a # character in the expression
-    int hash_detected = 0;
-    for (Py_ssize_t i = 0; i < tok_mode->last_expr_size - tok_mode->last_expr_end; i++) {
-        if (tok_mode->last_expr_buffer[i] == '#') {
-            hash_detected = 1;
-            break;
-        }
+  // Check if there is a # character in the expression
+  int hash_detected = 0;
+  for (Py_ssize_t i = 0; i < tok_mode->last_expr_size - tok_mode->last_expr_end;
+       i++) {
+    if (tok_mode->last_expr_buffer[i] == '#') {
+      hash_detected = 1;
+      break;
     }
+  }
 
-    if (hash_detected) {
-        Py_ssize_t input_length = tok_mode->last_expr_size - tok_mode->last_expr_end;
-        char *result = (char *)PyObject_Malloc((input_length + 1) * sizeof(char));
-        if (!result) {
-            return -1;
-        }
-
-        Py_ssize_t i = 0;
-        Py_ssize_t j = 0;
-
-        for (i = 0, j = 0; i < input_length; i++) {
-            if (tok_mode->last_expr_buffer[i] == '#') {
-                // Skip characters until newline or end of string
-                while (tok_mode->last_expr_buffer[i] != '\0' && i < input_length) {
-                    if (tok_mode->last_expr_buffer[i] == '\n') {
-                        result[j++] = tok_mode->last_expr_buffer[i];
-                        break;
-                    }
-                    i++;
-                }
-            } else {
-                result[j++] = tok_mode->last_expr_buffer[i];
-            }
-        }
-
-        result[j] = '\0';  // Null-terminate the result string
-        res = PyUnicode_DecodeUTF8(result, j, NULL);
-        PyObject_Free(result);
-    } else {
-        res = PyUnicode_DecodeUTF8(
-            tok_mode->last_expr_buffer,
-            tok_mode->last_expr_size - tok_mode->last_expr_end,
-            NULL
-        );
-
+  if (hash_detected) {
+    Py_ssize_t input_length =
+        tok_mode->last_expr_size - tok_mode->last_expr_end;
+    char *result = (char *)PyObject_Malloc((input_length + 1) * sizeof(char));
+    if (!result) {
+      return -1;
     }
 
+    Py_ssize_t i = 0;
+    Py_ssize_t j = 0;
 
-    if (!res) {
-        return -1;
+    for (i = 0, j = 0; i < input_length; i++) {
+      if (tok_mode->last_expr_buffer[i] == '#') {
+        // Skip characters until newline or end of string
+        while (tok_mode->last_expr_buffer[i] != '\0' && i < input_length) {
+          if (tok_mode->last_expr_buffer[i] == '\n') {
+            result[j++] = tok_mode->last_expr_buffer[i];
+            break;
+          }
+          i++;
+        }
+      } else {
+        result[j++] = tok_mode->last_expr_buffer[i];
+      }
     }
-    token->metadata = res;
-    return 0;
-}
 
-static int
-update_fstring_expr(struct tok_state *tok, char cur)
-{
-    assert(tok->cur != NULL);
+    result[j] = '\0'; // Null-terminate the result string
+    res = PyUnicode_DecodeUTF8(result, j, NULL);
+    PyObject_Free(result);
+  } else {
+    res = PyUnicode_DecodeUTF8(
+        tok_mode->last_expr_buffer,
+        tok_mode->last_expr_size - tok_mode->last_expr_end, NULL);
+  }
 
-    Py_ssize_t size = strlen(tok->cur);
-    tokenizer_mode *tok_mode = TOK_GET_MODE(tok);
-
-    switch (cur) {
-       case 0:
-            if (!tok_mode->last_expr_buffer || tok_mode->last_expr_end >= 0) {
-                return 1;
-            }
-            char *new_buffer = PyMem_Realloc(
-                tok_mode->last_expr_buffer,
-                tok_mode->last_expr_size + size
-            );
-            if (new_buffer == NULL) {
-                PyMem_Free(tok_mode->last_expr_buffer);
-                goto error;
-            }
-            tok_mode->last_expr_buffer = new_buffer;
-            strncpy(tok_mode->last_expr_buffer + tok_mode->last_expr_size, tok->cur, size);
-            tok_mode->last_expr_size += size;
-            break;
-        case '{':
-            if (tok_mode->last_expr_buffer != NULL) {
-                PyMem_Free(tok_mode->last_expr_buffer);
-            }
-            tok_mode->last_expr_buffer = PyMem_Malloc(size);
-            if (tok_mode->last_expr_buffer == NULL) {
-                goto error;
-            }
-            tok_mode->last_expr_size = size;
-            tok_mode->last_expr_end = -1;
-            strncpy(tok_mode->last_expr_buffer, tok->cur, size);
-            break;
-        case '}':
-        case '!':
-        case ':':
-            if (tok_mode->last_expr_end == -1) {
-                tok_mode->last_expr_end = strlen(tok->start);
-            }
-            break;
-        default:
-            Py_UNREACHABLE();
-    }
-    return 1;
+  if (!res) {
+    return -1;
+  }
+  token->metadata = res;
+  return 0;
+}
+
+static int update_fstring_expr(struct tok_state *tok, char cur) {
+  assert(tok->cur != NULL);
+
+  Py_ssize_t size = strlen(tok->cur);
+  tokenizer_mode *tok_mode = TOK_GET_MODE(tok);
+
+  switch (cur) {
+  case 0:
+    if (!tok_mode->last_expr_buffer || tok_mode->last_expr_end >= 0) {
+      return 1;
+    }
+    char *new_buffer = PyMem_Realloc(tok_mode->last_expr_buffer,
+                                     tok_mode->last_expr_size + size);
+    if (new_buffer == NULL) {
+      PyMem_Free(tok_mode->last_expr_buffer);
+      goto error;
+    }
+    tok_mode->last_expr_buffer = new_buffer;
+    strncpy(tok_mode->last_expr_buffer + tok_mode->last_expr_size, tok->cur,
+            size);
+    tok_mode->last_expr_size += size;
+    break;
+  case '{':
+    if (tok_mode->last_expr_buffer != NULL) {
+      PyMem_Free(tok_mode->last_expr_buffer);
+    }
+    tok_mode->last_expr_buffer = PyMem_Malloc(size);
+    if (tok_mode->last_expr_buffer == NULL) {
+      goto error;
+    }
+    tok_mode->last_expr_size = size;
+    tok_mode->last_expr_end = -1;
+    strncpy(tok_mode->last_expr_buffer, tok->cur, size);
+    break;
+  case '}':
+  case '!':
+  case ':':
+    if (tok_mode->last_expr_end == -1) {
+      tok_mode->last_expr_end = strlen(tok->start);
+    }
+    break;
+  default:
+    Py_UNREACHABLE();
+  }
+  return 1;
 error:
-    tok->done = E_NOMEM;
-    return 0;
+  tok->done = E_NOMEM;
+  return 0;
 }
 
-static void
-free_fstring_expressions(struct tok_state *tok)
-{
-    int index;
-    tokenizer_mode *mode;
-
-    for (index = tok->tok_mode_stack_index; index >= 0; --index) {
-        mode = &(tok->tok_mode_stack[index]);
-        if (mode->last_expr_buffer != NULL) {
-            PyMem_Free(mode->last_expr_buffer);
-            mode->last_expr_buffer = NULL;
-            mode->last_expr_size = 0;
-            mode->last_expr_end = -1;
-        }
+static void free_fstring_expressions(struct tok_state *tok) {
+  int index;
+  tokenizer_mode *mode;
+
+  for (index = tok->tok_mode_stack_index; index >= 0; --index) {
+    mode = &(tok->tok_mode_stack[index]);
+    if (mode->last_expr_buffer != NULL) {
+      PyMem_Free(mode->last_expr_buffer);
+      mode->last_expr_buffer = NULL;
+      mode->last_expr_size = 0;
+      mode->last_expr_end = -1;
+      mode->in_format_spec = 0;
     }
+  }
 }
 
 /* Read a line of text from TOK into S, using the stream in TOK.
@@ -539,88 +516,85 @@ free_fstring_expressions(struct tok_state *tok)
      1) NULL: need to call tok->decoding_readline to get a new line
      2) PyUnicodeObject *: decoding_feof has called tok->decoding_readline and
        stored the result in tok->decoding_buffer
-     3) PyByteArrayObject *: previous call to tok_readline_recode did not have enough room
-       (in the s buffer) to copy entire contents of the line read
-       by tok->decoding_readline.  tok->decoding_buffer has the overflow.
-       In this case, tok_readline_recode is called in a loop (with an expanded buffer)
-       until the buffer ends with a '\n' (or until the end of the file is
-       reached): see tok_nextc and its calls to tok_reserve_buf.
+     3) PyByteArrayObject *: previous call to tok_readline_recode did not have
+   enough room (in the s buffer) to copy entire contents of the line read by
+   tok->decoding_readline.  tok->decoding_buffer has the overflow. In this case,
+   tok_readline_recode is called in a loop (with an expanded buffer) until the
+   buffer ends with a '\n' (or until the end of the file is reached): see
+   tok_nextc and its calls to tok_reserve_buf.
 */
 
-static int
-tok_reserve_buf(struct tok_state *tok, Py_ssize_t size)
-{
-    Py_ssize_t cur = tok->cur - tok->buf;
-    Py_ssize_t oldsize = tok->inp - tok->buf;
-    Py_ssize_t newsize = oldsize + Py_MAX(size, oldsize >> 1);
-    if (newsize > tok->end - tok->buf) {
-        char *newbuf = tok->buf;
-        Py_ssize_t start = tok->start == NULL ? -1 : tok->start - tok->buf;
-        Py_ssize_t line_start = tok->start == NULL ? -1 : tok->line_start - tok->buf;
-        Py_ssize_t multi_line_start = tok->multi_line_start - tok->buf;
-        remember_fstring_buffers(tok);
-        newbuf = (char *)PyMem_Realloc(newbuf, newsize);
-        if (newbuf == NULL) {
-            tok->done = E_NOMEM;
-            return 0;
-        }
-        tok->buf = newbuf;
-        tok->cur = tok->buf + cur;
-        tok->inp = tok->buf + oldsize;
-        tok->end = tok->buf + newsize;
-        tok->start = start < 0 ? NULL : tok->buf + start;
-        tok->line_start = line_start < 0 ? NULL : tok->buf + line_start;
-        tok->multi_line_start = multi_line_start < 0 ? NULL : tok->buf + multi_line_start;
-        restore_fstring_buffers(tok);
-    }
-    return 1;
-}
-
-static inline int
-contains_null_bytes(const char* str, size_t size) {
-    return memchr(str, 0, size) != NULL;
-}
-
-static int
-tok_readline_recode(struct tok_state *tok) {
-    PyObject *line;
-    const  char *buf;
-    Py_ssize_t buflen;
-    line = tok->decoding_buffer;
+static int tok_reserve_buf(struct tok_state *tok, Py_ssize_t size) {
+  Py_ssize_t cur = tok->cur - tok->buf;
+  Py_ssize_t oldsize = tok->inp - tok->buf;
+  Py_ssize_t newsize = oldsize + Py_MAX(size, oldsize >> 1);
+  if (newsize > tok->end - tok->buf) {
+    char *newbuf = tok->buf;
+    Py_ssize_t start = tok->start == NULL ? -1 : tok->start - tok->buf;
+    Py_ssize_t line_start =
+        tok->start == NULL ? -1 : tok->line_start - tok->buf;
+    Py_ssize_t multi_line_start = tok->multi_line_start - tok->buf;
+    remember_fstring_buffers(tok);
+    newbuf = (char *)PyMem_Realloc(newbuf, newsize);
+    if (newbuf == NULL) {
+      tok->done = E_NOMEM;
+      return 0;
+    }
+    tok->buf = newbuf;
+    tok->cur = tok->buf + cur;
+    tok->inp = tok->buf + oldsize;
+    tok->end = tok->buf + newsize;
+    tok->start = start < 0 ? NULL : tok->buf + start;
+    tok->line_start = line_start < 0 ? NULL : tok->buf + line_start;
+    tok->multi_line_start =
+        multi_line_start < 0 ? NULL : tok->buf + multi_line_start;
+    restore_fstring_buffers(tok);
+  }
+  return 1;
+}
+
+static inline int contains_null_bytes(const char *str, size_t size) {
+  return memchr(str, 0, size) != NULL;
+}
+
+static int tok_readline_recode(struct tok_state *tok) {
+  PyObject *line;
+  const char *buf;
+  Py_ssize_t buflen;
+  line = tok->decoding_buffer;
+  if (line == NULL) {
+    line = PyObject_CallNoArgs(tok->decoding_readline);
     if (line == NULL) {
-        line = PyObject_CallNoArgs(tok->decoding_readline);
-        if (line == NULL) {
-            error_ret(tok);
-            goto error;
-        }
-    }
-    else {
-        tok->decoding_buffer = NULL;
+      error_ret(tok);
+      goto error;
     }
-    buf = PyUnicode_AsUTF8AndSize(line, &buflen);
-    if (buf == NULL) {
-        error_ret(tok);
-        goto error;
-    }
-    // Make room for the null terminator *and* potentially
-    // an extra newline character that we may need to artificially
-    // add.
-    size_t buffer_size = buflen + 2;
-    if (!tok_reserve_buf(tok, buffer_size)) {
-        goto error;
-    }
-    memcpy(tok->inp, buf, buflen);
-    tok->inp += buflen;
-    *tok->inp = '\0';
-    if (tok->fp_interactive &&
-        tok_concatenate_interactive_new_line(tok, buf) == -1) {
-        goto error;
-    }
-    Py_DECREF(line);
-    return 1;
+  } else {
+    tok->decoding_buffer = NULL;
+  }
+  buf = PyUnicode_AsUTF8AndSize(line, &buflen);
+  if (buf == NULL) {
+    error_ret(tok);
+    goto error;
+  }
+  // Make room for the null terminator *and* potentially
+  // an extra newline character that we may need to artificially
+  // add.
+  size_t buffer_size = buflen + 2;
+  if (!tok_reserve_buf(tok, buffer_size)) {
+    goto error;
+  }
+  memcpy(tok->inp, buf, buflen);
+  tok->inp += buflen;
+  *tok->inp = '\0';
+  if (tok->fp_interactive &&
+      tok_concatenate_interactive_new_line(tok, buf) == -1) {
+    goto error;
+  }
+  Py_DECREF(line);
+  return 1;
 error:
-    Py_XDECREF(line);
-    return 0;
+  Py_XDECREF(line);
+  return 0;
 }
 
 /* Set the readline function for TOK to a StreamReader's
@@ -633,2388 +607,2298 @@ error:
 
    Return 1 on success, 0 on failure. */
 
-static int
-fp_setreadl(struct tok_state *tok, const char* enc)
-{
-    PyObject *readline, *open, *stream;
-    int fd;
-    long pos;
-
-    fd = fileno(tok->fp);
-    /* Due to buffering the file offset for fd can be different from the file
-     * position of tok->fp.  If tok->fp was opened in text mode on Windows,
-     * its file position counts CRLF as one char and can't be directly mapped
-     * to the file offset for fd.  Instead we step back one byte and read to
-     * the end of line.*/
-    pos = ftell(tok->fp);
-    if (pos == -1 ||
-        lseek(fd, (off_t)(pos > 0 ? pos - 1 : pos), SEEK_SET) == (off_t)-1) {
-        PyErr_SetFromErrnoWithFilename(PyExc_OSError, NULL);
-        return 0;
-    }
+static int fp_setreadl(struct tok_state *tok, const char *enc) {
+  PyObject *readline, *open, *stream;
+  int fd;
+  long pos;
+
+  fd = fileno(tok->fp);
+  /* Due to buffering the file offset for fd can be different from the file
+   * position of tok->fp.  If tok->fp was opened in text mode on Windows,
+   * its file position counts CRLF as one char and can't be directly mapped
+   * to the file offset for fd.  Instead we step back one byte and read to
+   * the end of line.*/
+  pos = ftell(tok->fp);
+  if (pos == -1 ||
+      lseek(fd, (off_t)(pos > 0 ? pos - 1 : pos), SEEK_SET) == (off_t)-1) {
+    PyErr_SetFromErrnoWithFilename(PyExc_OSError, NULL);
+    return 0;
+  }
 
-    open = _PyImport_GetModuleAttrString("io", "open");
-    if (open == NULL) {
-        return 0;
-    }
-    stream = PyObject_CallFunction(open, "isisOOO",
-                    fd, "r", -1, enc, Py_None, Py_None, Py_False);
-    Py_DECREF(open);
-    if (stream == NULL) {
-        return 0;
-    }
+  open = _PyImport_GetModuleAttrString("io", "open");
+  if (open == NULL) {
+    return 0;
+  }
+  stream = PyObject_CallFunction(open, "isisOOO", fd, "r", -1, enc, Py_None,
+                                 Py_None, Py_False);
+  Py_DECREF(open);
+  if (stream == NULL) {
+    return 0;
+  }
 
-    readline = PyObject_GetAttr(stream, &_Py_ID(readline));
-    Py_DECREF(stream);
-    if (readline == NULL) {
-        return 0;
-    }
-    Py_XSETREF(tok->decoding_readline, readline);
+  readline = PyObject_GetAttr(stream, &_Py_ID(readline));
+  Py_DECREF(stream);
+  if (readline == NULL) {
+    return 0;
+  }
+  Py_XSETREF(tok->decoding_readline, readline);
 
-    if (pos > 0) {
-        PyObject *bufobj = _PyObject_CallNoArgs(readline);
-        if (bufobj == NULL) {
-            return 0;
-        }
-        Py_DECREF(bufobj);
+  if (pos > 0) {
+    PyObject *bufobj = _PyObject_CallNoArgs(readline);
+    if (bufobj == NULL) {
+      return 0;
     }
+    Py_DECREF(bufobj);
+  }
 
-    return 1;
+  return 1;
 }
 
 /* Fetch the next byte from TOK. */
 
-static int fp_getc(struct tok_state *tok) {
-    return getc(tok->fp);
-}
+static int fp_getc(struct tok_state *tok) { return getc(tok->fp); }
 
 /* Unfetch the last byte back into TOK.  */
 
-static void fp_ungetc(int c, struct tok_state *tok) {
-    ungetc(c, tok->fp);
-}
+static void fp_ungetc(int c, struct tok_state *tok) { ungetc(c, tok->fp); }
 
 /* Check whether the characters at s start a valid
    UTF-8 sequence. Return the number of characters forming
    the sequence if yes, 0 if not.  The special cases match
    those in stringlib/codecs.h:utf8_decode.
 */
-static int
-valid_utf8(const unsigned char* s)
-{
-    int expected = 0;
-    int length;
-    if (*s < 0x80) {
-        /* single-byte code */
-        return 1;
-    }
-    else if (*s < 0xE0) {
-        /* \xC2\x80-\xDF\xBF -- 0080-07FF */
-        if (*s < 0xC2) {
-            /* invalid sequence
-               \x80-\xBF -- continuation byte
-               \xC0-\xC1 -- fake 0000-007F */
-            return 0;
-        }
-        expected = 1;
-    }
-    else if (*s < 0xF0) {
-        /* \xE0\xA0\x80-\xEF\xBF\xBF -- 0800-FFFF */
-        if (*s == 0xE0 && *(s + 1) < 0xA0) {
-            /* invalid sequence
-               \xE0\x80\x80-\xE0\x9F\xBF -- fake 0000-0800 */
-            return 0;
-        }
-        else if (*s == 0xED && *(s + 1) >= 0xA0) {
-            /* Decoding UTF-8 sequences in range \xED\xA0\x80-\xED\xBF\xBF
-               will result in surrogates in range D800-DFFF. Surrogates are
-               not valid UTF-8 so they are rejected.
-               See https://www.unicode.org/versions/Unicode5.2.0/ch03.pdf
-               (table 3-7) and http://www.rfc-editor.org/rfc/rfc3629.txt */
-            return 0;
-        }
-        expected = 2;
-    }
-    else if (*s < 0xF5) {
-        /* \xF0\x90\x80\x80-\xF4\x8F\xBF\xBF -- 10000-10FFFF */
-        if (*(s + 1) < 0x90 ? *s == 0xF0 : *s == 0xF4) {
-            /* invalid sequence -- one of:
-               \xF0\x80\x80\x80-\xF0\x8F\xBF\xBF -- fake 0000-FFFF
-               \xF4\x90\x80\x80- -- 110000- overflow */
-            return 0;
-        }
-        expected = 3;
-    }
-    else {
-        /* invalid start byte */
-        return 0;
-    }
-    length = expected + 1;
-    for (; expected; expected--)
-        if (s[expected] < 0x80 || s[expected] >= 0xC0)
-            return 0;
-    return length;
-}
-
-static int
-ensure_utf8(char *line, struct tok_state *tok)
-{
-    int badchar = 0;
-    unsigned char *c;
-    int length;
-    for (c = (unsigned char *)line; *c; c += length) {
-        if (!(length = valid_utf8(c))) {
-            badchar = *c;
-            break;
-        }
-    }
-    if (badchar) {
-        PyErr_Format(PyExc_SyntaxError,
-                     "Non-UTF-8 code starting with '\\x%.2x' "
-                     "in file %U on line %i, "
-                     "but no encoding declared; "
-                     "see https://peps.python.org/pep-0263/ for details",
-                     badchar, tok->filename, tok->lineno);
-        return 0;
-    }
+static int valid_utf8(const unsigned char *s) {
+  int expected = 0;
+  int length;
+  if (*s < 0x80) {
+    /* single-byte code */
     return 1;
+  } else if (*s < 0xE0) {
+    /* \xC2\x80-\xDF\xBF -- 0080-07FF */
+    if (*s < 0xC2) {
+      /* invalid sequence
+         \x80-\xBF -- continuation byte
+         \xC0-\xC1 -- fake 0000-007F */
+      return 0;
+    }
+    expected = 1;
+  } else if (*s < 0xF0) {
+    /* \xE0\xA0\x80-\xEF\xBF\xBF -- 0800-FFFF */
+    if (*s == 0xE0 && *(s + 1) < 0xA0) {
+      /* invalid sequence
+         \xE0\x80\x80-\xE0\x9F\xBF -- fake 0000-0800 */
+      return 0;
+    } else if (*s == 0xED && *(s + 1) >= 0xA0) {
+      /* Decoding UTF-8 sequences in range \xED\xA0\x80-\xED\xBF\xBF
+         will result in surrogates in range D800-DFFF. Surrogates are
+         not valid UTF-8 so they are rejected.
+         See https://www.unicode.org/versions/Unicode5.2.0/ch03.pdf
+         (table 3-7) and http://www.rfc-editor.org/rfc/rfc3629.txt */
+      return 0;
+    }
+    expected = 2;
+  } else if (*s < 0xF5) {
+    /* \xF0\x90\x80\x80-\xF4\x8F\xBF\xBF -- 10000-10FFFF */
+    if (*(s + 1) < 0x90 ? *s == 0xF0 : *s == 0xF4) {
+      /* invalid sequence -- one of:
+         \xF0\x80\x80\x80-\xF0\x8F\xBF\xBF -- fake 0000-FFFF
+         \xF4\x90\x80\x80- -- 110000- overflow */
+      return 0;
+    }
+    expected = 3;
+  } else {
+    /* invalid start byte */
+    return 0;
+  }
+  length = expected + 1;
+  for (; expected; expected--)
+    if (s[expected] < 0x80 || s[expected] >= 0xC0)
+      return 0;
+  return length;
+}
+
+static int ensure_utf8(char *line, struct tok_state *tok) {
+  int badchar = 0;
+  unsigned char *c;
+  int length;
+  for (c = (unsigned char *)line; *c; c += length) {
+    if (!(length = valid_utf8(c))) {
+      badchar = *c;
+      break;
+    }
+  }
+  if (badchar) {
+    PyErr_Format(PyExc_SyntaxError,
+                 "Non-UTF-8 code starting with '\\x%.2x' "
+                 "in file %U on line %i, "
+                 "but no encoding declared; "
+                 "see https://peps.python.org/pep-0263/ for details",
+                 badchar, tok->filename, tok->lineno);
+    return 0;
+  }
+  return 1;
 }
 
 /* Fetch a byte from TOK, using the string buffer. */
 
-static int
-buf_getc(struct tok_state *tok) {
-    return Py_CHARMASK(*tok->str++);
-}
+static int buf_getc(struct tok_state *tok) { return Py_CHARMASK(*tok->str++); }
 
 /* Unfetch a byte from TOK, using the string buffer. */
 
-static void
-buf_ungetc(int c, struct tok_state *tok) {
-    tok->str--;
-    assert(Py_CHARMASK(*tok->str) == c);        /* tok->cur may point to read-only segment */
+static void buf_ungetc(int c, struct tok_state *tok) {
+  tok->str--;
+  assert(Py_CHARMASK(*tok->str) ==
+         c); /* tok->cur may point to read-only segment */
 }
 
 /* Set the readline function for TOK to ENC. For the string-based
    tokenizer, this means to just record the encoding. */
 
-static int
-buf_setreadl(struct tok_state *tok, const char* enc) {
-    tok->enc = enc;
-    return 1;
+static int buf_setreadl(struct tok_state *tok, const char *enc) {
+  tok->enc = enc;
+  return 1;
 }
 
 /* Return a UTF-8 encoding Python string object from the
    C byte string STR, which is encoded with ENC. */
 
-static PyObject *
-translate_into_utf8(const char* str, const char* enc) {
-    PyObject *utf8;
-    PyObject* buf = PyUnicode_Decode(str, strlen(str), enc, NULL);
-    if (buf == NULL)
-        return NULL;
-    utf8 = PyUnicode_AsUTF8String(buf);
-    Py_DECREF(buf);
-    return utf8;
+static PyObject *translate_into_utf8(const char *str, const char *enc) {
+  PyObject *utf8;
+  PyObject *buf = PyUnicode_Decode(str, strlen(str), enc, NULL);
+  if (buf == NULL)
+    return NULL;
+  utf8 = PyUnicode_AsUTF8String(buf);
+  Py_DECREF(buf);
+  return utf8;
 }
 
-
-static char *
-translate_newlines(const char *s, int exec_input, int preserve_crlf,
-                   struct tok_state *tok) {
-    int skip_next_lf = 0;
+static char *translate_newlines(const char *s, int exec_input,
+                                int preserve_crlf, struct tok_state *tok) {
+  int skip_next_lf = 0;
 #if defined(__has_feature)
 #  if __has_feature(memory_sanitizer)
     __msan_unpoison_string(s);
 #  endif
 #endif
-    size_t needed_length = strlen(s) + 2, final_length;
-    char *buf, *current;
-    char c = '\0';
-    buf = PyMem_Malloc(needed_length);
-    if (buf == NULL) {
-        tok->done = E_NOMEM;
-        return NULL;
-    }
-    for (current = buf; *s; s++, current++) {
-        c = *s;
-        if (skip_next_lf) {
-            skip_next_lf = 0;
-            if (c == '\n') {
-                c = *++s;
-                if (!c)
-                    break;
-            }
-        }
-        if (!preserve_crlf && c == '\r') {
-            skip_next_lf = 1;
-            c = '\n';
-        }
-        *current = c;
-    }
-    /* If this is exec input, add a newline to the end of the string if
-       there isn't one already. */
-    if (exec_input && c != '\n' && c != '\0') {
-        *current = '\n';
-        current++;
-    }
-    *current = '\0';
-    final_length = current - buf + 1;
-    if (final_length < needed_length && final_length) {
-        /* should never fail */
-        char* result = PyMem_Realloc(buf, final_length);
-        if (result == NULL) {
-            PyMem_Free(buf);
-        }
-        buf = result;
-    }
-    return buf;
+  size_t needed_length = strlen(s) + 2, final_length;
+  char *buf, *current;
+  char c = '\0';
+  buf = PyMem_Malloc(needed_length);
+  if (buf == NULL) {
+    tok->done = E_NOMEM;
+    return NULL;
+  }
+  for (current = buf; *s; s++, current++) {
+    c = *s;
+    if (skip_next_lf) {
+      skip_next_lf = 0;
+      if (c == '\n') {
+        c = *++s;
+        if (!c)
+          break;
+      }
+    }
+    if (!preserve_crlf && c == '\r') {
+      skip_next_lf = 1;
+      c = '\n';
+    }
+    *current = c;
+  }
+  /* If this is exec input, add a newline to the end of the string if
+     there isn't one already. */
+  if (exec_input && c != '\n' && c != '\0') {
+    *current = '\n';
+    current++;
+  }
+  *current = '\0';
+  final_length = current - buf + 1;
+  if (final_length < needed_length && final_length) {
+    /* should never fail */
+    char *result = PyMem_Realloc(buf, final_length);
+    if (result == NULL) {
+      PyMem_Free(buf);
+    }
+    buf = result;
+  }
+  return buf;
 }
 
 /* Decode a byte string STR for use as the buffer of TOK.
    Look for encoding declarations inside STR, and record them
    inside TOK.  */
 
-static char *
-decode_str(const char *input, int single, struct tok_state *tok, int preserve_crlf)
-{
-    PyObject* utf8 = NULL;
-    char *str;
-    const char *s;
-    const char *newl[2] = {NULL, NULL};
-    int lineno = 0;
-    tok->input = str = translate_newlines(input, single, preserve_crlf, tok);
-    if (str == NULL)
-        return NULL;
-    tok->enc = NULL;
-    tok->str = str;
-    if (!check_bom(buf_getc, buf_ungetc, buf_setreadl, tok))
-        return error_ret(tok);
-    str = tok->str;             /* string after BOM if any */
-    assert(str);
-    if (tok->enc != NULL) {
-        utf8 = translate_into_utf8(str, tok->enc);
-        if (utf8 == NULL)
-            return error_ret(tok);
-        str = PyBytes_AsString(utf8);
-    }
-    for (s = str;; s++) {
-        if (*s == '\0') break;
-        else if (*s == '\n') {
-            assert(lineno < 2);
-            newl[lineno] = s;
-            lineno++;
-            if (lineno == 2) break;
-        }
+static char *decode_str(const char *input, int single, struct tok_state *tok,
+                        int preserve_crlf) {
+  PyObject *utf8 = NULL;
+  char *str;
+  const char *s;
+  const char *newl[2] = {NULL, NULL};
+  int lineno = 0;
+  tok->input = str = translate_newlines(input, single, preserve_crlf, tok);
+  if (str == NULL)
+    return NULL;
+  tok->enc = NULL;
+  tok->str = str;
+  if (!check_bom(buf_getc, buf_ungetc, buf_setreadl, tok))
+    return error_ret(tok);
+  str = tok->str; /* string after BOM if any */
+  assert(str);
+  if (tok->enc != NULL) {
+    utf8 = translate_into_utf8(str, tok->enc);
+    if (utf8 == NULL)
+      return error_ret(tok);
+    str = PyBytes_AsString(utf8);
+  }
+  for (s = str;; s++) {
+    if (*s == '\0')
+      break;
+    else if (*s == '\n') {
+      assert(lineno < 2);
+      newl[lineno] = s;
+      lineno++;
+      if (lineno == 2)
+        break;
     }
-    tok->enc = NULL;
-    /* need to check line 1 and 2 separately since check_coding_spec
-       assumes a single line as input */
-    if (newl[0]) {
-        if (!check_coding_spec(str, newl[0] - str, tok, buf_setreadl)) {
-            return NULL;
-        }
-        if (tok->enc == NULL && tok->decoding_state != STATE_NORMAL && newl[1]) {
-            if (!check_coding_spec(newl[0]+1, newl[1] - newl[0],
-                                   tok, buf_setreadl))
-                return NULL;
-        }
+  }
+  tok->enc = NULL;
+  /* need to check line 1 and 2 separately since check_coding_spec
+     assumes a single line as input */
+  if (newl[0]) {
+    if (!check_coding_spec(str, newl[0] - str, tok, buf_setreadl)) {
+      return NULL;
     }
-    if (tok->enc != NULL) {
-        assert(utf8 == NULL);
-        utf8 = translate_into_utf8(str, tok->enc);
-        if (utf8 == NULL)
-            return error_ret(tok);
-        str = PyBytes_AS_STRING(utf8);
+    if (tok->enc == NULL && tok->decoding_state != STATE_NORMAL && newl[1]) {
+      if (!check_coding_spec(newl[0] + 1, newl[1] - newl[0], tok, buf_setreadl))
+        return NULL;
     }
-    assert(tok->decoding_buffer == NULL);
-    tok->decoding_buffer = utf8; /* CAUTION */
-    return str;
+  }
+  if (tok->enc != NULL) {
+    assert(utf8 == NULL);
+    utf8 = translate_into_utf8(str, tok->enc);
+    if (utf8 == NULL)
+      return error_ret(tok);
+    str = PyBytes_AS_STRING(utf8);
+  }
+  assert(tok->decoding_buffer == NULL);
+  tok->decoding_buffer = utf8; /* CAUTION */
+  return str;
 }
 
 /* Set up tokenizer for string */
 
-struct tok_state *
-_PyTokenizer_FromString(const char *str, int exec_input, int preserve_crlf)
-{
-    struct tok_state *tok = tok_new();
-    char *decoded;
+struct tok_state *_PyTokenizer_FromString(const char *str, int exec_input,
+                                          int preserve_crlf) {
+  struct tok_state *tok = tok_new();
+  char *decoded;
 
-    if (tok == NULL)
-        return NULL;
-    decoded = decode_str(str, exec_input, tok, preserve_crlf);
-    if (decoded == NULL) {
-        _PyTokenizer_Free(tok);
-        return NULL;
-    }
+  if (tok == NULL)
+    return NULL;
+  decoded = decode_str(str, exec_input, tok, preserve_crlf);
+  if (decoded == NULL) {
+    _PyTokenizer_Free(tok);
+    return NULL;
+  }
 
-    tok->buf = tok->cur = tok->inp = decoded;
-    tok->end = decoded;
-    return tok;
+  tok->buf = tok->cur = tok->inp = decoded;
+  tok->end = decoded;
+  return tok;
 }
 
-struct tok_state *
-_PyTokenizer_FromReadline(PyObject* readline, const char* enc,
-                          int exec_input, int preserve_crlf)
-{
-    struct tok_state *tok = tok_new();
-    if (tok == NULL)
-        return NULL;
-    if ((tok->buf = (char *)PyMem_Malloc(BUFSIZ)) == NULL) {
-        _PyTokenizer_Free(tok);
-        return NULL;
-    }
-    tok->cur = tok->inp = tok->buf;
-    tok->end = tok->buf + BUFSIZ;
-    tok->fp = NULL;
-    if (enc != NULL) {
-        tok->encoding = new_string(enc, strlen(enc), tok);
-        if (!tok->encoding) {
-            _PyTokenizer_Free(tok);
-            return NULL;
-        }
+struct tok_state *_PyTokenizer_FromReadline(PyObject *readline, const char *enc,
+                                            int exec_input, int preserve_crlf) {
+  struct tok_state *tok = tok_new();
+  if (tok == NULL)
+    return NULL;
+  if ((tok->buf = (char *)PyMem_Malloc(BUFSIZ)) == NULL) {
+    _PyTokenizer_Free(tok);
+    return NULL;
+  }
+  tok->cur = tok->inp = tok->buf;
+  tok->end = tok->buf + BUFSIZ;
+  tok->fp = NULL;
+  if (enc != NULL) {
+    tok->encoding = new_string(enc, strlen(enc), tok);
+    if (!tok->encoding) {
+      _PyTokenizer_Free(tok);
+      return NULL;
     }
-    tok->decoding_state = STATE_NORMAL;
-    Py_INCREF(readline);
-    tok->readline = readline;
-    return tok;
+  }
+  tok->decoding_state = STATE_NORMAL;
+  Py_INCREF(readline);
+  tok->readline = readline;
+  return tok;
 }
 
 /* Set up tokenizer for UTF-8 string */
 
-struct tok_state *
-_PyTokenizer_FromUTF8(const char *str, int exec_input, int preserve_crlf)
-{
-    struct tok_state *tok = tok_new();
-    char *translated;
-    if (tok == NULL)
-        return NULL;
-    tok->input = translated = translate_newlines(str, exec_input, preserve_crlf, tok);
-    if (translated == NULL) {
-        _PyTokenizer_Free(tok);
-        return NULL;
-    }
-    tok->decoding_state = STATE_NORMAL;
-    tok->enc = NULL;
-    tok->str = translated;
-    tok->encoding = new_string("utf-8", 5, tok);
-    if (!tok->encoding) {
-        _PyTokenizer_Free(tok);
-        return NULL;
-    }
+struct tok_state *_PyTokenizer_FromUTF8(const char *str, int exec_input,
+                                        int preserve_crlf) {
+  struct tok_state *tok = tok_new();
+  char *translated;
+  if (tok == NULL)
+    return NULL;
+  tok->input = translated =
+      translate_newlines(str, exec_input, preserve_crlf, tok);
+  if (translated == NULL) {
+    _PyTokenizer_Free(tok);
+    return NULL;
+  }
+  tok->decoding_state = STATE_NORMAL;
+  tok->enc = NULL;
+  tok->str = translated;
+  tok->encoding = new_string("utf-8", 5, tok);
+  if (!tok->encoding) {
+    _PyTokenizer_Free(tok);
+    return NULL;
+  }
 
-    tok->buf = tok->cur = tok->inp = translated;
-    tok->end = translated;
-    return tok;
+  tok->buf = tok->cur = tok->inp = translated;
+  tok->end = translated;
+  return tok;
 }
 
 /* Set up tokenizer for file */
 
-struct tok_state *
-_PyTokenizer_FromFile(FILE *fp, const char* enc,
-                      const char *ps1, const char *ps2)
-{
-    struct tok_state *tok = tok_new();
-    if (tok == NULL)
-        return NULL;
-    if ((tok->buf = (char *)PyMem_Malloc(BUFSIZ)) == NULL) {
-        _PyTokenizer_Free(tok);
-        return NULL;
-    }
-    tok->cur = tok->inp = tok->buf;
-    tok->end = tok->buf + BUFSIZ;
-    tok->fp = fp;
-    tok->prompt = ps1;
-    tok->nextprompt = ps2;
-    if (enc != NULL) {
-        /* Must copy encoding declaration since it
-           gets copied into the parse tree. */
-        tok->encoding = new_string(enc, strlen(enc), tok);
-        if (!tok->encoding) {
-            _PyTokenizer_Free(tok);
-            return NULL;
-        }
-        tok->decoding_state = STATE_NORMAL;
+struct tok_state *_PyTokenizer_FromFile(FILE *fp, const char *enc,
+                                        const char *ps1, const char *ps2) {
+  struct tok_state *tok = tok_new();
+  if (tok == NULL)
+    return NULL;
+  if ((tok->buf = (char *)PyMem_Malloc(BUFSIZ)) == NULL) {
+    _PyTokenizer_Free(tok);
+    return NULL;
+  }
+  tok->cur = tok->inp = tok->buf;
+  tok->end = tok->buf + BUFSIZ;
+  tok->fp = fp;
+  tok->prompt = ps1;
+  tok->nextprompt = ps2;
+  if (enc != NULL) {
+    /* Must copy encoding declaration since it
+       gets copied into the parse tree. */
+    tok->encoding = new_string(enc, strlen(enc), tok);
+    if (!tok->encoding) {
+      _PyTokenizer_Free(tok);
+      return NULL;
     }
-    return tok;
+    tok->decoding_state = STATE_NORMAL;
+  }
+  return tok;
 }
 
 /* Free a tok_state structure */
 
-void
-_PyTokenizer_Free(struct tok_state *tok)
-{
-    if (tok->encoding != NULL) {
-        PyMem_Free(tok->encoding);
-    }
-    Py_XDECREF(tok->decoding_readline);
-    Py_XDECREF(tok->decoding_buffer);
-    Py_XDECREF(tok->readline);
-    Py_XDECREF(tok->filename);
-    if ((tok->readline != NULL || tok->fp != NULL ) && tok->buf != NULL) {
-        PyMem_Free(tok->buf);
-    }
-    if (tok->input) {
-        PyMem_Free(tok->input);
-    }
-    if (tok->interactive_src_start != NULL) {
-        PyMem_Free(tok->interactive_src_start);
+void _PyTokenizer_Free(struct tok_state *tok) {
+  if (tok->encoding != NULL) {
+    PyMem_Free(tok->encoding);
+  }
+  Py_XDECREF(tok->decoding_readline);
+  Py_XDECREF(tok->decoding_buffer);
+  Py_XDECREF(tok->readline);
+  Py_XDECREF(tok->filename);
+  if ((tok->readline != NULL || tok->fp != NULL) && tok->buf != NULL) {
+    PyMem_Free(tok->buf);
+  }
+  if (tok->input) {
+    PyMem_Free(tok->input);
+  }
+  if (tok->interactive_src_start != NULL) {
+    PyMem_Free(tok->interactive_src_start);
+  }
+  free_fstring_expressions(tok);
+  PyMem_Free(tok);
+}
+
+void _PyToken_Free(struct token *token) { Py_XDECREF(token->metadata); }
+
+void _PyToken_Init(struct token *token) { token->metadata = NULL; }
+
+static int tok_readline_raw(struct tok_state *tok) {
+  do {
+    if (!tok_reserve_buf(tok, BUFSIZ)) {
+      return 0;
+    }
+    int n_chars = (int)(tok->end - tok->inp);
+    size_t line_size = 0;
+    char *line = _Py_UniversalNewlineFgetsWithSize(tok->inp, n_chars, tok->fp,
+                                                   NULL, &line_size);
+    if (line == NULL) {
+      return 1;
     }
-    free_fstring_expressions(tok);
-    PyMem_Free(tok);
-}
-
-void
-_PyToken_Free(struct token *token) {
-    Py_XDECREF(token->metadata);
-}
-
-void
-_PyToken_Init(struct token *token) {
-    token->metadata = NULL;
-}
-
-static int
-tok_readline_raw(struct tok_state *tok)
-{
-    do {
-        if (!tok_reserve_buf(tok, BUFSIZ)) {
-            return 0;
-        }
-        int n_chars = (int)(tok->end - tok->inp);
-        size_t line_size = 0;
-        char *line = _Py_UniversalNewlineFgetsWithSize(tok->inp, n_chars, tok->fp, NULL, &line_size);
-        if (line == NULL) {
-            return 1;
-        }
-        if (tok->fp_interactive &&
-            tok_concatenate_interactive_new_line(tok, line) == -1) {
-            return 0;
-        }
-        tok->inp += line_size;
-        if (tok->inp == tok->buf) {
-            return 0;
-        }
-    } while (tok->inp[-1] != '\n');
+    if (tok->fp_interactive &&
+        tok_concatenate_interactive_new_line(tok, line) == -1) {
+      return 0;
+    }
+    tok->inp += line_size;
+    if (tok->inp == tok->buf) {
+      return 0;
+    }
+  } while (tok->inp[-1] != '\n');
+  return 1;
+}
+
+static int tok_readline_string(struct tok_state *tok) {
+  PyObject *line = NULL;
+  PyObject *raw_line = PyObject_CallNoArgs(tok->readline);
+  if (raw_line == NULL) {
+    if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
+      PyErr_Clear();
+      return 1;
+    }
+    error_ret(tok);
+    goto error;
+  }
+  if (tok->encoding != NULL) {
+    if (!PyBytes_Check(raw_line)) {
+      PyErr_Format(PyExc_TypeError, "readline() returned a non-bytes object");
+      error_ret(tok);
+      goto error;
+    }
+    line =
+        PyUnicode_Decode(PyBytes_AS_STRING(raw_line),
+                         PyBytes_GET_SIZE(raw_line), tok->encoding, "replace");
+    Py_CLEAR(raw_line);
+    if (line == NULL) {
+      error_ret(tok);
+      goto error;
+    }
+  } else {
+    if (!PyUnicode_Check(raw_line)) {
+      PyErr_Format(PyExc_TypeError, "readline() returned a non-string object");
+      error_ret(tok);
+      goto error;
+    }
+    line = raw_line;
+    raw_line = NULL;
+  }
+  Py_ssize_t buflen;
+  const char *buf = PyUnicode_AsUTF8AndSize(line, &buflen);
+  if (buf == NULL) {
+    error_ret(tok);
+    goto error;
+  }
+
+  // Make room for the null terminator *and* potentially
+  // an extra newline character that we may need to artificially
+  // add.
+  size_t buffer_size = buflen + 2;
+  if (!tok_reserve_buf(tok, buffer_size)) {
+    goto error;
+  }
+  memcpy(tok->inp, buf, buflen);
+  tok->inp += buflen;
+  *tok->inp = '\0';
+
+  tok->line_start = tok->cur;
+  Py_DECREF(line);
+  return 1;
+error:
+  Py_XDECREF(raw_line);
+  Py_XDECREF(line);
+  return 0;
+}
+
+static int tok_underflow_string(struct tok_state *tok) {
+  char *end = strchr(tok->inp, '\n');
+  if (end != NULL) {
+    end++;
+  } else {
+    end = strchr(tok->inp, '\0');
+    if (end == tok->inp) {
+      tok->done = E_EOF;
+      return 0;
+    }
+  }
+  if (tok->start == NULL) {
+    tok->buf = tok->cur;
+  }
+  tok->line_start = tok->cur;
+  ADVANCE_LINENO();
+  tok->inp = end;
+  return 1;
+}
+
+static int tok_underflow_interactive(struct tok_state *tok) {
+  if (tok->interactive_underflow == IUNDERFLOW_STOP) {
+    tok->done = E_INTERACT_STOP;
     return 1;
-}
-
-static int
-tok_readline_string(struct tok_state* tok) {
-    PyObject* line = NULL;
-    PyObject* raw_line = PyObject_CallNoArgs(tok->readline);
-    if (raw_line == NULL) {
-        if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
-            PyErr_Clear();
-            return 1;
-        }
-        error_ret(tok);
-        goto error;
-    }
-    if(tok->encoding != NULL) {
-        if (!PyBytes_Check(raw_line)) {
-            PyErr_Format(PyExc_TypeError, "readline() returned a non-bytes object");
-            error_ret(tok);
-            goto error;
-        }
-        line = PyUnicode_Decode(PyBytes_AS_STRING(raw_line), PyBytes_GET_SIZE(raw_line),
-                                tok->encoding, "replace");
-        Py_CLEAR(raw_line);
-        if (line == NULL) {
-            error_ret(tok);
-            goto error;
-        }
-    } else {
-        if(!PyUnicode_Check(raw_line)) {
-            PyErr_Format(PyExc_TypeError, "readline() returned a non-string object");
-            error_ret(tok);
-            goto error;
-        }
-        line = raw_line;
-        raw_line = NULL;
+  }
+  char *newtok = PyOS_Readline(tok->fp ? tok->fp : stdin, stdout, tok->prompt);
+  if (newtok != NULL) {
+    char *translated = translate_newlines(newtok, 0, 0, tok);
+    PyMem_Free(newtok);
+    if (translated == NULL) {
+      return 0;
     }
+    newtok = translated;
+  }
+  if (tok->encoding && newtok && *newtok) {
+    /* Recode to UTF-8 */
     Py_ssize_t buflen;
-    const char* buf = PyUnicode_AsUTF8AndSize(line, &buflen);
-    if (buf == NULL) {
-        error_ret(tok);
-        goto error;
-    }
-
-    // Make room for the null terminator *and* potentially
-    // an extra newline character that we may need to artificially
-    // add.
-    size_t buffer_size = buflen + 2;
-    if (!tok_reserve_buf(tok, buffer_size)) {
-        goto error;
-    }
-    memcpy(tok->inp, buf, buflen);
-    tok->inp += buflen;
-    *tok->inp = '\0';
-
-    tok->line_start = tok->cur;
-    Py_DECREF(line);
-    return 1;
-error:
-    Py_XDECREF(raw_line);
-    Py_XDECREF(line);
+    const char *buf;
+    PyObject *u = translate_into_utf8(newtok, tok->encoding);
+    PyMem_Free(newtok);
+    if (u == NULL) {
+      tok->done = E_DECODE;
+      return 0;
+    }
+    buflen = PyBytes_GET_SIZE(u);
+    buf = PyBytes_AS_STRING(u);
+    newtok = PyMem_Malloc(buflen + 1);
+    if (newtok == NULL) {
+      Py_DECREF(u);
+      tok->done = E_NOMEM;
+      return 0;
+    }
+    strcpy(newtok, buf);
+    Py_DECREF(u);
+  }
+  if (tok->fp_interactive &&
+      tok_concatenate_interactive_new_line(tok, newtok) == -1) {
+    PyMem_Free(newtok);
     return 0;
-}
-
-static int
-tok_underflow_string(struct tok_state *tok) {
-    char *end = strchr(tok->inp, '\n');
-    if (end != NULL) {
-        end++;
-    }
-    else {
-        end = strchr(tok->inp, '\0');
-        if (end == tok->inp) {
-            tok->done = E_EOF;
-            return 0;
-        }
-    }
-    if (tok->start == NULL) {
-        tok->buf = tok->cur;
-    }
-    tok->line_start = tok->cur;
+  }
+  if (tok->nextprompt != NULL) {
+    tok->prompt = tok->nextprompt;
+  }
+  if (newtok == NULL) {
+    tok->done = E_INTR;
+  } else if (*newtok == '\0') {
+    PyMem_Free(newtok);
+    tok->done = E_EOF;
+  } else if (tok->start != NULL) {
+    Py_ssize_t cur_multi_line_start = tok->multi_line_start - tok->buf;
+    remember_fstring_buffers(tok);
+    size_t size = strlen(newtok);
     ADVANCE_LINENO();
-    tok->inp = end;
-    return 1;
-}
-
-static int
-tok_underflow_interactive(struct tok_state *tok) {
-    if (tok->interactive_underflow == IUNDERFLOW_STOP) {
-        tok->done = E_INTERACT_STOP;
-        return 1;
-    }
-    char *newtok = PyOS_Readline(tok->fp ? tok->fp : stdin, stdout, tok->prompt);
-    if (newtok != NULL) {
-        char *translated = translate_newlines(newtok, 0, 0, tok);
-        PyMem_Free(newtok);
-        if (translated == NULL) {
-            return 0;
-        }
-        newtok = translated;
-    }
-    if (tok->encoding && newtok && *newtok) {
-        /* Recode to UTF-8 */
-        Py_ssize_t buflen;
-        const char* buf;
-        PyObject *u = translate_into_utf8(newtok, tok->encoding);
-        PyMem_Free(newtok);
-        if (u == NULL) {
-            tok->done = E_DECODE;
-            return 0;
-        }
-        buflen = PyBytes_GET_SIZE(u);
-        buf = PyBytes_AS_STRING(u);
-        newtok = PyMem_Malloc(buflen+1);
-        if (newtok == NULL) {
-            Py_DECREF(u);
-            tok->done = E_NOMEM;
-            return 0;
-        }
-        strcpy(newtok, buf);
-        Py_DECREF(u);
-    }
-    if (tok->fp_interactive &&
-        tok_concatenate_interactive_new_line(tok, newtok) == -1) {
-        PyMem_Free(newtok);
-        return 0;
-    }
-    if (tok->nextprompt != NULL) {
-        tok->prompt = tok->nextprompt;
-    }
-    if (newtok == NULL) {
-        tok->done = E_INTR;
-    }
-    else if (*newtok == '\0') {
-        PyMem_Free(newtok);
-        tok->done = E_EOF;
-    }
-    else if (tok->start != NULL) {
-        Py_ssize_t cur_multi_line_start = tok->multi_line_start - tok->buf;
-        remember_fstring_buffers(tok);
-        size_t size = strlen(newtok);
-        ADVANCE_LINENO();
-        if (!tok_reserve_buf(tok, size + 1)) {
-            PyMem_Free(tok->buf);
-            tok->buf = NULL;
-            PyMem_Free(newtok);
-            return 0;
-        }
-        memcpy(tok->cur, newtok, size + 1);
-        PyMem_Free(newtok);
-        tok->inp += size;
-        tok->multi_line_start = tok->buf + cur_multi_line_start;
-        restore_fstring_buffers(tok);
-    }
-    else {
-        remember_fstring_buffers(tok);
-        ADVANCE_LINENO();
-        PyMem_Free(tok->buf);
-        tok->buf = newtok;
-        tok->cur = tok->buf;
-        tok->line_start = tok->buf;
-        tok->inp = strchr(tok->buf, '\0');
-        tok->end = tok->inp + 1;
-        restore_fstring_buffers(tok);
-    }
-    if (tok->done != E_OK) {
-        if (tok->prompt != NULL) {
-            PySys_WriteStderr("\n");
-        }
-        return 0;
+    if (!tok_reserve_buf(tok, size + 1)) {
+      PyMem_Free(tok->buf);
+      tok->buf = NULL;
+      PyMem_Free(newtok);
+      return 0;
+    }
+    memcpy(tok->cur, newtok, size + 1);
+    PyMem_Free(newtok);
+    tok->inp += size;
+    tok->multi_line_start = tok->buf + cur_multi_line_start;
+    restore_fstring_buffers(tok);
+  } else {
+    remember_fstring_buffers(tok);
+    ADVANCE_LINENO();
+    PyMem_Free(tok->buf);
+    tok->buf = newtok;
+    tok->cur = tok->buf;
+    tok->line_start = tok->buf;
+    tok->inp = strchr(tok->buf, '\0');
+    tok->end = tok->inp + 1;
+    restore_fstring_buffers(tok);
+  }
+  if (tok->done != E_OK) {
+    if (tok->prompt != NULL) {
+      PySys_WriteStderr("\n");
     }
+    return 0;
+  }
 
-    if (tok->tok_mode_stack_index && !update_fstring_expr(tok, 0)) {
-        return 0;
-    }
-    return 1;
+  if (tok->tok_mode_stack_index && !update_fstring_expr(tok, 0)) {
+    return 0;
+  }
+  return 1;
 }
 
-static int
-tok_underflow_file(struct tok_state *tok) {
-    if (tok->start == NULL && !INSIDE_FSTRING(tok)) {
-        tok->cur = tok->inp = tok->buf;
-    }
-    if (tok->decoding_state == STATE_INIT) {
-        /* We have not yet determined the encoding.
-           If an encoding is found, use the file-pointer
-           reader functions from now on. */
-        if (!check_bom(fp_getc, fp_ungetc, fp_setreadl, tok)) {
-            error_ret(tok);
-            return 0;
-        }
-        assert(tok->decoding_state != STATE_INIT);
-    }
-    /* Read until '\n' or EOF */
-    if (tok->decoding_readline != NULL) {
-        /* We already have a codec associated with this input. */
-        if (!tok_readline_recode(tok)) {
-            return 0;
-        }
-    }
-    else {
-        /* We want a 'raw' read. */
-        if (!tok_readline_raw(tok)) {
-            return 0;
-        }
-    }
-    if (tok->inp == tok->cur) {
-        tok->done = E_EOF;
-        return 0;
-    }
-    tok->implicit_newline = 0;
-    if (tok->inp[-1] != '\n') {
-        assert(tok->inp + 1 < tok->end);
-        /* Last line does not end in \n, fake one */
-        *tok->inp++ = '\n';
-        *tok->inp = '\0';
-        tok->implicit_newline = 1;
-    }
-
-    if (tok->tok_mode_stack_index && !update_fstring_expr(tok, 0)) {
-        return 0;
-    }
+static int tok_underflow_file(struct tok_state *tok) {
+  if (tok->start == NULL && !INSIDE_FSTRING(tok)) {
+    tok->cur = tok->inp = tok->buf;
+  }
+  if (tok->decoding_state == STATE_INIT) {
+    /* We have not yet determined the encoding.
+       If an encoding is found, use the file-pointer
+       reader functions from now on. */
+    if (!check_bom(fp_getc, fp_ungetc, fp_setreadl, tok)) {
+      error_ret(tok);
+      return 0;
+    }
+    assert(tok->decoding_state != STATE_INIT);
+  }
+  /* Read until '\n' or EOF */
+  if (tok->decoding_readline != NULL) {
+    /* We already have a codec associated with this input. */
+    if (!tok_readline_recode(tok)) {
+      return 0;
+    }
+  } else {
+    /* We want a 'raw' read. */
+    if (!tok_readline_raw(tok)) {
+      return 0;
+    }
+  }
+  if (tok->inp == tok->cur) {
+    tok->done = E_EOF;
+    return 0;
+  }
+  tok->implicit_newline = 0;
+  if (tok->inp[-1] != '\n') {
+    assert(tok->inp + 1 < tok->end);
+    /* Last line does not end in \n, fake one */
+    *tok->inp++ = '\n';
+    *tok->inp = '\0';
+    tok->implicit_newline = 1;
+  }
 
-    ADVANCE_LINENO();
-    if (tok->decoding_state != STATE_NORMAL) {
-        if (tok->lineno > 2) {
-            tok->decoding_state = STATE_NORMAL;
-        }
-        else if (!check_coding_spec(tok->cur, strlen(tok->cur),
-                                    tok, fp_setreadl))
-        {
-            return 0;
-        }
-    }
-    /* The default encoding is UTF-8, so make sure we don't have any
-       non-UTF-8 sequences in it. */
-    if (!tok->encoding && !ensure_utf8(tok->cur, tok)) {
-        error_ret(tok);
-        return 0;
-    }
-    assert(tok->done == E_OK);
-    return tok->done == E_OK;
+  if (tok->tok_mode_stack_index && !update_fstring_expr(tok, 0)) {
+    return 0;
+  }
+
+  ADVANCE_LINENO();
+  if (tok->decoding_state != STATE_NORMAL) {
+    if (tok->lineno > 2) {
+      tok->decoding_state = STATE_NORMAL;
+    } else if (!check_coding_spec(tok->cur, strlen(tok->cur), tok,
+                                  fp_setreadl)) {
+      return 0;
+    }
+  }
+  /* The default encoding is UTF-8, so make sure we don't have any
+     non-UTF-8 sequences in it. */
+  if (!tok->encoding && !ensure_utf8(tok->cur, tok)) {
+    error_ret(tok);
+    return 0;
+  }
+  assert(tok->done == E_OK);
+  return tok->done == E_OK;
 }
 
-static int
-tok_underflow_readline(struct tok_state* tok) {
-    assert(tok->decoding_state == STATE_NORMAL);
-    assert(tok->fp == NULL && tok->input == NULL && tok->decoding_readline == NULL);
-    if (tok->start == NULL && !INSIDE_FSTRING(tok)) {
-        tok->cur = tok->inp = tok->buf;
-    }
-    if (!tok_readline_string(tok)) {
-        return 0;
-    }
-    if (tok->inp == tok->cur) {
-        tok->done = E_EOF;
-        return 0;
-    }
-    tok->implicit_newline = 0;
-    if (tok->inp[-1] != '\n') {
-        assert(tok->inp + 1 < tok->end);
-        /* Last line does not end in \n, fake one */
-        *tok->inp++ = '\n';
-        *tok->inp = '\0';
-        tok->implicit_newline = 1;
-    }
+static int tok_underflow_readline(struct tok_state *tok) {
+  assert(tok->decoding_state == STATE_NORMAL);
+  assert(tok->fp == NULL && tok->input == NULL &&
+         tok->decoding_readline == NULL);
+  if (tok->start == NULL && !INSIDE_FSTRING(tok)) {
+    tok->cur = tok->inp = tok->buf;
+  }
+  if (!tok_readline_string(tok)) {
+    return 0;
+  }
+  if (tok->inp == tok->cur) {
+    tok->done = E_EOF;
+    return 0;
+  }
+  tok->implicit_newline = 0;
+  if (tok->inp[-1] != '\n') {
+    assert(tok->inp + 1 < tok->end);
+    /* Last line does not end in \n, fake one */
+    *tok->inp++ = '\n';
+    *tok->inp = '\0';
+    tok->implicit_newline = 1;
+  }
 
-    if (tok->tok_mode_stack_index && !update_fstring_expr(tok, 0)) {
-        return 0;
-    }
+  if (tok->tok_mode_stack_index && !update_fstring_expr(tok, 0)) {
+    return 0;
+  }
 
-    ADVANCE_LINENO();
-    /* The default encoding is UTF-8, so make sure we don't have any
-       non-UTF-8 sequences in it. */
-    if (!tok->encoding && !ensure_utf8(tok->cur, tok)) {
-        error_ret(tok);
-        return 0;
-    }
-    assert(tok->done == E_OK);
-    return tok->done == E_OK;
+  ADVANCE_LINENO();
+  /* The default encoding is UTF-8, so make sure we don't have any
+     non-UTF-8 sequences in it. */
+  if (!tok->encoding && !ensure_utf8(tok->cur, tok)) {
+    error_ret(tok);
+    return 0;
+  }
+  assert(tok->done == E_OK);
+  return tok->done == E_OK;
 }
 
 #if defined(Py_DEBUG)
-static void
-print_escape(FILE *f, const char *s, Py_ssize_t size)
-{
-    if (s == NULL) {
-        fputs("NULL", f);
-        return;
-    }
-    putc('"', f);
-    while (size-- > 0) {
-        unsigned char c = *s++;
-        switch (c) {
-            case '\n': fputs("\\n", f); break;
-            case '\r': fputs("\\r", f); break;
-            case '\t': fputs("\\t", f); break;
-            case '\f': fputs("\\f", f); break;
-            case '\'': fputs("\\'", f); break;
-            case '"': fputs("\\\"", f); break;
-            default:
-                if (0x20 <= c && c <= 0x7f)
-                    putc(c, f);
-                else
-                    fprintf(f, "\\x%02x", c);
-        }
+static void print_escape(FILE *f, const char *s, Py_ssize_t size) {
+  if (s == NULL) {
+    fputs("NULL", f);
+    return;
+  }
+  putc('"', f);
+  while (size-- > 0) {
+    unsigned char c = *s++;
+    switch (c) {
+    case '\n':
+      fputs("\\n", f);
+      break;
+    case '\r':
+      fputs("\\r", f);
+      break;
+    case '\t':
+      fputs("\\t", f);
+      break;
+    case '\f':
+      fputs("\\f", f);
+      break;
+    case '\'':
+      fputs("\\'", f);
+      break;
+    case '"':
+      fputs("\\\"", f);
+      break;
+    default:
+      if (0x20 <= c && c <= 0x7f)
+        putc(c, f);
+      else
+        fprintf(f, "\\x%02x", c);
     }
-    putc('"', f);
+  }
+  putc('"', f);
 }
 #endif
 
 /* Get next char, updating state; error code goes into tok->done */
 
-static int
-tok_nextc(struct tok_state *tok)
-{
-    int rc;
-    for (;;) {
-        if (tok->cur != tok->inp) {
-            if ((unsigned int) tok->col_offset >= (unsigned int) INT_MAX) {
-                tok->done = E_COLUMNOVERFLOW;
-                return EOF;
-            }
-            tok->col_offset++;
-            return Py_CHARMASK(*tok->cur++); /* Fast path */
-        }
-        if (tok->done != E_OK) {
-            return EOF;
-        }
-        if (tok->readline) {
-            rc = tok_underflow_readline(tok);
-        }
-        else if (tok->fp == NULL) {
-            rc = tok_underflow_string(tok);
-        }
-        else if (tok->prompt != NULL) {
-            rc = tok_underflow_interactive(tok);
-        }
-        else {
-            rc = tok_underflow_file(tok);
-        }
-#if defined(Py_DEBUG)
-        if (tok->debug) {
-            fprintf(stderr, "line[%d] = ", tok->lineno);
-            print_escape(stderr, tok->cur, tok->inp - tok->cur);
-            fprintf(stderr, "  tok->done = %d\n", tok->done);
-        }
-#endif
-        if (!rc) {
-            tok->cur = tok->inp;
-            return EOF;
-        }
-        tok->line_start = tok->cur;
-
-        if (contains_null_bytes(tok->line_start, tok->inp - tok->line_start)) {
-            syntaxerror(tok, "source code cannot contain null bytes");
-            tok->cur = tok->inp;
-            return EOF;
-        }
+static int tok_nextc(struct tok_state *tok) {
+  int rc;
+  for (;;) {
+    if (tok->cur != tok->inp) {
+      if ((unsigned int)tok->col_offset >= (unsigned int)INT_MAX) {
+        tok->done = E_COLUMNOVERFLOW;
+        return EOF;
+      }
+      tok->col_offset++;
+      return Py_CHARMASK(*tok->cur++); /* Fast path */
     }
-    Py_UNREACHABLE();
-}
-
-/* Back-up one character */
-
-static void
-tok_backup(struct tok_state *tok, int c)
-{
-    if (c != EOF) {
-        if (--tok->cur < tok->buf) {
-            Py_FatalError("tokenizer beginning of buffer");
-        }
-        if ((int)(unsigned char)*tok->cur != Py_CHARMASK(c)) {
-            Py_FatalError("tok_backup: wrong character");
-        }
-        tok->col_offset--;
+    if (tok->done != E_OK) {
+      return EOF;
+    }
+    if (tok->readline) {
+      rc = tok_underflow_readline(tok);
+    } else if (tok->fp == NULL) {
+      rc = tok_underflow_string(tok);
+    } else if (tok->prompt != NULL) {
+      rc = tok_underflow_interactive(tok);
+    } else {
+      rc = tok_underflow_file(tok);
     }
-}
-
-static int
-_syntaxerror_range(struct tok_state *tok, const char *format,
-                   int col_offset, int end_col_offset,
-                   va_list vargs)
-{
-    // In release builds, we don't want to overwrite a previous error, but in debug builds we
-    // want to fail if we are not doing it so we can fix it.
-    assert(tok->done != E_ERROR);
-    if (tok->done == E_ERROR) {
-        return ERRORTOKEN;
+#if defined(Py_DEBUG)
+    if (tok->debug) {
+      fprintf(stderr, "line[%d] = ", tok->lineno);
+      print_escape(stderr, tok->cur, tok->inp - tok->cur);
+      fprintf(stderr, "  tok->done = %d\n", tok->done);
     }
-    PyObject *errmsg, *errtext, *args;
-    errmsg = PyUnicode_FromFormatV(format, vargs);
-    if (!errmsg) {
-        goto error;
+#endif
+    if (!rc) {
+      tok->cur = tok->inp;
+      return EOF;
     }
+    tok->line_start = tok->cur;
 
-    errtext = PyUnicode_DecodeUTF8(tok->line_start, tok->cur - tok->line_start,
-                                   "replace");
-    if (!errtext) {
-        goto error;
+    if (contains_null_bytes(tok->line_start, tok->inp - tok->line_start)) {
+      syntaxerror(tok, "source code cannot contain null bytes");
+      tok->cur = tok->inp;
+      return EOF;
     }
+  }
+  Py_UNREACHABLE();
+}
 
-    if (col_offset == -1) {
-        col_offset = (int)PyUnicode_GET_LENGTH(errtext);
-    }
-    if (end_col_offset == -1) {
-        end_col_offset = col_offset;
-    }
+/* Back-up one character */
 
-    Py_ssize_t line_len = strcspn(tok->line_start, "\n");
-    if (line_len != tok->cur - tok->line_start) {
-        Py_DECREF(errtext);
-        errtext = PyUnicode_DecodeUTF8(tok->line_start, line_len,
-                                       "replace");
+static void tok_backup(struct tok_state *tok, int c) {
+  if (c != EOF) {
+    if (--tok->cur < tok->buf) {
+      Py_FatalError("tokenizer beginning of buffer");
     }
-    if (!errtext) {
-        goto error;
+    if ((int)(unsigned char)*tok->cur != Py_CHARMASK(c)) {
+      Py_FatalError("tok_backup: wrong character");
     }
+    tok->col_offset--;
+  }
+}
 
-    args = Py_BuildValue("(O(OiiNii))", errmsg, tok->filename, tok->lineno,
-                         col_offset, errtext, tok->lineno, end_col_offset);
-    if (args) {
-        PyErr_SetObject(PyExc_SyntaxError, args);
-        Py_DECREF(args);
-    }
+static int _syntaxerror_range(struct tok_state *tok, const char *format,
+                              int col_offset, int end_col_offset,
+                              va_list vargs) {
+  // In release builds, we don't want to overwrite a previous error, but in
+  // debug builds we want to fail if we are not doing it so we can fix it.
+  assert(tok->done != E_ERROR);
+  if (tok->done == E_ERROR) {
+    return ERRORTOKEN;
+  }
+  PyObject *errmsg, *errtext, *args;
+  errmsg = PyUnicode_FromFormatV(format, vargs);
+  if (!errmsg) {
+    goto error;
+  }
+
+  errtext = PyUnicode_DecodeUTF8(tok->line_start, tok->cur - tok->line_start,
+                                 "replace");
+  if (!errtext) {
+    goto error;
+  }
+
+  if (col_offset == -1) {
+    col_offset = (int)PyUnicode_GET_LENGTH(errtext);
+  }
+  if (end_col_offset == -1) {
+    end_col_offset = col_offset;
+  }
+
+  Py_ssize_t line_len = strcspn(tok->line_start, "\n");
+  if (line_len != tok->cur - tok->line_start) {
+    Py_DECREF(errtext);
+    errtext = PyUnicode_DecodeUTF8(tok->line_start, line_len, "replace");
+  }
+  if (!errtext) {
+    goto error;
+  }
+
+  args = Py_BuildValue("(O(OiiNii))", errmsg, tok->filename, tok->lineno,
+                       col_offset, errtext, tok->lineno, end_col_offset);
+  if (args) {
+    PyErr_SetObject(PyExc_SyntaxError, args);
+    Py_DECREF(args);
+  }
 
 error:
-    Py_XDECREF(errmsg);
-    tok->done = E_ERROR;
-    return ERRORTOKEN;
+  Py_XDECREF(errmsg);
+  tok->done = E_ERROR;
+  return ERRORTOKEN;
 }
 
-static int
-syntaxerror(struct tok_state *tok, const char *format, ...)
-{
-    // This errors are cleaned on startup. Todo: Fix it.
-    va_list vargs;
-    va_start(vargs, format);
-    int ret = _syntaxerror_range(tok, format, -1, -1, vargs);
-    va_end(vargs);
-    return ret;
+static int syntaxerror(struct tok_state *tok, const char *format, ...) {
+  // This errors are cleaned on startup. Todo: Fix it.
+  va_list vargs;
+  va_start(vargs, format);
+  int ret = _syntaxerror_range(tok, format, -1, -1, vargs);
+  va_end(vargs);
+  return ret;
 }
 
-static int
-syntaxerror_known_range(struct tok_state *tok,
-                        int col_offset, int end_col_offset,
-                        const char *format, ...)
-{
-    va_list vargs;
-    va_start(vargs, format);
-    int ret = _syntaxerror_range(tok, format, col_offset, end_col_offset, vargs);
-    va_end(vargs);
-    return ret;
+static int syntaxerror_known_range(struct tok_state *tok, int col_offset,
+                                   int end_col_offset, const char *format,
+                                   ...) {
+  va_list vargs;
+  va_start(vargs, format);
+  int ret = _syntaxerror_range(tok, format, col_offset, end_col_offset, vargs);
+  va_end(vargs);
+  return ret;
 }
 
-static int
-indenterror(struct tok_state *tok)
-{
-    tok->done = E_TABSPACE;
-    tok->cur = tok->inp;
-    return ERRORTOKEN;
+static int indenterror(struct tok_state *tok) {
+  tok->done = E_TABSPACE;
+  tok->cur = tok->inp;
+  return ERRORTOKEN;
 }
 
-static int
-parser_warn(struct tok_state *tok, PyObject *category, const char *format, ...)
-{
-    if (!tok->report_warnings) {
-        return 0;
-    }
-
-    PyObject *errmsg;
-    va_list vargs;
-    va_start(vargs, format);
-    errmsg = PyUnicode_FromFormatV(format, vargs);
-    va_end(vargs);
-    if (!errmsg) {
-        goto error;
-    }
-
-    if (PyErr_WarnExplicitObject(category, errmsg, tok->filename,
-                                 tok->lineno, NULL, NULL) < 0) {
-        if (PyErr_ExceptionMatches(category)) {
-            /* Replace the DeprecationWarning exception with a SyntaxError
-               to get a more accurate error report */
-            PyErr_Clear();
-            syntaxerror(tok, "%U", errmsg);
-        }
-        goto error;
-    }
-    Py_DECREF(errmsg);
+static int parser_warn(struct tok_state *tok, PyObject *category,
+                       const char *format, ...) {
+  if (!tok->report_warnings) {
     return 0;
+  }
+
+  PyObject *errmsg;
+  va_list vargs;
+  va_start(vargs, format);
+  errmsg = PyUnicode_FromFormatV(format, vargs);
+  va_end(vargs);
+  if (!errmsg) {
+    goto error;
+  }
+
+  if (PyErr_WarnExplicitObject(category, errmsg, tok->filename, tok->lineno,
+                               NULL, NULL) < 0) {
+    if (PyErr_ExceptionMatches(category)) {
+      /* Replace the DeprecationWarning exception with a SyntaxError
+         to get a more accurate error report */
+      PyErr_Clear();
+      syntaxerror(tok, "%U", errmsg);
+    }
+    goto error;
+  }
+  Py_DECREF(errmsg);
+  return 0;
 
 error:
-    Py_XDECREF(errmsg);
-    tok->done = E_ERROR;
-    return -1;
+  Py_XDECREF(errmsg);
+  tok->done = E_ERROR;
+  return -1;
 }
 
-static int
-warn_invalid_escape_sequence(struct tok_state *tok, int first_invalid_escape_char)
-{
-    if (!tok->report_warnings) {
-        return 0;
-    }
-
-    PyObject *msg = PyUnicode_FromFormat(
-        "invalid escape sequence '\\%c'",
-        (char) first_invalid_escape_char
-    );
+static int warn_invalid_escape_sequence(struct tok_state *tok,
+                                        int first_invalid_escape_char) {
+  if (!tok->report_warnings) {
+    return 0;
+  }
 
-    if (msg == NULL) {
-        return -1;
-    }
+  PyObject *msg = PyUnicode_FromFormat("invalid escape sequence '\\%c'",
+                                       (char)first_invalid_escape_char);
 
-    if (PyErr_WarnExplicitObject(PyExc_SyntaxWarning, msg, tok->filename,
-                                 tok->lineno, NULL, NULL) < 0) {
-        Py_DECREF(msg);
+  if (msg == NULL) {
+    return -1;
+  }
 
-        if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
-            /* Replace the SyntaxWarning exception with a SyntaxError
-               to get a more accurate error report */
-            PyErr_Clear();
-            return syntaxerror(tok, "invalid escape sequence '\\%c'", (char) first_invalid_escape_char);
-        }
+  if (PyErr_WarnExplicitObject(PyExc_SyntaxWarning, msg, tok->filename,
+                               tok->lineno, NULL, NULL) < 0) {
+    Py_DECREF(msg);
 
-        return -1;
+    if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
+      /* Replace the SyntaxWarning exception with a SyntaxError
+         to get a more accurate error report */
+      PyErr_Clear();
+      return syntaxerror(tok, "invalid escape sequence '\\%c'",
+                         (char)first_invalid_escape_char);
     }
 
-    Py_DECREF(msg);
-    return 0;
+    return -1;
+  }
+
+  Py_DECREF(msg);
+  return 0;
 }
 
-static int
-lookahead(struct tok_state *tok, const char *test)
-{
-    const char *s = test;
-    int res = 0;
-    while (1) {
-        int c = tok_nextc(tok);
-        if (*s == 0) {
-            res = !is_potential_identifier_char(c);
-        }
-        else if (c == *s) {
-            s++;
-            continue;
-        }
+static int lookahead(struct tok_state *tok, const char *test) {
+  const char *s = test;
+  int res = 0;
+  while (1) {
+    int c = tok_nextc(tok);
+    if (*s == 0) {
+      res = !is_potential_identifier_char(c);
+    } else if (c == *s) {
+      s++;
+      continue;
+    }
 
-        tok_backup(tok, c);
-        while (s != test) {
-            tok_backup(tok, *--s);
-        }
-        return res;
+    tok_backup(tok, c);
+    while (s != test) {
+      tok_backup(tok, *--s);
     }
+    return res;
+  }
 }
 
-static int
-verify_end_of_number(struct tok_state *tok, int c, const char *kind) {
-    if (tok->tok_extra_tokens) {
-        // When we are parsing extra tokens, we don't want to emit warnings
-        // about invalid literals, because we want to be a bit more liberal.
-        return 1;
-    }
-    /* Emit a deprecation warning only if the numeric literal is immediately
-     * followed by one of keywords which can occur after a numeric literal
-     * in valid code: "and", "else", "for", "if", "in", "is" and "or".
-     * It allows to gradually deprecate existing valid code without adding
-     * warning before error in most cases of invalid numeric literal (which
-     * would be confusing and break existing tests).
-     * Raise a syntax error with slightly better message than plain
-     * "invalid syntax" if the numeric literal is immediately followed by
-     * other keyword or identifier.
-     */
-    int r = 0;
-    if (c == 'a') {
-        r = lookahead(tok, "nd");
-    }
-    else if (c == 'e') {
-        r = lookahead(tok, "lse");
-    }
-    else if (c == 'f') {
-        r = lookahead(tok, "or");
-    }
-    else if (c == 'i') {
-        int c2 = tok_nextc(tok);
-        if (c2 == 'f' || c2 == 'n' || c2 == 's') {
-            r = 1;
-        }
-        tok_backup(tok, c2);
-    }
-    else if (c == 'o') {
-        r = lookahead(tok, "r");
-    }
-    else if (c == 'n') {
-        r = lookahead(tok, "ot");
-    }
-    if (r) {
-        tok_backup(tok, c);
-        if (parser_warn(tok, PyExc_SyntaxWarning,
-                "invalid %s literal", kind))
-        {
-            return 0;
-        }
-        tok_nextc(tok);
+static int verify_end_of_number(struct tok_state *tok, int c,
+                                const char *kind) {
+  if (tok->tok_extra_tokens) {
+    // When we are parsing extra tokens, we don't want to emit warnings
+    // about invalid literals, because we want to be a bit more liberal.
+    return 1;
+  }
+  /* Emit a deprecation warning only if the numeric literal is immediately
+   * followed by one of keywords which can occur after a numeric literal
+   * in valid code: "and", "else", "for", "if", "in", "is" and "or".
+   * It allows to gradually deprecate existing valid code without adding
+   * warning before error in most cases of invalid numeric literal (which
+   * would be confusing and break existing tests).
+   * Raise a syntax error with slightly better message than plain
+   * "invalid syntax" if the numeric literal is immediately followed by
+   * other keyword or identifier.
+   */
+  int r = 0;
+  if (c == 'a') {
+    r = lookahead(tok, "nd");
+  } else if (c == 'e') {
+    r = lookahead(tok, "lse");
+  } else if (c == 'f') {
+    r = lookahead(tok, "or");
+  } else if (c == 'i') {
+    int c2 = tok_nextc(tok);
+    if (c2 == 'f' || c2 == 'n' || c2 == 's') {
+      r = 1;
+    }
+    tok_backup(tok, c2);
+  } else if (c == 'o') {
+    r = lookahead(tok, "r");
+  } else if (c == 'n') {
+    r = lookahead(tok, "ot");
+  }
+  if (r) {
+    tok_backup(tok, c);
+    if (parser_warn(tok, PyExc_SyntaxWarning, "invalid %s literal", kind)) {
+      return 0;
     }
-    else /* In future releases, only error will remain. */
+    tok_nextc(tok);
+  } else /* In future releases, only error will remain. */
     if (c < 128 && is_potential_identifier_char(c)) {
-        tok_backup(tok, c);
-        syntaxerror(tok, "invalid %s literal", kind);
-        return 0;
+      tok_backup(tok, c);
+      syntaxerror(tok, "invalid %s literal", kind);
+      return 0;
     }
-    return 1;
+  return 1;
 }
 
 /* Verify that the identifier follows PEP 3131.
    All identifier strings are guaranteed to be "ready" unicode objects.
  */
-static int
-verify_identifier(struct tok_state *tok)
-{
-    if (tok->tok_extra_tokens) {
-        return 1;
-    }
-    PyObject *s;
-    if (tok->decoding_erred)
-        return 0;
-    s = PyUnicode_DecodeUTF8(tok->start, tok->cur - tok->start, NULL);
-    if (s == NULL) {
-        if (PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {
-            tok->done = E_DECODE;
-        }
-        else {
-            tok->done = E_ERROR;
-        }
-        return 0;
+static int verify_identifier(struct tok_state *tok) {
+  if (tok->tok_extra_tokens) {
+    return 1;
+  }
+  PyObject *s;
+  if (tok->decoding_erred)
+    return 0;
+  s = PyUnicode_DecodeUTF8(tok->start, tok->cur - tok->start, NULL);
+  if (s == NULL) {
+    if (PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {
+      tok->done = E_DECODE;
+    } else {
+      tok->done = E_ERROR;
     }
-    Py_ssize_t invalid = _PyUnicode_ScanIdentifier(s);
-    if (invalid < 0) {
-        Py_DECREF(s);
+    return 0;
+  }
+  Py_ssize_t invalid = _PyUnicode_ScanIdentifier(s);
+  if (invalid < 0) {
+    Py_DECREF(s);
+    tok->done = E_ERROR;
+    return 0;
+  }
+  assert(PyUnicode_GET_LENGTH(s) > 0);
+  if (invalid < PyUnicode_GET_LENGTH(s)) {
+    Py_UCS4 ch = PyUnicode_READ_CHAR(s, invalid);
+    if (invalid + 1 < PyUnicode_GET_LENGTH(s)) {
+      /* Determine the offset in UTF-8 encoded input */
+      Py_SETREF(s, PyUnicode_Substring(s, 0, invalid + 1));
+      if (s != NULL) {
+        Py_SETREF(s, PyUnicode_AsUTF8String(s));
+      }
+      if (s == NULL) {
         tok->done = E_ERROR;
         return 0;
-    }
-    assert(PyUnicode_GET_LENGTH(s) > 0);
-    if (invalid < PyUnicode_GET_LENGTH(s)) {
-        Py_UCS4 ch = PyUnicode_READ_CHAR(s, invalid);
-        if (invalid + 1 < PyUnicode_GET_LENGTH(s)) {
-            /* Determine the offset in UTF-8 encoded input */
-            Py_SETREF(s, PyUnicode_Substring(s, 0, invalid + 1));
-            if (s != NULL) {
-                Py_SETREF(s, PyUnicode_AsUTF8String(s));
-            }
-            if (s == NULL) {
-                tok->done = E_ERROR;
-                return 0;
-            }
-            tok->cur = (char *)tok->start + PyBytes_GET_SIZE(s);
-        }
-        Py_DECREF(s);
-        if (Py_UNICODE_ISPRINTABLE(ch)) {
-            syntaxerror(tok, "invalid character '%c' (U+%04X)", ch, ch);
-        }
-        else {
-            syntaxerror(tok, "invalid non-printable character U+%04X", ch);
-        }
-        return 0;
+      }
+      tok->cur = (char *)tok->start + PyBytes_GET_SIZE(s);
     }
     Py_DECREF(s);
-    return 1;
-}
-
-static int
-tok_decimal_tail(struct tok_state *tok)
-{
-    int c;
-
-    while (1) {
-        do {
-            c = tok_nextc(tok);
-        } while (isdigit(c));
-        if (c != '_') {
-            break;
-        }
-        c = tok_nextc(tok);
-        if (!isdigit(c)) {
-            tok_backup(tok, c);
-            syntaxerror(tok, "invalid decimal literal");
-            return 0;
-        }
-    }
-    return c;
-}
-
-
-static inline int
-tok_continuation_line(struct tok_state *tok) {
-    int c = tok_nextc(tok);
-    if (c == '\r') {
-        c = tok_nextc(tok);
-    }
-    if (c != '\n') {
-        tok->done = E_LINECONT;
-        return -1;
-    }
-    c = tok_nextc(tok);
-    if (c == EOF) {
-        tok->done = E_EOF;
-        tok->cur = tok->inp;
-        return -1;
+    if (Py_UNICODE_ISPRINTABLE(ch)) {
+      syntaxerror(tok, "invalid character '%c' (U+%04X)", ch, ch);
     } else {
-        tok_backup(tok, c);
+      syntaxerror(tok, "invalid non-printable character U+%04X", ch);
     }
-    return c;
+    return 0;
+  }
+  Py_DECREF(s);
+  return 1;
 }
 
-static int
-type_comment_token_setup(struct tok_state *tok, struct token *token, int type, int col_offset,
-                         int end_col_offset, const char *start, const char *end)
-{
-    token->level = tok->level;
-    token->lineno = token->end_lineno = tok->lineno;
-    token->col_offset = col_offset;
-    token->end_col_offset = end_col_offset;
-    token->start = start;
-    token->end = end;
-    return type;
-}
+static int tok_decimal_tail(struct tok_state *tok) {
+  int c;
 
-static int
-token_setup(struct tok_state *tok, struct token *token, int type, const char *start, const char *end)
-{
-    assert((start == NULL && end == NULL) || (start != NULL && end != NULL));
-    token->level = tok->level;
-    if (ISSTRINGLIT(type)) {
-        token->lineno = tok->first_lineno;
-    }
-    else {
-        token->lineno = tok->lineno;
+  while (1) {
+    do {
+      c = tok_nextc(tok);
+    } while (isdigit(c));
+    if (c != '_') {
+      break;
     }
-    token->end_lineno = tok->lineno;
-    token->col_offset = token->end_col_offset = -1;
-    token->start = start;
-    token->end = end;
-
-    if (start != NULL && end != NULL) {
-        token->col_offset = tok->starting_col_offset;
-        token->end_col_offset = tok->col_offset;
+    c = tok_nextc(tok);
+    if (!isdigit(c)) {
+      tok_backup(tok, c);
+      syntaxerror(tok, "invalid decimal literal");
+      return 0;
     }
-    return type;
+  }
+  return c;
 }
 
-
-static int
-tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct token *token)
-{
-    int c;
-    int blankline, nonascii;
-
-    const char *p_start = NULL;
-    const char *p_end = NULL;
-  nextline:
-    tok->start = NULL;
-    tok->starting_col_offset = -1;
-    blankline = 0;
-
-
-    /* Get indentation level */
-    if (tok->atbol) {
-        int col = 0;
-        int altcol = 0;
-        tok->atbol = 0;
-        int cont_line_col = 0;
-        for (;;) {
-            c = tok_nextc(tok);
-            if (c == ' ') {
-                col++, altcol++;
-            }
-            else if (c == '\t') {
-                col = (col / tok->tabsize + 1) * tok->tabsize;
-                altcol = (altcol / ALTTABSIZE + 1) * ALTTABSIZE;
-            }
-            else if (c == '\014')  {/* Control-L (formfeed) */
-                col = altcol = 0; /* For Emacs users */
-            }
-            else if (c == '\\') {
-                // Indentation cannot be split over multiple physical lines
-                // using backslashes. This means that if we found a backslash
-                // preceded by whitespace, **the first one we find** determines
-                // the level of indentation of whatever comes next.
-                cont_line_col = cont_line_col ? cont_line_col : col;
-                if ((c = tok_continuation_line(tok)) == -1) {
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-            }
-            else {
-                break;
-            }
-        }
-        tok_backup(tok, c);
-        if (c == '#' || c == '\n' || c == '\r') {
-            /* Lines with only whitespace and/or comments
-               shouldn't affect the indentation and are
-               not passed to the parser as NEWLINE tokens,
-               except *totally* empty lines in interactive
-               mode, which signal the end of a command group. */
-            if (col == 0 && c == '\n' && tok->prompt != NULL) {
-                blankline = 0; /* Let it through */
-            }
-            else if (tok->prompt != NULL && tok->lineno == 1) {
-                /* In interactive mode, if the first line contains
-                   only spaces and/or a comment, let it through. */
-                blankline = 0;
-                col = altcol = 0;
-            }
-            else {
-                blankline = 1; /* Ignore completely */
-            }
-            /* We can't jump back right here since we still
-               may need to skip to the end of a comment */
-        }
-        if (!blankline && tok->level == 0) {
-            col = cont_line_col ? cont_line_col : col;
-            altcol = cont_line_col ? cont_line_col : altcol;
-            if (col == tok->indstack[tok->indent]) {
-                /* No change */
-                if (altcol != tok->altindstack[tok->indent]) {
-                    return MAKE_TOKEN(indenterror(tok));
-                }
-            }
-            else if (col > tok->indstack[tok->indent]) {
-                /* Indent -- always one */
-                if (tok->indent+1 >= MAXINDENT) {
-                    tok->done = E_TOODEEP;
-                    tok->cur = tok->inp;
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-                if (altcol <= tok->altindstack[tok->indent]) {
-                    return MAKE_TOKEN(indenterror(tok));
-                }
-                tok->pendin++;
-                tok->indstack[++tok->indent] = col;
-                tok->altindstack[tok->indent] = altcol;
-            }
-            else /* col < tok->indstack[tok->indent] */ {
-                /* Dedent -- any number, must be consistent */
-                while (tok->indent > 0 &&
-                    col < tok->indstack[tok->indent]) {
-                    tok->pendin--;
-                    tok->indent--;
-                }
-                if (col != tok->indstack[tok->indent]) {
-                    tok->done = E_DEDENT;
-                    tok->cur = tok->inp;
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-                if (altcol != tok->altindstack[tok->indent]) {
-                    return MAKE_TOKEN(indenterror(tok));
-                }
-            }
-        }
-    }
-
-    tok->start = tok->cur;
-    tok->starting_col_offset = tok->col_offset;
-
-    /* Return pending indents/dedents */
-   if (tok->pendin != 0) {
-        if (tok->pendin < 0) {
-            if (tok->tok_extra_tokens) {
-                p_start = tok->cur;
-                p_end = tok->cur;
-            }
-            tok->pendin++;
-            return MAKE_TOKEN(DEDENT);
-        }
-        else {
-            if (tok->tok_extra_tokens) {
-                p_start = tok->buf;
-                p_end = tok->cur;
-            }
-            tok->pendin--;
-            return MAKE_TOKEN(INDENT);
+static inline int tok_continuation_line(struct tok_state *tok) {
+  int c = tok_nextc(tok);
+  if (c == '\r') {
+    c = tok_nextc(tok);
+  }
+  if (c != '\n') {
+    tok->done = E_LINECONT;
+    return -1;
+  }
+  c = tok_nextc(tok);
+  if (c == EOF) {
+    tok->done = E_EOF;
+    tok->cur = tok->inp;
+    return -1;
+  } else {
+    tok_backup(tok, c);
+  }
+  return c;
+}
+
+static int type_comment_token_setup(struct tok_state *tok, struct token *token,
+                                    int type, int col_offset,
+                                    int end_col_offset, const char *start,
+                                    const char *end) {
+  token->level = tok->level;
+  token->lineno = token->end_lineno = tok->lineno;
+  token->col_offset = col_offset;
+  token->end_col_offset = end_col_offset;
+  token->start = start;
+  token->end = end;
+  return type;
+}
+
+static int token_setup(struct tok_state *tok, struct token *token, int type,
+                       const char *start, const char *end) {
+  assert((start == NULL && end == NULL) || (start != NULL && end != NULL));
+  token->level = tok->level;
+  if (ISSTRINGLIT(type)) {
+    token->lineno = tok->first_lineno;
+  } else {
+    token->lineno = tok->lineno;
+  }
+  token->end_lineno = tok->lineno;
+  token->col_offset = token->end_col_offset = -1;
+  token->start = start;
+  token->end = end;
+
+  if (start != NULL && end != NULL) {
+    token->col_offset = tok->starting_col_offset;
+    token->end_col_offset = tok->col_offset;
+  }
+  return type;
+}
+
+static int tok_get_normal_mode(struct tok_state *tok,
+                               tokenizer_mode *current_tok,
+                               struct token *token) {
+  int c;
+  int blankline, nonascii;
+
+  const char *p_start = NULL;
+  const char *p_end = NULL;
+nextline:
+  tok->start = NULL;
+  tok->starting_col_offset = -1;
+  blankline = 0;
+
+  /* Get indentation level */
+  if (tok->atbol) {
+    int col = 0;
+    int altcol = 0;
+    tok->atbol = 0;
+    int cont_line_col = 0;
+    for (;;) {
+      c = tok_nextc(tok);
+      if (c == ' ') {
+        col++, altcol++;
+      } else if (c == '\t') {
+        col = (col / tok->tabsize + 1) * tok->tabsize;
+        altcol = (altcol / ALTTABSIZE + 1) * ALTTABSIZE;
+      } else if (c == '\014') { /* Control-L (formfeed) */
+        col = altcol = 0;       /* For Emacs users */
+      } else if (c == '\\') {
+        // Indentation cannot be split over multiple physical lines
+        // using backslashes. This means that if we found a backslash
+        // preceded by whitespace, **the first one we find** determines
+        // the level of indentation of whatever comes next.
+        cont_line_col = cont_line_col ? cont_line_col : col;
+        if ((c = tok_continuation_line(tok)) == -1) {
+          return MAKE_TOKEN(ERRORTOKEN);
         }
+      } else {
+        break;
+      }
     }
+    tok_backup(tok, c);
+    if (c == '#' || c == '\n' || c == '\r') {
+      /* Lines with only whitespace and/or comments
+         shouldn't affect the indentation and are
+         not passed to the parser as NEWLINE tokens,
+         except *totally* empty lines in interactive
+         mode, which signal the end of a command group. */
+      if (col == 0 && c == '\n' && tok->prompt != NULL) {
+        blankline = 0; /* Let it through */
+      } else if (tok->prompt != NULL && tok->lineno == 1) {
+        /* In interactive mode, if the first line contains
+           only spaces and/or a comment, let it through. */
+        blankline = 0;
+        col = altcol = 0;
+      } else {
+        blankline = 1; /* Ignore completely */
+      }
+      /* We can't jump back right here since we still
+         may need to skip to the end of a comment */
+    }
+    if (!blankline && tok->level == 0) {
+      col = cont_line_col ? cont_line_col : col;
+      altcol = cont_line_col ? cont_line_col : altcol;
+      if (col == tok->indstack[tok->indent]) {
+        /* No change */
+        if (altcol != tok->altindstack[tok->indent]) {
+          return MAKE_TOKEN(indenterror(tok));
+        }
+      } else if (col > tok->indstack[tok->indent]) {
+        /* Indent -- always one */
+        if (tok->indent + 1 >= MAXINDENT) {
+          tok->done = E_TOODEEP;
+          tok->cur = tok->inp;
+          return MAKE_TOKEN(ERRORTOKEN);
+        }
+        if (altcol <= tok->altindstack[tok->indent]) {
+          return MAKE_TOKEN(indenterror(tok));
+        }
+        tok->pendin++;
+        tok->indstack[++tok->indent] = col;
+        tok->altindstack[tok->indent] = altcol;
+      } else /* col < tok->indstack[tok->indent] */ {
+        /* Dedent -- any number, must be consistent */
+        while (tok->indent > 0 && col < tok->indstack[tok->indent]) {
+          tok->pendin--;
+          tok->indent--;
+        }
+        if (col != tok->indstack[tok->indent]) {
+          tok->done = E_DEDENT;
+          tok->cur = tok->inp;
+          return MAKE_TOKEN(ERRORTOKEN);
+        }
+        if (altcol != tok->altindstack[tok->indent]) {
+          return MAKE_TOKEN(indenterror(tok));
+        }
+      }
+    }
+  }
+
+  tok->start = tok->cur;
+  tok->starting_col_offset = tok->col_offset;
+
+  /* Return pending indents/dedents */
+  if (tok->pendin != 0) {
+    if (tok->pendin < 0) {
+      if (tok->tok_extra_tokens) {
+        p_start = tok->cur;
+        p_end = tok->cur;
+      }
+      tok->pendin++;
+      return MAKE_TOKEN(DEDENT);
+    } else {
+      if (tok->tok_extra_tokens) {
+        p_start = tok->buf;
+        p_end = tok->cur;
+      }
+      tok->pendin--;
+      return MAKE_TOKEN(INDENT);
+    }
+  }
+
+  /* Peek ahead at the next character */
+  c = tok_nextc(tok);
+  tok_backup(tok, c);
+  /* Check if we are closing an async function */
+  if (tok->async_def &&
+      !blankline
+      /* Due to some implementation artifacts of type comments,
+       * a TYPE_COMMENT at the start of a function won't set an
+       * indentation level and it will produce a NEWLINE after it.
+       * To avoid spuriously ending an async function due to this,
+       * wait until we have some non-newline char in front of us. */
+      && c != '\n' &&
+      tok->level == 0
+      /* There was a NEWLINE after ASYNC DEF,
+         so we're past the signature. */
+      && tok->async_def_nl
+      /* Current indentation level is less than where
+         the async function was defined */
+      && tok->async_def_indent >= tok->indent) {
+    tok->async_def = 0;
+    tok->async_def_indent = 0;
+    tok->async_def_nl = 0;
+  }
 
-    /* Peek ahead at the next character */
+again:
+  tok->start = NULL;
+  /* Skip spaces */
+  do {
     c = tok_nextc(tok);
-    tok_backup(tok, c);
-    /* Check if we are closing an async function */
-    if (tok->async_def
-        && !blankline
-        /* Due to some implementation artifacts of type comments,
-         * a TYPE_COMMENT at the start of a function won't set an
-         * indentation level and it will produce a NEWLINE after it.
-         * To avoid spuriously ending an async function due to this,
-         * wait until we have some non-newline char in front of us. */
-        && c != '\n'
-        && tok->level == 0
-        /* There was a NEWLINE after ASYNC DEF,
-           so we're past the signature. */
-        && tok->async_def_nl
-        /* Current indentation level is less than where
-           the async function was defined */
-        && tok->async_def_indent >= tok->indent)
-    {
-        tok->async_def = 0;
-        tok->async_def_indent = 0;
-        tok->async_def_nl = 0;
-    }
-
- again:
-    tok->start = NULL;
-    /* Skip spaces */
-    do {
-        c = tok_nextc(tok);
-    } while (c == ' ' || c == '\t' || c == '\014');
+  } while (c == ' ' || c == '\t' || c == '\014');
 
-    /* Set start of current token */
-    tok->start = tok->cur == NULL ? NULL : tok->cur - 1;
-    tok->starting_col_offset = tok->col_offset - 1;
+  /* Set start of current token */
+  tok->start = tok->cur == NULL ? NULL : tok->cur - 1;
+  tok->starting_col_offset = tok->col_offset - 1;
 
-    /* Skip comment, unless it's a type comment */
-    if (c == '#') {
+  /* Skip comment, unless it's a type comment */
+  if (c == '#') {
 
-        const char* p = NULL;
-        const char *prefix, *type_start;
-        int current_starting_col_offset;
+    const char *p = NULL;
+    const char *prefix, *type_start;
+    int current_starting_col_offset;
 
-        while (c != EOF && c != '\n' && c != '\r') {
-            c = tok_nextc(tok);
-        }
-
-        if (tok->tok_extra_tokens) {
-            p = tok->start;
-        }
-
-        if (tok->type_comments) {
-            p = tok->start;
-            current_starting_col_offset = tok->starting_col_offset;
-            prefix = type_comment_prefix;
-            while (*prefix && p < tok->cur) {
-                if (*prefix == ' ') {
-                    while (*p == ' ' || *p == '\t') {
-                        p++;
-                        current_starting_col_offset++;
-                    }
-                } else if (*prefix == *p) {
-                    p++;
-                    current_starting_col_offset++;
-                } else {
-                    break;
-                }
-
-                prefix++;
-            }
+    while (c != EOF && c != '\n' && c != '\r') {
+      c = tok_nextc(tok);
+    }
 
-            /* This is a type comment if we matched all of type_comment_prefix. */
-            if (!*prefix) {
-                int is_type_ignore = 1;
-                // +6 in order to skip the word 'ignore'
-                const char *ignore_end = p + 6;
-                const int ignore_end_col_offset = current_starting_col_offset + 6;
-                tok_backup(tok, c);  /* don't eat the newline or EOF */
-
-                type_start = p;
-
-                /* A TYPE_IGNORE is "type: ignore" followed by the end of the token
-                 * or anything ASCII and non-alphanumeric. */
-                is_type_ignore = (
-                    tok->cur >= ignore_end && memcmp(p, "ignore", 6) == 0
-                    && !(tok->cur > ignore_end
-                         && ((unsigned char)ignore_end[0] >= 128 || Py_ISALNUM(ignore_end[0]))));
-
-                if (is_type_ignore) {
-                    p_start = ignore_end;
-                    p_end = tok->cur;
-
-                    /* If this type ignore is the only thing on the line, consume the newline also. */
-                    if (blankline) {
-                        tok_nextc(tok);
-                        tok->atbol = 1;
-                    }
-                    return MAKE_TYPE_COMMENT_TOKEN(TYPE_IGNORE, ignore_end_col_offset, tok->col_offset);
-                } else {
-                    p_start = type_start;
-                    p_end = tok->cur;
-                    return MAKE_TYPE_COMMENT_TOKEN(TYPE_COMMENT, current_starting_col_offset, tok->col_offset);
-                }
-            }
+    if (tok->tok_extra_tokens) {
+      p = tok->start;
+    }
+
+    if (tok->type_comments) {
+      p = tok->start;
+      current_starting_col_offset = tok->starting_col_offset;
+      prefix = type_comment_prefix;
+      while (*prefix && p < tok->cur) {
+        if (*prefix == ' ') {
+          while (*p == ' ' || *p == '\t') {
+            p++;
+            current_starting_col_offset++;
+          }
+        } else if (*prefix == *p) {
+          p++;
+          current_starting_col_offset++;
+        } else {
+          break;
+        }
+
+        prefix++;
+      }
+
+      /* This is a type comment if we matched all of type_comment_prefix. */
+      if (!*prefix) {
+        int is_type_ignore = 1;
+        // +6 in order to skip the word 'ignore'
+        const char *ignore_end = p + 6;
+        const int ignore_end_col_offset = current_starting_col_offset + 6;
+        tok_backup(tok, c); /* don't eat the newline or EOF */
+
+        type_start = p;
+
+        /* A TYPE_IGNORE is "type: ignore" followed by the end of the token
+         * or anything ASCII and non-alphanumeric. */
+        is_type_ignore =
+            (tok->cur >= ignore_end && memcmp(p, "ignore", 6) == 0 &&
+             !(tok->cur > ignore_end && ((unsigned char)ignore_end[0] >= 128 ||
+                                         Py_ISALNUM(ignore_end[0]))));
+
+        if (is_type_ignore) {
+          p_start = ignore_end;
+          p_end = tok->cur;
+
+          /* If this type ignore is the only thing on the line, consume the
+           * newline also. */
+          if (blankline) {
+            tok_nextc(tok);
+            tok->atbol = 1;
+          }
+          return MAKE_TYPE_COMMENT_TOKEN(TYPE_IGNORE, ignore_end_col_offset,
+                                         tok->col_offset);
+        } else {
+          p_start = type_start;
+          p_end = tok->cur;
+          return MAKE_TYPE_COMMENT_TOKEN(
+              TYPE_COMMENT, current_starting_col_offset, tok->col_offset);
         }
-        if (tok->tok_extra_tokens) {
-            tok_backup(tok, c);  /* don't eat the newline or EOF */
-            p_start = p;
-            p_end = tok->cur;
-            tok->comment_newline = blankline;
-            return MAKE_TOKEN(COMMENT);
+      }
+    }
+    if (tok->tok_extra_tokens) {
+      tok_backup(tok, c); /* don't eat the newline or EOF */
+      p_start = p;
+      p_end = tok->cur;
+      tok->comment_newline = blankline;
+      return MAKE_TOKEN(COMMENT);
+    }
+  }
+
+  if (tok->done == E_INTERACT_STOP) {
+    return MAKE_TOKEN(ENDMARKER);
+  }
+
+  /* Check for EOF and errors now */
+  if (c == EOF) {
+    if (tok->level) {
+      return MAKE_TOKEN(ERRORTOKEN);
+    }
+    return MAKE_TOKEN(tok->done == E_EOF ? ENDMARKER : ERRORTOKEN);
+  }
+
+  /* Identifier (most frequent token!) */
+  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;
+    while (1) {
+      if (!(saw_b || saw_u || saw_f) && (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_b || saw_u || saw_r || saw_f) && (c == 'u' || c == 'U')) {
+        saw_u = 1;
+      }
+      /* ur"" and ru"" are not supported */
+      else if (!(saw_r || saw_u) && (c == 'r' || c == 'R')) {
+        saw_r = 1;
+      } else if (!(saw_f || saw_b || saw_u) && (c == 'f' || c == 'F')) {
+        saw_f = 1;
+      } else {
+        break;
+      }
+      c = tok_nextc(tok);
+      if (c == '"' || c == '\'') {
+        if (saw_f) {
+          goto f_string_quote;
         }
+        goto letter_quote;
+      }
     }
-
-    if (tok->done == E_INTERACT_STOP) {
-        return MAKE_TOKEN(ENDMARKER);
+    while (is_potential_identifier_char(c)) {
+      if (c >= 128) {
+        nonascii = 1;
+      }
+      c = tok_nextc(tok);
     }
-
-    /* Check for EOF and errors now */
-    if (c == EOF) {
-        if (tok->level) {
-            return MAKE_TOKEN(ERRORTOKEN);
-        }
-        return MAKE_TOKEN(tok->done == E_EOF ? ENDMARKER : ERRORTOKEN);
+    tok_backup(tok, c);
+    if (nonascii && !verify_identifier(tok)) {
+      return MAKE_TOKEN(ERRORTOKEN);
     }
 
-    /* Identifier (most frequent token!) */
-    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;
-        while (1) {
-            if (!(saw_b || saw_u || saw_f) && (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_b || saw_u || saw_r || saw_f)
-                     && (c == 'u'|| c == 'U')) {
-                saw_u = 1;
-            }
-            /* ur"" and ru"" are not supported */
-            else if (!(saw_r || saw_u) && (c == 'r' || c == 'R')) {
-                saw_r = 1;
-            }
-            else if (!(saw_f || saw_b || saw_u) && (c == 'f' || c == 'F')) {
-                saw_f = 1;
-            }
-            else {
-                break;
-            }
-            c = tok_nextc(tok);
-            if (c == '"' || c == '\'') {
-                if (saw_f) {
-                    goto f_string_quote;
-                }
-                goto letter_quote;
-            }
-        }
-        while (is_potential_identifier_char(c)) {
-            if (c >= 128) {
-                nonascii = 1;
-            }
-            c = tok_nextc(tok);
-        }
-        tok_backup(tok, c);
-        if (nonascii && !verify_identifier(tok)) {
-            return MAKE_TOKEN(ERRORTOKEN);
-        }
+    p_start = tok->start;
+    p_end = tok->cur;
 
-        p_start = tok->start;
-        p_end = tok->cur;
+    /* async/await parsing block. */
+    if (tok->cur - tok->start == 5 && tok->start[0] == 'a') {
+      /* May be an 'async' or 'await' token.  For Python 3.7 or
+         later we recognize them unconditionally.  For Python
+         3.5 or 3.6 we recognize 'async' in front of 'def', and
+         either one inside of 'async def'.  (Technically we
+         shouldn't recognize these at all for 3.4 or earlier,
+         but there's no *valid* Python 3.4 code that would be
+         rejected, and async functions will be rejected in a
+         later phase.) */
+      if (!tok->async_hacks || tok->async_def) {
+        /* Always recognize the keywords. */
+        if (memcmp(tok->start, "async", 5) == 0) {
+          return MAKE_TOKEN(ASYNC);
+        }
+        if (memcmp(tok->start, "await", 5) == 0) {
+          return MAKE_TOKEN(AWAIT);
+        }
+      } else if (memcmp(tok->start, "async", 5) == 0) {
+        /* The current token is 'async'.
+           Look ahead one token to see if that is 'def'. */
+
+        struct tok_state ahead_tok;
+        struct token ahead_token;
+        _PyToken_Init(&ahead_token);
+        int ahead_tok_kind;
+
+        memcpy(&ahead_tok, tok, sizeof(ahead_tok));
+        ahead_tok_kind =
+            tok_get_normal_mode(&ahead_tok, current_tok, &ahead_token);
+
+        if (ahead_tok_kind == NAME && ahead_tok.cur - ahead_tok.start == 3 &&
+            memcmp(ahead_tok.start, "def", 3) == 0) {
+          /* The next token is going to be 'def', so instead of
+             returning a plain NAME token, return ASYNC. */
+          tok->async_def_indent = tok->indent;
+          tok->async_def = 1;
+          _PyToken_Free(&ahead_token);
+          return MAKE_TOKEN(ASYNC);
+        }
+        _PyToken_Free(&ahead_token);
+      }
+    }
+
+    return MAKE_TOKEN(NAME);
+  }
+
+  if (c == '\r') {
+    c = tok_nextc(tok);
+  }
 
-        /* async/await parsing block. */
-        if (tok->cur - tok->start == 5 && tok->start[0] == 'a') {
-            /* May be an 'async' or 'await' token.  For Python 3.7 or
-               later we recognize them unconditionally.  For Python
-               3.5 or 3.6 we recognize 'async' in front of 'def', and
-               either one inside of 'async def'.  (Technically we
-               shouldn't recognize these at all for 3.4 or earlier,
-               but there's no *valid* Python 3.4 code that would be
-               rejected, and async functions will be rejected in a
-               later phase.) */
-            if (!tok->async_hacks || tok->async_def) {
-                /* Always recognize the keywords. */
-                if (memcmp(tok->start, "async", 5) == 0) {
-                    return MAKE_TOKEN(ASYNC);
-                }
-                if (memcmp(tok->start, "await", 5) == 0) {
-                    return MAKE_TOKEN(AWAIT);
-                }
-            }
-            else if (memcmp(tok->start, "async", 5) == 0) {
-                /* The current token is 'async'.
-                   Look ahead one token to see if that is 'def'. */
-
-                struct tok_state ahead_tok;
-                struct token ahead_token;
-                _PyToken_Init(&ahead_token);
-                int ahead_tok_kind;
-
-                memcpy(&ahead_tok, tok, sizeof(ahead_tok));
-                ahead_tok_kind = tok_get_normal_mode(&ahead_tok,
-                                                     current_tok,
-                                                     &ahead_token);
-
-                if (ahead_tok_kind == NAME
-                    && ahead_tok.cur - ahead_tok.start == 3
-                    && memcmp(ahead_tok.start, "def", 3) == 0)
-                {
-                    /* The next token is going to be 'def', so instead of
-                       returning a plain NAME token, return ASYNC. */
-                    tok->async_def_indent = tok->indent;
-                    tok->async_def = 1;
-                    _PyToken_Free(&ahead_token);
-                    return MAKE_TOKEN(ASYNC);
-                }
-                _PyToken_Free(&ahead_token);
-            }
+  /* Newline */
+  if (c == '\n') {
+    tok->atbol = 1;
+    if (blankline || tok->level > 0) {
+      if (tok->tok_extra_tokens) {
+        if (tok->comment_newline) {
+          tok->comment_newline = 0;
         }
-
-        return MAKE_TOKEN(NAME);
+        p_start = tok->start;
+        p_end = tok->cur;
+        return MAKE_TOKEN(NL);
+      }
+      goto nextline;
     }
-
-    if (c == '\r') {
-        c = tok_nextc(tok);
+    if (tok->comment_newline && tok->tok_extra_tokens) {
+      tok->comment_newline = 0;
+      p_start = tok->start;
+      p_end = tok->cur;
+      return MAKE_TOKEN(NL);
+    }
+    p_start = tok->start;
+    p_end = tok->cur - 1; /* Leave '\n' out of the string */
+    tok->cont_line = 0;
+    if (tok->async_def) {
+      /* We're somewhere inside an 'async def' function, and
+         we've encountered a NEWLINE after its signature. */
+      tok->async_def_nl = 1;
     }
+    return MAKE_TOKEN(NEWLINE);
+  }
 
-    /* Newline */
-    if (c == '\n') {
-        tok->atbol = 1;
-        if (blankline || tok->level > 0) {
-            if (tok->tok_extra_tokens) {
-                if (tok->comment_newline) {
-                    tok->comment_newline = 0;
-                }
-                p_start = tok->start;
-                p_end = tok->cur;
-                return MAKE_TOKEN(NL);
-            }
-            goto nextline;
-        }
-        if (tok->comment_newline && tok->tok_extra_tokens) {
-            tok->comment_newline = 0;
-            p_start = tok->start;
-            p_end = tok->cur;
-            return MAKE_TOKEN(NL);
-        }
+  /* Period or number starting with period? */
+  if (c == '.') {
+    c = tok_nextc(tok);
+    if (isdigit(c)) {
+      goto fraction;
+    } else if (c == '.') {
+      c = tok_nextc(tok);
+      if (c == '.') {
         p_start = tok->start;
-        p_end = tok->cur - 1; /* Leave '\n' out of the string */
-        tok->cont_line = 0;
-        if (tok->async_def) {
-            /* We're somewhere inside an 'async def' function, and
-               we've encountered a NEWLINE after its signature. */
-            tok->async_def_nl = 1;
-        }
-        return MAKE_TOKEN(NEWLINE);
+        p_end = tok->cur;
+        return MAKE_TOKEN(ELLIPSIS);
+      } else {
+        tok_backup(tok, c);
+      }
+      tok_backup(tok, '.');
+    } else {
+      tok_backup(tok, c);
     }
-
-    /* Period or number starting with period? */
-    if (c == '.') {
+    p_start = tok->start;
+    p_end = tok->cur;
+    return MAKE_TOKEN(DOT);
+  }
+
+  /* Number */
+  if (isdigit(c)) {
+    if (c == '0') {
+      /* Hex, octal or binary -- maybe. */
+      c = tok_nextc(tok);
+      if (c == 'x' || c == 'X') {
+        /* Hex */
         c = tok_nextc(tok);
-        if (isdigit(c)) {
-            goto fraction;
-        } else if (c == '.') {
+        do {
+          if (c == '_') {
             c = tok_nextc(tok);
-            if (c == '.') {
-                p_start = tok->start;
-                p_end = tok->cur;
-                return MAKE_TOKEN(ELLIPSIS);
-            }
-            else {
-                tok_backup(tok, c);
-            }
-            tok_backup(tok, '.');
-        }
-        else {
+          }
+          if (!isxdigit(c)) {
             tok_backup(tok, c);
-        }
-        p_start = tok->start;
-        p_end = tok->cur;
-        return MAKE_TOKEN(DOT);
-    }
-
-    /* Number */
-    if (isdigit(c)) {
-        if (c == '0') {
-            /* Hex, octal or binary -- maybe. */
+            return MAKE_TOKEN(syntaxerror(tok, "invalid hexadecimal literal"));
+          }
+          do {
             c = tok_nextc(tok);
-            if (c == 'x' || c == 'X') {
-                /* Hex */
-                c = tok_nextc(tok);
-                do {
-                    if (c == '_') {
-                        c = tok_nextc(tok);
-                    }
-                    if (!isxdigit(c)) {
-                        tok_backup(tok, c);
-                        return MAKE_TOKEN(syntaxerror(tok, "invalid hexadecimal literal"));
-                    }
-                    do {
-                        c = tok_nextc(tok);
-                    } while (isxdigit(c));
-                } while (c == '_');
-                if (!verify_end_of_number(tok, c, "hexadecimal")) {
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-            }
-            else if (c == 'o' || c == 'O') {
-                /* Octal */
-                c = tok_nextc(tok);
-                do {
-                    if (c == '_') {
-                        c = tok_nextc(tok);
-                    }
-                    if (c < '0' || c >= '8') {
-                        if (isdigit(c)) {
-                            return MAKE_TOKEN(syntaxerror(tok,
-                                    "invalid digit '%c' in octal literal", c));
-                        }
-                        else {
-                            tok_backup(tok, c);
-                            return MAKE_TOKEN(syntaxerror(tok, "invalid octal literal"));
-                        }
-                    }
-                    do {
-                        c = tok_nextc(tok);
-                    } while ('0' <= c && c < '8');
-                } while (c == '_');
-                if (isdigit(c)) {
-                    return MAKE_TOKEN(syntaxerror(tok,
-                            "invalid digit '%c' in octal literal", c));
-                }
-                if (!verify_end_of_number(tok, c, "octal")) {
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-            }
-            else if (c == 'b' || c == 'B') {
-                /* Binary */
-                c = tok_nextc(tok);
-                do {
-                    if (c == '_') {
-                        c = tok_nextc(tok);
-                    }
-                    if (c != '0' && c != '1') {
-                        if (isdigit(c)) {
-                            return MAKE_TOKEN(syntaxerror(tok, "invalid digit '%c' in binary literal", c));
-                        }
-                        else {
-                            tok_backup(tok, c);
-                            return MAKE_TOKEN(syntaxerror(tok, "invalid binary literal"));
-                        }
-                    }
-                    do {
-                        c = tok_nextc(tok);
-                    } while (c == '0' || c == '1');
-                } while (c == '_');
-                if (isdigit(c)) {
-                    return MAKE_TOKEN(syntaxerror(tok, "invalid digit '%c' in binary literal", c));
-                }
-                if (!verify_end_of_number(tok, c, "binary")) {
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-            }
-            else {
-                int nonzero = 0;
-                /* maybe old-style octal; c is first char of it */
-                /* in any case, allow '0' as a literal */
-                while (1) {
-                    if (c == '_') {
-                        c = tok_nextc(tok);
-                        if (!isdigit(c)) {
-                            tok_backup(tok, c);
-                            return MAKE_TOKEN(syntaxerror(tok, "invalid decimal literal"));
-                        }
-                    }
-                    if (c != '0') {
-                        break;
-                    }
-                    c = tok_nextc(tok);
-                }
-                char* zeros_end = tok->cur;
-                if (isdigit(c)) {
-                    nonzero = 1;
-                    c = tok_decimal_tail(tok);
-                    if (c == 0) {
-                        return MAKE_TOKEN(ERRORTOKEN);
-                    }
-                }
-                if (c == '.') {
-                    c = tok_nextc(tok);
-                    goto fraction;
-                }
-                else if (c == 'e' || c == 'E') {
-                    goto exponent;
-                }
-                else if (c == 'j' || c == 'J') {
-                    goto imaginary;
-                }
-                else if (nonzero && !tok->tok_extra_tokens) {
-                    /* Old-style octal: now disallowed. */
-                    tok_backup(tok, c);
-                    return MAKE_TOKEN(syntaxerror_known_range(
-                            tok, (int)(tok->start + 1 - tok->line_start),
-                            (int)(zeros_end - tok->line_start),
-                            "leading zeros in decimal integer "
-                            "literals are not permitted; "
-                            "use an 0o prefix for octal integers"));
-                }
-                if (!verify_end_of_number(tok, c, "decimal")) {
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-            }
+          } while (isxdigit(c));
+        } while (c == '_');
+        if (!verify_end_of_number(tok, c, "hexadecimal")) {
+          return MAKE_TOKEN(ERRORTOKEN);
         }
-        else {
-            /* Decimal */
-            c = tok_decimal_tail(tok);
-            if (c == 0) {
-                return MAKE_TOKEN(ERRORTOKEN);
-            }
-            {
-                /* Accept floating point numbers. */
-                if (c == '.') {
-                    c = tok_nextc(tok);
-        fraction:
-                    /* Fraction */
-                    if (isdigit(c)) {
-                        c = tok_decimal_tail(tok);
-                        if (c == 0) {
-                            return MAKE_TOKEN(ERRORTOKEN);
-                        }
-                    }
-                }
-                if (c == 'e' || c == 'E') {
-                    int e;
-                  exponent:
-                    e = c;
-                    /* Exponent part */
-                    c = tok_nextc(tok);
-                    if (c == '+' || c == '-') {
-                        c = tok_nextc(tok);
-                        if (!isdigit(c)) {
-                            tok_backup(tok, c);
-                            return MAKE_TOKEN(syntaxerror(tok, "invalid decimal literal"));
-                        }
-                    } else if (!isdigit(c)) {
-                        tok_backup(tok, c);
-                        if (!verify_end_of_number(tok, e, "decimal")) {
-                            return MAKE_TOKEN(ERRORTOKEN);
-                        }
-                        tok_backup(tok, e);
-                        p_start = tok->start;
-                        p_end = tok->cur;
-                        return MAKE_TOKEN(NUMBER);
-                    }
-                    c = tok_decimal_tail(tok);
-                    if (c == 0) {
-                        return MAKE_TOKEN(ERRORTOKEN);
-                    }
-                }
-                if (c == 'j' || c == 'J') {
-                    /* Imaginary part */
-        imaginary:
-                    c = tok_nextc(tok);
-                    if (!verify_end_of_number(tok, c, "imaginary")) {
-                        return MAKE_TOKEN(ERRORTOKEN);
-                    }
-                }
-                else if (!verify_end_of_number(tok, c, "decimal")) {
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-            }
-        }
-        tok_backup(tok, c);
-        p_start = tok->start;
-        p_end = tok->cur;
-        return MAKE_TOKEN(NUMBER);
-    }
-
-  f_string_quote:
-    if (((tolower(*tok->start) == 'f' || tolower(*tok->start) == 'r') && (c == '\'' || c == '"'))) {
-        int quote = c;
-        int quote_size = 1;             /* 1 or 3 */
-
-        /* Nodes of type STRING, especially multi line strings
-           must be handled differently in order to get both
-           the starting line number and the column offset right.
-           (cf. issue 16806) */
-        tok->first_lineno = tok->lineno;
-        tok->multi_line_start = tok->line_start;
-
-        /* 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 {
-                // TODO: Check this
-                tok_backup(tok, after_after_quote);
-                tok_backup(tok, after_quote);
+      } else if (c == 'o' || c == 'O') {
+        /* Octal */
+        c = tok_nextc(tok);
+        do {
+          if (c == '_') {
+            c = tok_nextc(tok);
+          }
+          if (c < '0' || c >= '8') {
+            if (isdigit(c)) {
+              return MAKE_TOKEN(
+                  syntaxerror(tok, "invalid digit '%c' in octal literal", c));
+            } else {
+              tok_backup(tok, c);
+              return MAKE_TOKEN(syntaxerror(tok, "invalid octal literal"));
             }
+          }
+          do {
+            c = tok_nextc(tok);
+          } while ('0' <= c && c < '8');
+        } while (c == '_');
+        if (isdigit(c)) {
+          return MAKE_TOKEN(
+              syntaxerror(tok, "invalid digit '%c' in octal literal", c));
         }
-        if (after_quote != quote) {
-            tok_backup(tok, after_quote);
-        }
-
-
-        p_start = tok->start;
-        p_end = tok->cur;
-        if (tok->tok_mode_stack_index + 1 >= MAXFSTRINGLEVEL) {
-            return MAKE_TOKEN(syntaxerror(tok, "too many nested f-strings"));
-        }
-        tokenizer_mode *the_current_tok = TOK_NEXT_MODE(tok);
-        the_current_tok->kind = TOK_FSTRING_MODE;
-        the_current_tok->f_string_quote = quote;
-        the_current_tok->f_string_quote_size = quote_size;
-        the_current_tok->f_string_start = tok->start;
-        the_current_tok->f_string_multi_line_start = tok->line_start;
-        the_current_tok->f_string_line_start = tok->lineno;
-        the_current_tok->f_string_start_offset = -1;
-        the_current_tok->f_string_multi_line_start_offset = -1;
-        the_current_tok->last_expr_buffer = NULL;
-        the_current_tok->last_expr_size = 0;
-        the_current_tok->last_expr_end = -1;
-        the_current_tok->f_string_debug = 0;
-
-        switch (*tok->start) {
-            case 'F':
-            case 'f':
-                the_current_tok->f_string_raw = tolower(*(tok->start + 1)) == 'r';
-                break;
-            case 'R':
-            case 'r':
-                the_current_tok->f_string_raw = 1;
-                break;
-            default:
-                Py_UNREACHABLE();
+        if (!verify_end_of_number(tok, c, "octal")) {
+          return MAKE_TOKEN(ERRORTOKEN);
         }
-
-        the_current_tok->curly_bracket_depth = 0;
-        the_current_tok->curly_bracket_expr_start_depth = -1;
-        return MAKE_TOKEN(FSTRING_START);
-    }
-
-  letter_quote:
-    /* String */
-    if (c == '\'' || c == '"') {
-        int quote = c;
-        int quote_size = 1;             /* 1 or 3 */
-        int end_quote_size = 0;
-
-        /* Nodes of type STRING, especially multi line strings
-           must be handled differently in order to get both
-           the starting line number and the column offset right.
-           (cf. issue 16806) */
-        tok->first_lineno = tok->lineno;
-        tok->multi_line_start = tok->line_start;
-
-        /* Find the quote size and start of string */
+      } else if (c == 'b' || c == 'B') {
+        /* Binary */
         c = tok_nextc(tok);
-        if (c == quote) {
+        do {
+          if (c == '_') {
             c = tok_nextc(tok);
-            if (c == quote) {
-                quote_size = 3;
-            }
-            else {
-                end_quote_size = 1;     /* empty string found */
+          }
+          if (c != '0' && c != '1') {
+            if (isdigit(c)) {
+              return MAKE_TOKEN(
+                  syntaxerror(tok, "invalid digit '%c' in binary literal", c));
+            } else {
+              tok_backup(tok, c);
+              return MAKE_TOKEN(syntaxerror(tok, "invalid binary literal"));
             }
+          }
+          do {
+            c = tok_nextc(tok);
+          } while (c == '0' || c == '1');
+        } while (c == '_');
+        if (isdigit(c)) {
+          return MAKE_TOKEN(
+              syntaxerror(tok, "invalid digit '%c' in binary literal", c));
         }
-        if (c != quote) {
-            tok_backup(tok, c);
+        if (!verify_end_of_number(tok, c, "binary")) {
+          return MAKE_TOKEN(ERRORTOKEN);
         }
-
-        /* Get rest of string */
-        while (end_quote_size != quote_size) {
+      } else {
+        int nonzero = 0;
+        /* maybe old-style octal; c is first char of it */
+        /* in any case, allow '0' as a literal */
+        while (1) {
+          if (c == '_') {
             c = tok_nextc(tok);
-            if (tok->done == E_ERROR) {
-                return MAKE_TOKEN(ERRORTOKEN);
-            }
-            if (tok->done == E_DECODE) {
-                break;
+            if (!isdigit(c)) {
+              tok_backup(tok, c);
+              return MAKE_TOKEN(syntaxerror(tok, "invalid decimal literal"));
             }
-            if (c == EOF || (quote_size == 1 && c == '\n')) {
-                assert(tok->multi_line_start != NULL);
-                // shift the tok_state's location into
-                // the start of string, and report the error
-                // from the initial quote character
-                tok->cur = (char *)tok->start;
-                tok->cur++;
-                tok->line_start = tok->multi_line_start;
-                int start = tok->lineno;
-                tok->lineno = tok->first_lineno;
-
-                if (INSIDE_FSTRING(tok)) {
-                    /* When we are in an f-string, before raising the
-                     * unterminated string literal error, check whether
-                     * does the initial quote matches with f-strings quotes
-                     * and if it is, then this must be a missing '}' token
-                     * so raise the proper error */
-                    tokenizer_mode *the_current_tok = TOK_GET_MODE(tok);
-                    if (the_current_tok->f_string_quote == quote &&
-                        the_current_tok->f_string_quote_size == quote_size) {
-                        return MAKE_TOKEN(syntaxerror(tok, "f-string: expecting '}'", start));
-                    }
-                }
-
-                if (quote_size == 3) {
-                    syntaxerror(tok, "unterminated triple-quoted string literal"
-                                     " (detected at line %d)", start);
-                    if (c != '\n') {
-                        tok->done = E_EOFS;
-                    }
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-                else {
-                    syntaxerror(tok, "unterminated string literal (detected at"
-                                     " line %d)", start);
-                    if (c != '\n') {
-                        tok->done = E_EOLS;
-                    }
-                    return MAKE_TOKEN(ERRORTOKEN);
-                }
-            }
-            if (c == quote) {
-                end_quote_size += 1;
-            }
-            else {
-                end_quote_size = 0;
-                if (c == '\\') {
-                    c = tok_nextc(tok);  /* skip escaped char */
-                    if (c == '\r') {
-                        c = tok_nextc(tok);
-                    }
-                }
-            }
-        }
-
-        p_start = tok->start;
-        p_end = tok->cur;
-        return MAKE_TOKEN(STRING);
-    }
-
-    /* Line continuation */
-    if (c == '\\') {
-        if ((c = tok_continuation_line(tok)) == -1) {
-            return MAKE_TOKEN(ERRORTOKEN);
-        }
-        tok->cont_line = 1;
-        goto again; /* Read next line */
-    }
-
-    /* Punctuation character */
-    int is_punctuation = (c == ':' || c == '}' || c == '!' || c == '{');
-    if (is_punctuation && INSIDE_FSTRING(tok) && INSIDE_FSTRING_EXPR(current_tok)) {
-        /* This code block gets executed before the curly_bracket_depth is incremented
-         * by the `{` case, so for ensuring that we are on the 0th level, we need
-         * to adjust it manually */
-        int cursor = current_tok->curly_bracket_depth - (c != '{');
-        if (cursor == 0 && !update_fstring_expr(tok, c)) {
-            return MAKE_TOKEN(ENDMARKER);
+          }
+          if (c != '0') {
+            break;
+          }
+          c = tok_nextc(tok);
         }
-        if (cursor == 0 && c != '{' && set_fstring_expr(tok, token, c)) {
+        char *zeros_end = tok->cur;
+        if (isdigit(c)) {
+          nonzero = 1;
+          c = tok_decimal_tail(tok);
+          if (c == 0) {
             return MAKE_TOKEN(ERRORTOKEN);
+          }
+        }
+        if (c == '.') {
+          c = tok_nextc(tok);
+          goto fraction;
+        } else if (c == 'e' || c == 'E') {
+          goto exponent;
+        } else if (c == 'j' || c == 'J') {
+          goto imaginary;
+        } else if (nonzero && !tok->tok_extra_tokens) {
+          /* Old-style octal: now disallowed. */
+          tok_backup(tok, c);
+          return MAKE_TOKEN(syntaxerror_known_range(
+              tok, (int)(tok->start + 1 - tok->line_start),
+              (int)(zeros_end - tok->line_start),
+              "leading zeros in decimal integer "
+              "literals are not permitted; "
+              "use an 0o prefix for octal integers"));
+        }
+        if (!verify_end_of_number(tok, c, "decimal")) {
+          return MAKE_TOKEN(ERRORTOKEN);
+        }
+      }
+    } else {
+      /* Decimal */
+      c = tok_decimal_tail(tok);
+      if (c == 0) {
+        return MAKE_TOKEN(ERRORTOKEN);
+      }
+      {
+        /* Accept floating point numbers. */
+        if (c == '.') {
+          c = tok_nextc(tok);
+        fraction:
+          /* Fraction */
+          if (isdigit(c)) {
+            c = tok_decimal_tail(tok);
+            if (c == 0) {
+              return MAKE_TOKEN(ERRORTOKEN);
+            }
+          }
         }
-
-        if (c == ':' && cursor == current_tok->curly_bracket_expr_start_depth) {
-            current_tok->kind = TOK_FSTRING_MODE;
-            p_start = tok->start;
-            p_end = tok->cur;
-            return MAKE_TOKEN(_PyToken_OneChar(c));
-        }
-    }
-
-    /* Check for two-character token */
-    {
-        int c2 = tok_nextc(tok);
-        int current_token = _PyToken_TwoChars(c, c2);
-        if (current_token != OP) {
-            int c3 = tok_nextc(tok);
-            int current_token3 = _PyToken_ThreeChars(c, c2, c3);
-            if (current_token3 != OP) {
-                current_token = current_token3;
+        if (c == 'e' || c == 'E') {
+          int e;
+        exponent:
+          e = c;
+          /* Exponent part */
+          c = tok_nextc(tok);
+          if (c == '+' || c == '-') {
+            c = tok_nextc(tok);
+            if (!isdigit(c)) {
+              tok_backup(tok, c);
+              return MAKE_TOKEN(syntaxerror(tok, "invalid decimal literal"));
             }
-            else {
-                tok_backup(tok, c3);
+          } else if (!isdigit(c)) {
+            tok_backup(tok, c);
+            if (!verify_end_of_number(tok, e, "decimal")) {
+              return MAKE_TOKEN(ERRORTOKEN);
             }
+            tok_backup(tok, e);
             p_start = tok->start;
             p_end = tok->cur;
-            return MAKE_TOKEN(current_token);
-        }
-        tok_backup(tok, c2);
-    }
-
-    /* Keep track of parentheses nesting level */
-    switch (c) {
-    case '(':
-    case '[':
-    case '{':
-        if (tok->level >= MAXLEVEL) {
-            return MAKE_TOKEN(syntaxerror(tok, "too many nested parentheses"));
-        }
-        tok->parenstack[tok->level] = c;
-        tok->parenlinenostack[tok->level] = tok->lineno;
-        tok->parencolstack[tok->level] = (int)(tok->start - tok->line_start);
-        tok->level++;
-        if (INSIDE_FSTRING(tok)) {
-            current_tok->curly_bracket_depth++;
-        }
-        break;
-    case ')':
-    case ']':
-    case '}':
-        if (INSIDE_FSTRING(tok) && !current_tok->curly_bracket_depth && c == '}') {
-            return MAKE_TOKEN(syntaxerror(tok, "f-string: single '}' is not allowed"));
-        }
-        if (!tok->tok_extra_tokens && !tok->level) {
-            return MAKE_TOKEN(syntaxerror(tok, "unmatched '%c'", c));
-        }
-        if (tok->level > 0) {
-            tok->level--;
-            int opening = tok->parenstack[tok->level];
-            if (!tok->tok_extra_tokens && !((opening == '(' && c == ')') ||
-                                            (opening == '[' && c == ']') ||
-                                            (opening == '{' && c == '}'))) {
-                /* If the opening bracket belongs to an f-string's expression
-                part (e.g. f"{)}") and the closing bracket is an arbitrary
-                nested expression, then instead of matching a different
-                syntactical construct with it; we'll throw an unmatched
-                parentheses error. */
-                if (INSIDE_FSTRING(tok) && opening == '{') {
-                    assert(current_tok->curly_bracket_depth >= 0);
-                    int previous_bracket = current_tok->curly_bracket_depth - 1;
-                    if (previous_bracket == current_tok->curly_bracket_expr_start_depth) {
-                        return MAKE_TOKEN(syntaxerror(tok, "f-string: unmatched '%c'", c));
-                    }
-                }
-                if (tok->parenlinenostack[tok->level] != tok->lineno) {
-                    return MAKE_TOKEN(syntaxerror(tok,
-                            "closing parenthesis '%c' does not match "
-                            "opening parenthesis '%c' on line %d",
-                            c, opening, tok->parenlinenostack[tok->level]));
-                }
-                else {
-                    return MAKE_TOKEN(syntaxerror(tok,
-                            "closing parenthesis '%c' does not match "
-                            "opening parenthesis '%c'",
-                            c, opening));
-                }
-            }
+            return MAKE_TOKEN(NUMBER);
+          }
+          c = tok_decimal_tail(tok);
+          if (c == 0) {
+            return MAKE_TOKEN(ERRORTOKEN);
+          }
         }
-
-        if (INSIDE_FSTRING(tok)) {
-            current_tok->curly_bracket_depth--;
-            if (c == '}' && current_tok->curly_bracket_depth == current_tok->curly_bracket_expr_start_depth) {
-                current_tok->curly_bracket_expr_start_depth--;
-                current_tok->kind = TOK_FSTRING_MODE;
-                current_tok->f_string_debug = 0;
-            }
+        if (c == 'j' || c == 'J') {
+          /* Imaginary part */
+        imaginary:
+          c = tok_nextc(tok);
+          if (!verify_end_of_number(tok, c, "imaginary")) {
+            return MAKE_TOKEN(ERRORTOKEN);
+          }
+        } else if (!verify_end_of_number(tok, c, "decimal")) {
+          return MAKE_TOKEN(ERRORTOKEN);
         }
-        break;
-    default:
-        break;
-    }
-
-    if (!Py_UNICODE_ISPRINTABLE(c)) {
-        return MAKE_TOKEN(syntaxerror(tok, "invalid non-printable character U+%04X", c));
-    }
-
-    if( c == '=' && INSIDE_FSTRING_EXPR(current_tok)) {
-        current_tok->f_string_debug = 1;
+      }
     }
-
-    /* Punctuation character */
+    tok_backup(tok, c);
     p_start = tok->start;
     p_end = tok->cur;
-    return MAKE_TOKEN(_PyToken_OneChar(c));
-}
-
-static int
-tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct token *token)
-{
-    const char *p_start = NULL;
-    const char *p_end = NULL;
-    int end_quote_size = 0;
-    int unicode_escape = 0;
-
-    tok->start = tok->cur;
+    return MAKE_TOKEN(NUMBER);
+  }
+
+f_string_quote:
+  if (((tolower(*tok->start) == 'f' || tolower(*tok->start) == 'r') &&
+       (c == '\'' || c == '"'))) {
+    int quote = c;
+    int quote_size = 1; /* 1 or 3 */
+
+    /* Nodes of type STRING, especially multi line strings
+       must be handled differently in order to get both
+       the starting line number and the column offset right.
+       (cf. issue 16806) */
     tok->first_lineno = tok->lineno;
-    tok->starting_col_offset = tok->col_offset;
-
-    // If we start with a bracket, we defer to the normal mode as there is nothing for us to tokenize
-    // before it.
-    int start_char = tok_nextc(tok);
-    if (start_char == '{') {
-        int peek1 = tok_nextc(tok);
-        tok_backup(tok, peek1);
-        tok_backup(tok, start_char);
-        if (peek1 != '{') {
-            current_tok->curly_bracket_expr_start_depth++;
-            if (current_tok->curly_bracket_expr_start_depth >= MAX_EXPR_NESTING) {
-                return MAKE_TOKEN(syntaxerror(tok, "f-string: expressions nested too deeply"));
-            }
-            TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE;
-            return tok_get_normal_mode(tok, current_tok, token);
-        }
-    }
-    else {
-        tok_backup(tok, start_char);
-    }
+    tok->multi_line_start = tok->line_start;
 
-    // Check if we are at the end of the string
-    for (int i = 0; i < current_tok->f_string_quote_size; i++) {
-        int quote = tok_nextc(tok);
-        if (quote != current_tok->f_string_quote) {
-            tok_backup(tok, quote);
-            goto f_string_middle;
-        }
+    /* 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 {
+        // TODO: Check this
+        tok_backup(tok, after_after_quote);
+        tok_backup(tok, after_quote);
+      }
     }
-
-    if (current_tok->last_expr_buffer != NULL) {
-        PyMem_Free(current_tok->last_expr_buffer);
-        current_tok->last_expr_buffer = NULL;
-        current_tok->last_expr_size = 0;
-        current_tok->last_expr_end = -1;
+    if (after_quote != quote) {
+      tok_backup(tok, after_quote);
     }
 
     p_start = tok->start;
     p_end = tok->cur;
-    tok->tok_mode_stack_index--;
-    return MAKE_TOKEN(FSTRING_END);
+    if (tok->tok_mode_stack_index + 1 >= MAXFSTRINGLEVEL) {
+      return MAKE_TOKEN(syntaxerror(tok, "too many nested f-strings"));
+    }
+    tokenizer_mode *the_current_tok = TOK_NEXT_MODE(tok);
+    the_current_tok->kind = TOK_FSTRING_MODE;
+    the_current_tok->f_string_quote = quote;
+    the_current_tok->f_string_quote_size = quote_size;
+    the_current_tok->f_string_start = tok->start;
+    the_current_tok->f_string_multi_line_start = tok->line_start;
+    the_current_tok->f_string_line_start = tok->lineno;
+    the_current_tok->f_string_start_offset = -1;
+    the_current_tok->f_string_multi_line_start_offset = -1;
+    the_current_tok->last_expr_buffer = NULL;
+    the_current_tok->last_expr_size = 0;
+    the_current_tok->last_expr_end = -1;
+    the_current_tok->f_string_debug = 0;
+
+    switch (*tok->start) {
+    case 'F':
+    case 'f':
+      the_current_tok->f_string_raw = tolower(*(tok->start + 1)) == 'r';
+      break;
+    case 'R':
+    case 'r':
+      the_current_tok->f_string_raw = 1;
+      break;
+    default:
+      Py_UNREACHABLE();
+    }
 
-f_string_middle:
+    the_current_tok->curly_bracket_depth = 0;
+    the_current_tok->curly_bracket_expr_start_depth = -1;
+    return MAKE_TOKEN(FSTRING_START);
+  }
 
-    // TODO: This is a bit of a hack, but it works for now. We need to find a better way to handle
-    // this.
-    tok->multi_line_start = tok->line_start;
-    while (end_quote_size != current_tok->f_string_quote_size) {
-        int c = tok_nextc(tok);
-        if (tok->done == E_ERROR) {
-            return MAKE_TOKEN(ERRORTOKEN);
-        }
-        int in_format_spec = (
-                current_tok->last_expr_end != -1
-                &&
-                INSIDE_FSTRING_EXPR(current_tok)
-        );
-
-       if (c == EOF || (current_tok->f_string_quote_size == 1 && c == '\n')) {
-            if (tok->decoding_erred) {
-                return MAKE_TOKEN(ERRORTOKEN);
-            }
+letter_quote:
+  /* String */
+  if (c == '\'' || c == '"') {
+    int quote = c;
+    int quote_size = 1; /* 1 or 3 */
+    int end_quote_size = 0;
 
-            // If we are in a format spec and we found a newline,
-            // it means that the format spec ends here and we should
-            // return to the regular mode.
-            if (in_format_spec && c == '\n') {
-                tok_backup(tok, c);
-                TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE;
-                p_start = tok->start;
-                p_end = tok->cur;
-                return MAKE_TOKEN(FSTRING_MIDDLE);
-            }
+    /* Nodes of type STRING, especially multi line strings
+       must be handled differently in order to get both
+       the starting line number and the column offset right.
+       (cf. issue 16806) */
+    tok->first_lineno = tok->lineno;
+    tok->multi_line_start = tok->line_start;
 
-            assert(tok->multi_line_start != NULL);
-            // shift the tok_state's location into
-            // the start of string, and report the error
-            // from the initial quote character
-            tok->cur = (char *)current_tok->f_string_start;
-            tok->cur++;
-            tok->line_start = current_tok->f_string_multi_line_start;
-            int start = tok->lineno;
-
-            tokenizer_mode *the_current_tok = TOK_GET_MODE(tok);
-            tok->lineno = the_current_tok->f_string_line_start;
-
-            if (current_tok->f_string_quote_size == 3) {
-                syntaxerror(tok,
-                            "unterminated triple-quoted f-string literal"
-                            " (detected at line %d)", start);
-                if (c != '\n') {
-                    tok->done = E_EOFS;
-                }
-                return MAKE_TOKEN(ERRORTOKEN);
-            }
-            else {
-                return MAKE_TOKEN(syntaxerror(tok,
-                                    "unterminated f-string literal (detected at"
-                                    " line %d)", start));
-            }
-        }
+    /* 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) {
+        return MAKE_TOKEN(ERRORTOKEN);
+      }
+      if (tok->done == E_DECODE) {
+        break;
+      }
+      if (c == EOF || (quote_size == 1 && c == '\n')) {
+        assert(tok->multi_line_start != NULL);
+        // shift the tok_state's location into
+        // the start of string, and report the error
+        // from the initial quote character
+        tok->cur = (char *)tok->start;
+        tok->cur++;
+        tok->line_start = tok->multi_line_start;
+        int start = tok->lineno;
+        tok->lineno = tok->first_lineno;
 
-        if (c == current_tok->f_string_quote) {
-            end_quote_size += 1;
-            continue;
+        if (INSIDE_FSTRING(tok)) {
+          /* When we are in an f-string, before raising the
+           * unterminated string literal error, check whether
+           * does the initial quote matches with f-strings quotes
+           * and if it is, then this must be a missing '}' token
+           * so raise the proper error */
+          tokenizer_mode *the_current_tok = TOK_GET_MODE(tok);
+          if (the_current_tok->f_string_quote == quote &&
+              the_current_tok->f_string_quote_size == quote_size) {
+            return MAKE_TOKEN(
+                syntaxerror(tok, "f-string: expecting '}'", start));
+          }
+        }
+
+        if (quote_size == 3) {
+          syntaxerror(tok,
+                      "unterminated triple-quoted string literal"
+                      " (detected at line %d)",
+                      start);
+          if (c != '\n') {
+            tok->done = E_EOFS;
+          }
+          return MAKE_TOKEN(ERRORTOKEN);
         } else {
-            end_quote_size = 0;
-        }
-
-        if (c == '{') {
-            int peek = tok_nextc(tok);
-            if (peek != '{' || in_format_spec) {
-                tok_backup(tok, peek);
-                tok_backup(tok, c);
-                current_tok->curly_bracket_expr_start_depth++;
-                if (current_tok->curly_bracket_expr_start_depth >= MAX_EXPR_NESTING) {
-                    return MAKE_TOKEN(syntaxerror(tok, "f-string: expressions nested too deeply"));
-                }
-                TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE;
-                p_start = tok->start;
-                p_end = tok->cur;
-            } else {
-                p_start = tok->start;
-                p_end = tok->cur - 1;
-            }
-            return MAKE_TOKEN(FSTRING_MIDDLE);
-        } else if (c == '}') {
-            if (unicode_escape) {
-                p_start = tok->start;
-                p_end = tok->cur;
-                return MAKE_TOKEN(FSTRING_MIDDLE);
-            }
-            int peek = tok_nextc(tok);
-
-            // The tokenizer can only be in the format spec if we have already completed the expression
-            // scanning (indicated by the end of the expression being set) and we are not at the top level
-            // of the bracket stack (-1 is the top level). Since format specifiers can't legally use double
-            // brackets, we can bypass it here.
-            if (peek == '}' && !in_format_spec) {
-                p_start = tok->start;
-                p_end = tok->cur - 1;
-            } else {
-                tok_backup(tok, peek);
-                tok_backup(tok, c);
-                TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE;
-                p_start = tok->start;
-                p_end = tok->cur;
-            }
-            return MAKE_TOKEN(FSTRING_MIDDLE);
-        } else if (c == '\\') {
-            int peek = tok_nextc(tok);
-            if (peek == '\r') {
-                peek = tok_nextc(tok);
-            }
-            // Special case when the backslash is right before a curly
-            // brace. We have to restore and return the control back
-            // to the loop for the next iteration.
-            if (peek == '{' || peek == '}') {
-                if (!current_tok->f_string_raw) {
-                    if (warn_invalid_escape_sequence(tok, peek)) {
-                        return MAKE_TOKEN(ERRORTOKEN);
-                    }
-                }
-                tok_backup(tok, peek);
-                continue;
-            }
-
-            if (!current_tok->f_string_raw) {
-                if (peek == 'N') {
-                    /* Handle named unicode escapes (\N{BULLET}) */
-                    peek = tok_nextc(tok);
-                    if (peek == '{') {
-                        unicode_escape = 1;
-                    } else {
-                        tok_backup(tok, peek);
-                    }
-                }
-            } /* else {
-                skip the escaped character
-            }*/
+          syntaxerror(tok,
+                      "unterminated string literal (detected at"
+                      " line %d)",
+                      start);
+          if (c != '\n') {
+            tok->done = E_EOLS;
+          }
+          return MAKE_TOKEN(ERRORTOKEN);
+        }
+      }
+      if (c == quote) {
+        end_quote_size += 1;
+      } else {
+        end_quote_size = 0;
+        if (c == '\\') {
+          c = tok_nextc(tok); /* skip escaped char */
+          if (c == '\r') {
+            c = tok_nextc(tok);
+          }
         }
+      }
     }
 
-    // Backup the f-string quotes to emit a final FSTRING_MIDDLE and
-    // add the quotes to the FSTRING_END in the next tokenizer iteration.
-    for (int i = 0; i < current_tok->f_string_quote_size; i++) {
-        tok_backup(tok, current_tok->f_string_quote);
-    }
     p_start = tok->start;
     p_end = tok->cur;
-    return MAKE_TOKEN(FSTRING_MIDDLE);
-}
+    return MAKE_TOKEN(STRING);
+  }
+
+  /* Line continuation */
+  if (c == '\\') {
+    if ((c = tok_continuation_line(tok)) == -1) {
+      return MAKE_TOKEN(ERRORTOKEN);
+    }
+    tok->cont_line = 1;
+    goto again; /* Read next line */
+  }
+
+  /* Punctuation character */
+  int is_punctuation = (c == ':' || c == '}' || c == '!' || c == '{');
+  if (is_punctuation && INSIDE_FSTRING(tok) &&
+      INSIDE_FSTRING_EXPR(current_tok)) {
+    /* This code block gets executed before the curly_bracket_depth is
+     * incremented by the `{` case, so for ensuring that we are on the 0th
+     * level, we need to adjust it manually */
+    int cursor = current_tok->curly_bracket_depth - (c != '{');
+    int in_format_spec = current_tok->in_format_spec;
+    int cursor_in_format_with_debug =
+        cursor == 1 && (current_tok->f_string_debug || in_format_spec);
+    int cursor_valid = cursor == 0 || cursor_in_format_with_debug;
+    if (cursor_valid && !update_fstring_expr(tok, c)) {
+      return MAKE_TOKEN(ENDMARKER);
+    }
+    if (cursor_valid && c != '{' && set_fstring_expr(tok, token, c)) {
+      return MAKE_TOKEN(ERRORTOKEN);
+    }
+
+    if (c == ':' && cursor == current_tok->curly_bracket_expr_start_depth) {
+      current_tok->kind = TOK_FSTRING_MODE;
+      current_tok->in_format_spec = 1;
+      p_start = tok->start;
+      p_end = tok->cur;
+      return MAKE_TOKEN(_PyToken_OneChar(c));
+    }
+  }
+
+  /* Check for two-character token */
+  {
+    int c2 = tok_nextc(tok);
+    int current_token = _PyToken_TwoChars(c, c2);
+    if (current_token != OP) {
+      int c3 = tok_nextc(tok);
+      int current_token3 = _PyToken_ThreeChars(c, c2, c3);
+      if (current_token3 != OP) {
+        current_token = current_token3;
+      } else {
+        tok_backup(tok, c3);
+      }
+      p_start = tok->start;
+      p_end = tok->cur;
+      return MAKE_TOKEN(current_token);
+    }
+    tok_backup(tok, c2);
+  }
+
+  /* Keep track of parentheses nesting level */
+  switch (c) {
+  case '(':
+  case '[':
+  case '{':
+    if (tok->level >= MAXLEVEL) {
+      return MAKE_TOKEN(syntaxerror(tok, "too many nested parentheses"));
+    }
+    tok->parenstack[tok->level] = c;
+    tok->parenlinenostack[tok->level] = tok->lineno;
+    tok->parencolstack[tok->level] = (int)(tok->start - tok->line_start);
+    tok->level++;
+    if (INSIDE_FSTRING(tok)) {
+      current_tok->curly_bracket_depth++;
+    }
+    break;
+  case ')':
+  case ']':
+  case '}':
+    if (INSIDE_FSTRING(tok) && !current_tok->curly_bracket_depth && c == '}') {
+      return MAKE_TOKEN(
+          syntaxerror(tok, "f-string: single '}' is not allowed"));
+    }
+    if (!tok->tok_extra_tokens && !tok->level) {
+      return MAKE_TOKEN(syntaxerror(tok, "unmatched '%c'", c));
+    }
+    if (tok->level > 0) {
+      tok->level--;
+      int opening = tok->parenstack[tok->level];
+      if (!tok->tok_extra_tokens &&
+          !((opening == '(' && c == ')') || (opening == '[' && c == ']') ||
+            (opening == '{' && c == '}'))) {
+        /* If the opening bracket belongs to an f-string's expression
+        part (e.g. f"{)}") and the closing bracket is an arbitrary
+        nested expression, then instead of matching a different
+        syntactical construct with it; we'll throw an unmatched
+        parentheses error. */
+        if (INSIDE_FSTRING(tok) && opening == '{') {
+          assert(current_tok->curly_bracket_depth >= 0);
+          int previous_bracket = current_tok->curly_bracket_depth - 1;
+          if (previous_bracket == current_tok->curly_bracket_expr_start_depth) {
+            return MAKE_TOKEN(syntaxerror(tok, "f-string: unmatched '%c'", c));
+          }
+        }
+        if (tok->parenlinenostack[tok->level] != tok->lineno) {
+          return MAKE_TOKEN(
+              syntaxerror(tok,
+                          "closing parenthesis '%c' does not match "
+                          "opening parenthesis '%c' on line %d",
+                          c, opening, tok->parenlinenostack[tok->level]));
+        } else {
+          return MAKE_TOKEN(
+              syntaxerror(tok,
+                          "closing parenthesis '%c' does not match "
+                          "opening parenthesis '%c'",
+                          c, opening));
+        }
+      }
+    }
+
+    if (INSIDE_FSTRING(tok)) {
+      current_tok->curly_bracket_depth--;
+      if (current_tok->curly_bracket_depth < 0) {
+        return MAKE_TOKEN(syntaxerror(tok, "f-string: unmatched '%c'", c));
+      }
+      if (c == '}' && current_tok->curly_bracket_depth ==
+                          current_tok->curly_bracket_expr_start_depth) {
+        current_tok->curly_bracket_expr_start_depth--;
+        current_tok->kind = TOK_FSTRING_MODE;
+        current_tok->in_format_spec = 0;
+        current_tok->f_string_debug = 0;
+      }
+    }
+    break;
+  default:
+    break;
+  }
+
+  if (!Py_UNICODE_ISPRINTABLE(c)) {
+    return MAKE_TOKEN(
+        syntaxerror(tok, "invalid non-printable character U+%04X", c));
+  }
+
+  if (c == '=' && INSIDE_FSTRING_EXPR(current_tok)) {
+    current_tok->f_string_debug = 1;
+  }
+
+  /* Punctuation character */
+  p_start = tok->start;
+  p_end = tok->cur;
+  return MAKE_TOKEN(_PyToken_OneChar(c));
+}
+
+static int tok_get_fstring_mode(struct tok_state *tok,
+                                tokenizer_mode *current_tok,
+                                struct token *token) {
+  const char *p_start = NULL;
+  const char *p_end = NULL;
+  int end_quote_size = 0;
+  int unicode_escape = 0;
+
+  tok->start = tok->cur;
+  tok->first_lineno = tok->lineno;
+  tok->starting_col_offset = tok->col_offset;
+
+  // If we start with a bracket, we defer to the normal mode as there is nothing
+  // for us to tokenize before it.
+  int start_char = tok_nextc(tok);
+  if (start_char == '{') {
+    int peek1 = tok_nextc(tok);
+    tok_backup(tok, peek1);
+    tok_backup(tok, start_char);
+    if (peek1 != '{') {
+      current_tok->curly_bracket_expr_start_depth++;
+      if (current_tok->curly_bracket_expr_start_depth >= MAX_EXPR_NESTING) {
+        return MAKE_TOKEN(
+            syntaxerror(tok, "f-string: expressions nested too deeply"));
+      }
+      TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE;
+      return tok_get_normal_mode(tok, current_tok, token);
+    }
+  } else {
+    tok_backup(tok, start_char);
+  }
+
+  // Check if we are at the end of the string
+  for (int i = 0; i < current_tok->f_string_quote_size; i++) {
+    int quote = tok_nextc(tok);
+    if (quote != current_tok->f_string_quote) {
+      tok_backup(tok, quote);
+      goto f_string_middle;
+    }
+  }
+
+  if (current_tok->last_expr_buffer != NULL) {
+    PyMem_Free(current_tok->last_expr_buffer);
+    current_tok->last_expr_buffer = NULL;
+    current_tok->last_expr_size = 0;
+    current_tok->last_expr_end = -1;
+  }
+
+  p_start = tok->start;
+  p_end = tok->cur;
+  tok->tok_mode_stack_index--;
+  return MAKE_TOKEN(FSTRING_END);
 
+f_string_middle:
 
-static int
-tok_get(struct tok_state *tok, struct token *token)
-{
-    tokenizer_mode *current_tok = TOK_GET_MODE(tok);
-    if (current_tok->kind == TOK_REGULAR_MODE) {
-        return tok_get_normal_mode(tok, current_tok, token);
-    } else {
-        return tok_get_fstring_mode(tok, current_tok, token);
+  // TODO: This is a bit of a hack, but it works for now. We need to find a
+  // better way to handle this.
+  tok->multi_line_start = tok->line_start;
+  while (end_quote_size != current_tok->f_string_quote_size) {
+    int c = tok_nextc(tok);
+    if (tok->done == E_ERROR || tok->done == E_DECODE) {
+      return MAKE_TOKEN(ERRORTOKEN);
     }
-}
+    int in_format_spec =
+        (current_tok->in_format_spec && INSIDE_FSTRING_EXPR(current_tok));
 
-int
-_PyTokenizer_Get(struct tok_state *tok, struct token *token)
-{
-    int result = tok_get(tok, token);
-    if (tok->decoding_erred) {
-        result = ERRORTOKEN;
-        tok->done = E_DECODE;
+    if (c == EOF || (current_tok->f_string_quote_size == 1 && c == '\n')) {
+      if (tok->decoding_erred) {
+        return MAKE_TOKEN(ERRORTOKEN);
+      }
+
+      // If we are in a format spec and we found a newline,
+      // it means that the format spec ends here and we should
+      // return to the regular mode.
+      if (in_format_spec && c == '\n') {
+        tok_backup(tok, c);
+        TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE;
+        current_tok->in_format_spec = 0;
+        p_start = tok->start;
+        p_end = tok->cur;
+        return MAKE_TOKEN(FSTRING_MIDDLE);
+      }
+
+      assert(tok->multi_line_start != NULL);
+      // shift the tok_state's location into
+      // the start of string, and report the error
+      // from the initial quote character
+      tok->cur = (char *)current_tok->f_string_start;
+      tok->cur++;
+      tok->line_start = current_tok->f_string_multi_line_start;
+      int start = tok->lineno;
+
+      tokenizer_mode *the_current_tok = TOK_GET_MODE(tok);
+      tok->lineno = the_current_tok->f_string_line_start;
+
+      if (current_tok->f_string_quote_size == 3) {
+        syntaxerror(tok,
+                    "unterminated triple-quoted f-string literal"
+                    " (detected at line %d)",
+                    start);
+        if (c != '\n') {
+          tok->done = E_EOFS;
+        }
+        return MAKE_TOKEN(ERRORTOKEN);
+      } else {
+        return MAKE_TOKEN(
+            syntaxerror(tok,
+                        "unterminated f-string literal (detected at"
+                        " line %d)",
+                        start));
+      }
+    }
+
+    if (c == current_tok->f_string_quote) {
+      end_quote_size += 1;
+      continue;
+    } else {
+      end_quote_size = 0;
     }
-    return result;
+
+    if (c == '{') {
+      if (!update_fstring_expr(tok, c)) {
+        return MAKE_TOKEN(ENDMARKER);
+      }
+      int peek = tok_nextc(tok);
+      if (peek != '{' || in_format_spec) {
+        tok_backup(tok, peek);
+        tok_backup(tok, c);
+        current_tok->curly_bracket_expr_start_depth++;
+        if (current_tok->curly_bracket_expr_start_depth >= MAX_EXPR_NESTING) {
+          return MAKE_TOKEN(
+              syntaxerror(tok, "f-string: expressions nested too deeply"));
+        }
+        TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE;
+        current_tok->in_format_spec = 0;
+        p_start = tok->start;
+        p_end = tok->cur;
+      } else {
+        p_start = tok->start;
+        p_end = tok->cur - 1;
+      }
+      return MAKE_TOKEN(FSTRING_MIDDLE);
+    } else if (c == '}') {
+      if (unicode_escape) {
+        p_start = tok->start;
+        p_end = tok->cur;
+        return MAKE_TOKEN(FSTRING_MIDDLE);
+      }
+      int peek = tok_nextc(tok);
+
+      // The tokenizer can only be in the format spec if we have already
+      // completed the expression scanning (indicated by the end of the
+      // expression being set) and we are not at the top level of the bracket
+      // stack (-1 is the top level). Since format specifiers can't legally use
+      // double brackets, we can bypass it here.
+      int cursor = current_tok->curly_bracket_depth;
+      if (peek == '}' && !in_format_spec && cursor == 0) {
+        p_start = tok->start;
+        p_end = tok->cur - 1;
+      } else {
+        tok_backup(tok, peek);
+        tok_backup(tok, c);
+        TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE;
+        p_start = tok->start;
+        p_end = tok->cur;
+      }
+      return MAKE_TOKEN(FSTRING_MIDDLE);
+    } else if (c == '\\') {
+      int peek = tok_nextc(tok);
+      if (peek == '\r') {
+        peek = tok_nextc(tok);
+      }
+      // Special case when the backslash is right before a curly
+      // brace. We have to restore and return the control back
+      // to the loop for the next iteration.
+      if (peek == '{' || peek == '}') {
+        if (!current_tok->f_string_raw) {
+          if (warn_invalid_escape_sequence(tok, peek)) {
+            return MAKE_TOKEN(ERRORTOKEN);
+          }
+        }
+        tok_backup(tok, peek);
+        continue;
+      }
+
+      if (!current_tok->f_string_raw) {
+        if (peek == 'N') {
+          /* Handle named unicode escapes (\N{BULLET}) */
+          peek = tok_nextc(tok);
+          if (peek == '{') {
+            unicode_escape = 1;
+          } else {
+            tok_backup(tok, peek);
+          }
+        }
+      } /* else {
+          skip the escaped character
+      }*/
+    }
+  }
+
+  // Backup the f-string quotes to emit a final FSTRING_MIDDLE and
+  // add the quotes to the FSTRING_END in the next tokenizer iteration.
+  for (int i = 0; i < current_tok->f_string_quote_size; i++) {
+    tok_backup(tok, current_tok->f_string_quote);
+  }
+  p_start = tok->start;
+  p_end = tok->cur;
+  return MAKE_TOKEN(FSTRING_MIDDLE);
+}
+
+static int tok_get(struct tok_state *tok, struct token *token) {
+  tokenizer_mode *current_tok = TOK_GET_MODE(tok);
+  if (current_tok->kind == TOK_REGULAR_MODE) {
+    return tok_get_normal_mode(tok, current_tok, token);
+  } else {
+    return tok_get_fstring_mode(tok, current_tok, token);
+  }
+}
+
+int _PyTokenizer_Get(struct tok_state *tok, struct token *token) {
+  int result = tok_get(tok, token);
+  if (tok->decoding_erred) {
+    result = ERRORTOKEN;
+    tok->done = E_DECODE;
+  }
+  return result;
 }
 
-#if defined(__wasi__) || (defined(__EMSCRIPTEN__) && (__EMSCRIPTEN_major__ >= 3))
+#if defined(__wasi__) ||                                                       \
+    (defined(__EMSCRIPTEN__) && (__EMSCRIPTEN_major__ >= 3))
 // fdopen() with borrowed fd. WASI does not provide dup() and Emscripten's
 // dup() emulation with open() is slow.
 typedef union {
-    void *cookie;
-    int fd;
+  void *cookie;
+  int fd;
 } borrowed;
 
-static ssize_t
-borrow_read(void *cookie, char *buf, size_t size)
-{
-    borrowed b = {.cookie = cookie};
-    return read(b.fd, (void *)buf, size);
+static ssize_t borrow_read(void *cookie, char *buf, size_t size) {
+  borrowed b = {.cookie = cookie};
+  return read(b.fd, (void *)buf, size);
 }
 
-static FILE *
-fdopen_borrow(int fd) {
-    // supports only reading. seek fails. close and write are no-ops.
-    cookie_io_functions_t io_cb = {borrow_read, NULL, NULL, NULL};
-    borrowed b = {.fd = fd};
-    return fopencookie(b.cookie, "r", io_cb);
+static FILE *fdopen_borrow(int fd) {
+  // supports only reading. seek fails. close and write are no-ops.
+  cookie_io_functions_t io_cb = {borrow_read, NULL, NULL, NULL};
+  borrowed b = {.fd = fd};
+  return fopencookie(b.cookie, "r", io_cb);
 }
 #else
-static FILE *
-fdopen_borrow(int fd) {
-    fd = _Py_dup(fd);
-    if (fd < 0) {
-        return NULL;
-    }
-    return fdopen(fd, "r");
+static FILE *fdopen_borrow(int fd) {
+  fd = _Py_dup(fd);
+  if (fd < 0) {
+    return NULL;
+  }
+  return fdopen(fd, "r");
 }
 #endif
 
@@ -3028,59 +2912,54 @@ fdopen_borrow(int fd) {
    The char* returned is malloc'ed via PyMem_Malloc() and thus must be freed
    by the caller. */
 
-char *
-_PyTokenizer_FindEncodingFilename(int fd, PyObject *filename)
-{
-    struct tok_state *tok;
-    FILE *fp;
-    char *encoding = NULL;
-
-    fp = fdopen_borrow(fd);
-    if (fp == NULL) {
-        return NULL;
-    }
-    tok = _PyTokenizer_FromFile(fp, NULL, NULL, NULL);
-    if (tok == NULL) {
-        fclose(fp);
-        return NULL;
-    }
-    if (filename != NULL) {
-        tok->filename = Py_NewRef(filename);
-    }
-    else {
-        tok->filename = PyUnicode_FromString("<string>");
-        if (tok->filename == NULL) {
-            fclose(fp);
-            _PyTokenizer_Free(tok);
-            return encoding;
-        }
-    }
-    struct token token;
-    // We don't want to report warnings here because it could cause infinite recursion
-    // if fetching the encoding shows a warning.
-    tok->report_warnings = 0;
-    while (tok->lineno < 2 && tok->done == E_OK) {
-        _PyToken_Init(&token);
-        _PyTokenizer_Get(tok, &token);
-        _PyToken_Free(&token);
-    }
+char *_PyTokenizer_FindEncodingFilename(int fd, PyObject *filename) {
+  struct tok_state *tok;
+  FILE *fp;
+  char *encoding = NULL;
+
+  fp = fdopen_borrow(fd);
+  if (fp == NULL) {
+    return NULL;
+  }
+  tok = _PyTokenizer_FromFile(fp, NULL, NULL, NULL);
+  if (tok == NULL) {
     fclose(fp);
-    if (tok->encoding) {
-        encoding = (char *)PyMem_Malloc(strlen(tok->encoding) + 1);
-        if (encoding) {
-            strcpy(encoding, tok->encoding);
-        }
-    }
-    _PyTokenizer_Free(tok);
-    return encoding;
+    return NULL;
+  }
+  if (filename != NULL) {
+    tok->filename = Py_NewRef(filename);
+  } else {
+    tok->filename = PyUnicode_FromString("<string>");
+    if (tok->filename == NULL) {
+      fclose(fp);
+      _PyTokenizer_Free(tok);
+      return encoding;
+    }
+  }
+  struct token token;
+  // We don't want to report warnings here because it could cause infinite
+  // recursion if fetching the encoding shows a warning.
+  tok->report_warnings = 0;
+  while (tok->lineno < 2 && tok->done == E_OK) {
+    _PyToken_Init(&token);
+    _PyTokenizer_Get(tok, &token);
+    _PyToken_Free(&token);
+  }
+  fclose(fp);
+  if (tok->encoding) {
+    encoding = (char *)PyMem_Malloc(strlen(tok->encoding) + 1);
+    if (encoding) {
+      strcpy(encoding, tok->encoding);
+    }
+  }
+  _PyTokenizer_Free(tok);
+  return encoding;
 }
 
 #ifdef Py_DEBUG
-void
-tok_dump(int type, char *start, char *end)
-{
-    fprintf(stderr, "%s", _PyParser_TokenNames[type]);
-    if (type == NAME || type == NUMBER || type == STRING || type == OP)
-        fprintf(stderr, "(%.*s)", (int)(end - start), start);
+void tok_dump(int type, char *start, char *end) {
+  fprintf(stderr, "%s", _PyParser_TokenNames[type]);
+  if (type == NAME || type == NUMBER || type == STRING || type == OP)
+    fprintf(stderr, "(%.*s)", (int)(end - start), start);
 }
-#endif  // Py_DEBUG
+#endif // Py_DEBUG
diff --git a/contrib/tools/python3/Parser/tokenizer.h b/contrib/tools/python3/Parser/tokenizer.h
index 1e1daa3648..4eeeb1f234 100644
--- a/contrib/tools/python3/Parser/tokenizer.h
+++ b/contrib/tools/python3/Parser/tokenizer.h
@@ -14,133 +14,136 @@ extern "C" {
 #define MAXLEVEL 200        /* Max parentheses level */
 #define MAXFSTRINGLEVEL 150 /* Max f-string nesting level */
 
-enum decoding_state {
-    STATE_INIT,
-    STATE_SEEK_CODING,
-    STATE_NORMAL
-};
+enum decoding_state { STATE_INIT, STATE_SEEK_CODING, STATE_NORMAL };
 
 enum interactive_underflow_t {
-    /* Normal mode of operation: return a new token when asked in interactive mode */
-    IUNDERFLOW_NORMAL,
-    /* Forcefully return ENDMARKER when asked for a new token in interactive mode. This
-     * can be used to prevent the tokenizer to prompt the user for new tokens */
-    IUNDERFLOW_STOP,
+  /* Normal mode of operation: return a new token when asked in interactive mode
+   */
+  IUNDERFLOW_NORMAL,
+  /* Forcefully return ENDMARKER when asked for a new token in interactive mode.
+   * This can be used to prevent the tokenizer to prompt the user for new tokens
+   */
+  IUNDERFLOW_STOP,
 };
 
 struct token {
-    int level;
-    int lineno, col_offset, end_lineno, end_col_offset;
-    const char *start, *end;
-    PyObject *metadata;
+  int level;
+  int lineno, col_offset, end_lineno, end_col_offset;
+  const char *start, *end;
+  PyObject *metadata;
 };
 
 enum tokenizer_mode_kind_t {
-    TOK_REGULAR_MODE,
-    TOK_FSTRING_MODE,
+  TOK_REGULAR_MODE,
+  TOK_FSTRING_MODE,
 };
 
 #define MAX_EXPR_NESTING 3
 
 typedef struct _tokenizer_mode {
-    enum tokenizer_mode_kind_t kind;
-
-    int curly_bracket_depth;
-    int curly_bracket_expr_start_depth;
-
-    char f_string_quote;
-    int f_string_quote_size;
-    int f_string_raw;
-    const char* f_string_start;
-    const char* f_string_multi_line_start;
-    int f_string_line_start;
-
-    Py_ssize_t f_string_start_offset;
-    Py_ssize_t f_string_multi_line_start_offset;
-
-    Py_ssize_t last_expr_size;
-    Py_ssize_t last_expr_end;
-    char* last_expr_buffer;
-    int f_string_debug;
+  enum tokenizer_mode_kind_t kind;
+
+  int curly_bracket_depth;
+  int curly_bracket_expr_start_depth;
+
+  char f_string_quote;
+  int f_string_quote_size;
+  int f_string_raw;
+  const char *f_string_start;
+  const char *f_string_multi_line_start;
+  int f_string_line_start;
+
+  Py_ssize_t f_string_start_offset;
+  Py_ssize_t f_string_multi_line_start_offset;
+
+  Py_ssize_t last_expr_size;
+  Py_ssize_t last_expr_end;
+  char *last_expr_buffer;
+  int f_string_debug;
+  int in_format_spec;
 } tokenizer_mode;
 
 /* Tokenizer state */
 struct tok_state {
-    /* Input state; buf <= cur <= inp <= end */
-    /* NB an entire line is held in the buffer */
-    char *buf;          /* Input buffer, or NULL; malloc'ed if fp != NULL or readline != NULL */
-    char *cur;          /* Next character in buffer */
-    char *inp;          /* End of data in buffer */
-    int fp_interactive; /* If the file descriptor is interactive */
-    char *interactive_src_start; /* The start of the source parsed so far in interactive mode */
-    char *interactive_src_end; /* The end of the source parsed so far in interactive mode */
-    const char *end;    /* End of input buffer if buf != NULL */
-    const char *start;  /* Start of current token if not NULL */
-    int done;           /* E_OK normally, E_EOF at EOF, otherwise error code */
-    /* NB If done != E_OK, cur must be == inp!!! */
-    FILE *fp;           /* Rest of input; NULL if tokenizing a string */
-    int tabsize;        /* Tab spacing */
-    int indent;         /* Current indentation index */
-    int indstack[MAXINDENT];            /* Stack of indents */
-    int atbol;          /* Nonzero if at begin of new line */
-    int pendin;         /* Pending indents (if > 0) or dedents (if < 0) */
-    const char *prompt, *nextprompt;          /* For interactive prompting */
-    int lineno;         /* Current line number */
-    int first_lineno;   /* First line of a single line or multi line string
-                           expression (cf. issue 16806) */
-    int starting_col_offset; /* The column offset at the beginning of a token */
-    int col_offset;     /* Current col offset */
-    int level;          /* () [] {} Parentheses nesting level */
-            /* Used to allow free continuations inside them */
-    char parenstack[MAXLEVEL];
-    int parenlinenostack[MAXLEVEL];
-    int parencolstack[MAXLEVEL];
-    PyObject *filename;
-    /* Stuff for checking on different tab sizes */
-    int altindstack[MAXINDENT];         /* Stack of alternate indents */
-    /* Stuff for PEP 0263 */
-    enum decoding_state decoding_state;
-    int decoding_erred;         /* whether erred in decoding  */
-    char *encoding;         /* Source encoding. */
-    int cont_line;          /* whether we are in a continuation line. */
-    const char* line_start;     /* pointer to start of current line */
-    const char* multi_line_start; /* pointer to start of first line of
-                                     a single line or multi line string
-                                     expression (cf. issue 16806) */
-    PyObject *decoding_readline; /* open(...).readline */
-    PyObject *decoding_buffer;
-    PyObject *readline;     /* readline() function */
-    const char* enc;        /* Encoding for the current str. */
-    char* str;          /* Source string being tokenized (if tokenizing from a string)*/
-    char* input;       /* Tokenizer's newline translated copy of the string. */
-
-    int type_comments;      /* Whether to look for type comments */
-
-    /* async/await related fields (still needed depending on feature_version) */
-    int async_hacks;     /* =1 if async/await aren't always keywords */
-    int async_def;        /* =1 if tokens are inside an 'async def' body. */
-    int async_def_indent; /* Indentation level of the outermost 'async def'. */
-    int async_def_nl;     /* =1 if the outermost 'async def' had at least one
-                             NEWLINE token after it. */
-    /* How to proceed when asked for a new token in interactive mode */
-    enum interactive_underflow_t interactive_underflow;
-    int report_warnings;
-    // TODO: Factor this into its own thing
-    tokenizer_mode tok_mode_stack[MAXFSTRINGLEVEL];
-    int tok_mode_stack_index;
-    int tok_extra_tokens;
-    int comment_newline;
-    int implicit_newline;
+  /* Input state; buf <= cur <= inp <= end */
+  /* NB an entire line is held in the buffer */
+  char *buf; /* Input buffer, or NULL; malloc'ed if fp != NULL or readline !=
+                NULL */
+  char *cur; /* Next character in buffer */
+  char *inp; /* End of data in buffer */
+  int fp_interactive;          /* If the file descriptor is interactive */
+  char *interactive_src_start; /* The start of the source parsed so far in
+                                  interactive mode */
+  char *interactive_src_end;   /* The end of the source parsed so far in
+                                  interactive mode */
+  const char *end;             /* End of input buffer if buf != NULL */
+  const char *start;           /* Start of current token if not NULL */
+  int done; /* E_OK normally, E_EOF at EOF, otherwise error code */
+  /* NB If done != E_OK, cur must be == inp!!! */
+  FILE *fp;                /* Rest of input; NULL if tokenizing a string */
+  int tabsize;             /* Tab spacing */
+  int indent;              /* Current indentation index */
+  int indstack[MAXINDENT]; /* Stack of indents */
+  int atbol;               /* Nonzero if at begin of new line */
+  int pendin;              /* Pending indents (if > 0) or dedents (if < 0) */
+  const char *prompt, *nextprompt; /* For interactive prompting */
+  int lineno;                      /* Current line number */
+  int first_lineno;        /* First line of a single line or multi line string
+                              expression (cf. issue 16806) */
+  int starting_col_offset; /* The column offset at the beginning of a token */
+  int col_offset;          /* Current col offset */
+  int level;               /* () [] {} Parentheses nesting level */
+                           /* Used to allow free continuations inside them */
+  char parenstack[MAXLEVEL];
+  int parenlinenostack[MAXLEVEL];
+  int parencolstack[MAXLEVEL];
+  PyObject *filename;
+  /* Stuff for checking on different tab sizes */
+  int altindstack[MAXINDENT]; /* Stack of alternate indents */
+  /* Stuff for PEP 0263 */
+  enum decoding_state decoding_state;
+  int decoding_erred;           /* whether erred in decoding  */
+  char *encoding;               /* Source encoding. */
+  int cont_line;                /* whether we are in a continuation line. */
+  const char *line_start;       /* pointer to start of current line */
+  const char *multi_line_start; /* pointer to start of first line of
+                                   a single line or multi line string
+                                   expression (cf. issue 16806) */
+  PyObject *decoding_readline;  /* open(...).readline */
+  PyObject *decoding_buffer;
+  PyObject *readline; /* readline() function */
+  const char *enc;    /* Encoding for the current str. */
+  char *str;   /* Source string being tokenized (if tokenizing from a string)*/
+  char *input; /* Tokenizer's newline translated copy of the string. */
+
+  int type_comments; /* Whether to look for type comments */
+
+  /* async/await related fields (still needed depending on feature_version) */
+  int async_hacks;      /* =1 if async/await aren't always keywords */
+  int async_def;        /* =1 if tokens are inside an 'async def' body. */
+  int async_def_indent; /* Indentation level of the outermost 'async def'. */
+  int async_def_nl;     /* =1 if the outermost 'async def' had at least one
+                           NEWLINE token after it. */
+  /* How to proceed when asked for a new token in interactive mode */
+  enum interactive_underflow_t interactive_underflow;
+  int report_warnings;
+  // TODO: Factor this into its own thing
+  tokenizer_mode tok_mode_stack[MAXFSTRINGLEVEL];
+  int tok_mode_stack_index;
+  int tok_extra_tokens;
+  int comment_newline;
+  int implicit_newline;
 #ifdef Py_DEBUG
-    int debug;
+  int debug;
 #endif
 };
 
 extern struct tok_state *_PyTokenizer_FromString(const char *, int, int);
 extern struct tok_state *_PyTokenizer_FromUTF8(const char *, int, int);
-extern struct tok_state *_PyTokenizer_FromReadline(PyObject*, const char*, int, int);
-extern struct tok_state *_PyTokenizer_FromFile(FILE *, const char*,
-                                              const char *, const char *);
+extern struct tok_state *_PyTokenizer_FromReadline(PyObject *, const char *,
+                                                   int, int);
+extern struct tok_state *_PyTokenizer_FromFile(FILE *, const char *,
+                                               const char *, const char *);
 extern void _PyTokenizer_Free(struct tok_state *);
 extern void _PyToken_Free(struct token *);
 extern void _PyToken_Init(struct token *);
author	shadchin <shadchin@yandex-team.com>	2024-08-17 21:51:59 +0300
committer	shadchin <shadchin@yandex-team.com>	2024-08-17 22:04:51 +0300
commit	ee9edbd8878888bafcd0eeb3b528f3ec4311560b (patch)
tree	d54d8138e50a446904f10a2092719be86af011b7 /contrib/tools/python3/Parser
parent	72cbe4bad58add0912623ba51351ff1db8587249 (diff)
download	ydb-ee9edbd8878888bafcd0eeb3b528f3ec4311560b.tar.gz