Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

1 files changed, 70 insertions, 70 deletions

diff --git a/contrib/tools/python3/src/Modules/parsermodule.c b/contrib/tools/python3/src/Modules/parsermodule.c
index 24b0ffbe36..9ba86e4b39 100644
--- a/contrib/tools/python3/src/Modules/parsermodule.c
+++ b/contrib/tools/python3/src/Modules/parsermodule.c
@@ -28,13 +28,13 @@
 
 #include "Python.h"                     /* general Python API             */
 #include "Python-ast.h"                 /* mod_ty */
-#undef Yield   /* undefine macro conflicting with <winbase.h> */
-#include "ast.h"
+#undef Yield   /* undefine macro conflicting with <winbase.h> */ 
+#include "ast.h" 
 #include "graminit.h"                   /* symbols defined in the grammar */
 #include "node.h"                       /* internal parser structure      */
 #include "errcode.h"                    /* error codes for PyNode_*()     */
 #include "token.h"                      /* token definitions              */
-                                        /* ISTERMINAL() / ISNONTERMINAL() */
+                                        /* ISTERMINAL() / ISNONTERMINAL() */ 
 #include "grammar.h"
 #include "parsetok.h"
 
@@ -202,15 +202,15 @@ static PyObject* parser_st2tuple(PyST_Object *, PyObject *, PyObject *);
 #define PUBLIC_METHOD_TYPE (METH_VARARGS|METH_KEYWORDS)
 
 static PyMethodDef parser_methods[] = {
-    {"compile",         (PyCFunction)(void(*)(void))parser_compilest,  PUBLIC_METHOD_TYPE,
+    {"compile",         (PyCFunction)(void(*)(void))parser_compilest,  PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Compile this ST object into a code object.")},
-    {"isexpr",          (PyCFunction)(void(*)(void))parser_isexpr,     PUBLIC_METHOD_TYPE,
+    {"isexpr",          (PyCFunction)(void(*)(void))parser_isexpr,     PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Determines if this ST object was created from an expression.")},
-    {"issuite",         (PyCFunction)(void(*)(void))parser_issuite,    PUBLIC_METHOD_TYPE,
+    {"issuite",         (PyCFunction)(void(*)(void))parser_issuite,    PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Determines if this ST object was created from a suite.")},
-    {"tolist",          (PyCFunction)(void(*)(void))parser_st2list,    PUBLIC_METHOD_TYPE,
+    {"tolist",          (PyCFunction)(void(*)(void))parser_st2list,    PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Creates a list-tree representation of this ST.")},
-    {"totuple",         (PyCFunction)(void(*)(void))parser_st2tuple,   PUBLIC_METHOD_TYPE,
+    {"totuple",         (PyCFunction)(void(*)(void))parser_st2tuple,   PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Creates a tuple-tree representation of this ST.")},
     {"__sizeof__",      (PyCFunction)parser_sizeof,     METH_NOARGS,
         PyDoc_STR("Returns size in memory, in bytes.")},
@@ -224,10 +224,10 @@ PyTypeObject PyST_Type = {
     (int) sizeof(PyST_Object),          /* tp_basicsize         */
     0,                                  /* tp_itemsize          */
     (destructor)parser_free,            /* tp_dealloc           */
-    0,                                  /* tp_vectorcall_offset */
+    0,                                  /* tp_vectorcall_offset */ 
     0,                                  /* tp_getattr           */
     0,                                  /* tp_setattr           */
-    0,                                  /* tp_as_async          */
+    0,                                  /* tp_as_async          */ 
     0,                                  /* tp_repr              */
     0,                                  /* tp_as_number         */
     0,                                  /* tp_as_sequence       */
@@ -256,7 +256,7 @@ PyTypeObject PyST_Type = {
 
 
 /* PyST_Type isn't subclassable, so just check ob_type */
-#define PyST_Object_Check(v) Py_IS_TYPE(v, &PyST_Type)
+#define PyST_Object_Check(v) Py_IS_TYPE(v, &PyST_Type) 
 
 static int
 parser_compare_nodes(node *left, node *right)
@@ -336,7 +336,7 @@ parser_newstobject(node *st, int type)
     if (o != 0) {
         o->st_node = st;
         o->st_type = type;
-        o->st_flags = _PyCompilerFlags_INIT;
+        o->st_flags = _PyCompilerFlags_INIT; 
     }
     else {
         PyNode_Free(st);
@@ -580,10 +580,10 @@ parser_do_parse(PyObject *args, PyObject *kw, const char *argspec, int type)
 
         if (n) {
             res = parser_newstobject(n, type);
-            if (res) {
+            if (res) { 
                 ((PyST_Object *)res)->st_flags.cf_flags = flags & PyCF_MASK;
-                ((PyST_Object *)res)->st_flags.cf_feature_version = PY_MINOR_VERSION;
-            }
+                ((PyST_Object *)res)->st_flags.cf_feature_version = PY_MINOR_VERSION; 
+            } 
         }
         else {
             PyParser_SetError(&err);
@@ -652,36 +652,36 @@ validate_node(node *tree)
         PyErr_Format(parser_error, "Unrecognized node type %d.", TYPE(tree));
         return 0;
     }
-    const dfa *nt_dfa = &_PyParser_Grammar.g_dfa[type];
+    const dfa *nt_dfa = &_PyParser_Grammar.g_dfa[type]; 
     REQ(tree, nt_dfa->d_type);
 
     /* Run the DFA for this nonterminal. */
-    dfa_state = nt_dfa->d_state;
+    dfa_state = nt_dfa->d_state; 
     for (pos = 0; pos < nch; ++pos) {
         node *ch = CHILD(tree, pos);
         int ch_type = TYPE(ch);
-        if ((ch_type >= NT_OFFSET + _PyParser_Grammar.g_ndfas)
-            || (ISTERMINAL(ch_type) && (ch_type >= N_TOKENS))
-            || (ch_type < 0)
-           ) {
-            PyErr_Format(parser_error, "Unrecognized node type %d.", ch_type);
-            return 0;
-        }
-        if (ch_type == suite && TYPE(tree) == funcdef) {
-            /* This is the opposite hack of what we do in parser.c
-               (search for func_body_suite), except we don't ever
-               support type comments here. */
-            ch_type = func_body_suite;
-        }
+        if ((ch_type >= NT_OFFSET + _PyParser_Grammar.g_ndfas) 
+            || (ISTERMINAL(ch_type) && (ch_type >= N_TOKENS)) 
+            || (ch_type < 0) 
+           ) { 
+            PyErr_Format(parser_error, "Unrecognized node type %d.", ch_type); 
+            return 0; 
+        } 
+        if (ch_type == suite && TYPE(tree) == funcdef) { 
+            /* This is the opposite hack of what we do in parser.c 
+               (search for func_body_suite), except we don't ever 
+               support type comments here. */ 
+            ch_type = func_body_suite; 
+        } 
         for (arc = 0; arc < dfa_state->s_narcs; ++arc) {
             short a_label = dfa_state->s_arc[arc].a_lbl;
             assert(a_label < _PyParser_Grammar.g_ll.ll_nlabels);
-
-            const char *label_str = _PyParser_Grammar.g_ll.ll_label[a_label].lb_str;
-            if ((_PyParser_Grammar.g_ll.ll_label[a_label].lb_type == ch_type)
-                && ((ch->n_str == NULL) || (label_str == NULL)
-                     || (strcmp(ch->n_str, label_str) == 0))
-               ) {
+ 
+            const char *label_str = _PyParser_Grammar.g_ll.ll_label[a_label].lb_str; 
+            if ((_PyParser_Grammar.g_ll.ll_label[a_label].lb_type == ch_type) 
+                && ((ch->n_str == NULL) || (label_str == NULL) 
+                     || (strcmp(ch->n_str, label_str) == 0)) 
+               ) { 
                 /* The child is acceptable; if non-terminal, validate it recursively. */
                 if (ISNONTERMINAL(ch_type) && !validate_node(ch))
                     return 0;
@@ -697,23 +697,23 @@ validate_node(node *tree)
             if (!a_label) /* Wouldn't accept any more children */
                 goto illegal_num_children;
 
-            int next_type = _PyParser_Grammar.g_ll.ll_label[a_label].lb_type;
-            const char *expected_str = _PyParser_Grammar.g_ll.ll_label[a_label].lb_str;
-
-            if (ISNONTERMINAL(next_type)) {
-                PyErr_Format(parser_error, "Expected %s, got %s.",
-                             _PyParser_Grammar.g_dfa[next_type - NT_OFFSET].d_name,
-                             ISTERMINAL(ch_type) ? _PyParser_TokenNames[ch_type] :
-                             _PyParser_Grammar.g_dfa[ch_type - NT_OFFSET].d_name);
-            }
-            else if (expected_str != NULL) {
-                PyErr_Format(parser_error, "Illegal terminal: expected '%s'.",
-                             expected_str);
-            }
-            else {
+            int next_type = _PyParser_Grammar.g_ll.ll_label[a_label].lb_type; 
+            const char *expected_str = _PyParser_Grammar.g_ll.ll_label[a_label].lb_str; 
+ 
+            if (ISNONTERMINAL(next_type)) { 
+                PyErr_Format(parser_error, "Expected %s, got %s.", 
+                             _PyParser_Grammar.g_dfa[next_type - NT_OFFSET].d_name, 
+                             ISTERMINAL(ch_type) ? _PyParser_TokenNames[ch_type] : 
+                             _PyParser_Grammar.g_dfa[ch_type - NT_OFFSET].d_name); 
+            } 
+            else if (expected_str != NULL) { 
+                PyErr_Format(parser_error, "Illegal terminal: expected '%s'.", 
+                             expected_str); 
+            } 
+            else { 
                 PyErr_Format(parser_error, "Illegal terminal: expected %s.",
                              _PyParser_TokenNames[next_type]);
-            }
+            } 
             return 0;
         }
 
@@ -944,7 +944,7 @@ build_node_children(PyObject *tuple, node *root, int *line_num)
             Py_DECREF(elem);
             return NULL;
         }
-        err = PyNode_AddChild(root, type, strn, *line_num, 0, *line_num, 0);
+        err = PyNode_AddChild(root, type, strn, *line_num, 0, *line_num, 0); 
         if (err == E_NOMEM) {
             Py_DECREF(elem);
             PyObject_FREE(strn);
@@ -1085,9 +1085,9 @@ parser__pickler(PyObject *self, PyObject *args)
         PyObject *newargs;
         PyObject *tuple;
 
-        if ((newargs = PyTuple_Pack(2, st, Py_True)) == NULL)
-            return NULL;
-        tuple = parser_st2tuple((PyST_Object*)NULL, newargs, NULL);
+        if ((newargs = PyTuple_Pack(2, st, Py_True)) == NULL) 
+            return NULL; 
+        tuple = parser_st2tuple((PyST_Object*)NULL, newargs, NULL); 
         if (tuple != NULL) {
             result = Py_BuildValue("O(O)", pickle_constructor, tuple);
             Py_DECREF(tuple);
@@ -1106,23 +1106,23 @@ parser__pickler(PyObject *self, PyObject *args)
  *  inheritance.
  */
 static PyMethodDef parser_functions[] =  {
-    {"compilest",      (PyCFunction)(void(*)(void))parser_compilest,  PUBLIC_METHOD_TYPE,
+    {"compilest",      (PyCFunction)(void(*)(void))parser_compilest,  PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Compiles an ST object into a code object.")},
-    {"expr",            (PyCFunction)(void(*)(void))parser_expr,      PUBLIC_METHOD_TYPE,
+    {"expr",            (PyCFunction)(void(*)(void))parser_expr,      PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Creates an ST object from an expression.")},
-    {"isexpr",          (PyCFunction)(void(*)(void))parser_isexpr,    PUBLIC_METHOD_TYPE,
+    {"isexpr",          (PyCFunction)(void(*)(void))parser_isexpr,    PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Determines if an ST object was created from an expression.")},
-    {"issuite",         (PyCFunction)(void(*)(void))parser_issuite,   PUBLIC_METHOD_TYPE,
+    {"issuite",         (PyCFunction)(void(*)(void))parser_issuite,   PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Determines if an ST object was created from a suite.")},
-    {"suite",           (PyCFunction)(void(*)(void))parser_suite,     PUBLIC_METHOD_TYPE,
+    {"suite",           (PyCFunction)(void(*)(void))parser_suite,     PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Creates an ST object from a suite.")},
-    {"sequence2st",     (PyCFunction)(void(*)(void))parser_tuple2st,  PUBLIC_METHOD_TYPE,
+    {"sequence2st",     (PyCFunction)(void(*)(void))parser_tuple2st,  PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Creates an ST object from a tree representation.")},
-    {"st2tuple",        (PyCFunction)(void(*)(void))parser_st2tuple,  PUBLIC_METHOD_TYPE,
+    {"st2tuple",        (PyCFunction)(void(*)(void))parser_st2tuple,  PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Creates a tuple-tree representation of an ST.")},
-    {"st2list",         (PyCFunction)(void(*)(void))parser_st2list,   PUBLIC_METHOD_TYPE,
+    {"st2list",         (PyCFunction)(void(*)(void))parser_st2list,   PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Creates a list-tree representation of an ST.")},
-    {"tuple2st",        (PyCFunction)(void(*)(void))parser_tuple2st,  PUBLIC_METHOD_TYPE,
+    {"tuple2st",        (PyCFunction)(void(*)(void))parser_tuple2st,  PUBLIC_METHOD_TYPE, 
         PyDoc_STR("Creates an ST object from a tree representation.")},
 
     /* private stuff: support pickle module */
@@ -1153,12 +1153,12 @@ PyInit_parser(void)
 {
     PyObject *module, *copyreg;
 
-    if (PyErr_WarnEx(PyExc_DeprecationWarning,
-            "The parser module is deprecated and will be removed "
-            "in future versions of Python", 7) != 0) {
-        return NULL;
-    }
-
+    if (PyErr_WarnEx(PyExc_DeprecationWarning, 
+            "The parser module is deprecated and will be removed " 
+            "in future versions of Python", 7) != 0) { 
+        return NULL; 
+    } 
+ 
     if (PyType_Ready(&PyST_Type) < 0)
         return NULL;
     module = PyModule_Create(&parsermodule);