LCOV - code coverage report
Current view: | top level - Python - Python-tokenize.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 22 | 72 | 30.6 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 6 | 9 | 66.7 %
|  |  | Branches: | 7 | 46 | 15.2 %

               Branch data     Line data    Source code
           1                 :            : #include "Python.h"
           2                 :            : #include "../Parser/tokenizer.h"
           3                 :            :
           4                 :            : static struct PyModuleDef _tokenizemodule;
           5                 :            :
           6                 :            : typedef struct {
           7                 :            :     PyTypeObject *TokenizerIter;
           8                 :            : } tokenize_state;
           9                 :            :
          10                 :            : static tokenize_state *
          11                 :          9 : get_tokenize_state(PyObject *module) {
          12                 :          9 :     return (tokenize_state *)PyModule_GetState(module);
          13                 :            : }
          14                 :            :
          15                 :            : #define _tokenize_get_state_by_type(type) \
          16                 :            :     get_tokenize_state(PyType_GetModuleByDef(type, &_tokenizemodule))
          17                 :            :
          18                 :            : #include "pycore_runtime.h"
          19                 :            : #include "clinic/Python-tokenize.c.h"
          20                 :            :
          21                 :            : /*[clinic input]
          22                 :            : module _tokenizer
          23                 :            : class _tokenizer.tokenizeriter "tokenizeriterobject *" "_tokenize_get_state_by_type(type)->TokenizerIter"
          24                 :            : [clinic start generated code]*/
          25                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=96d98ee2fef7a8bc]*/
          26                 :            :
          27                 :            : typedef struct
          28                 :            : {
          29                 :            :     PyObject_HEAD struct tok_state *tok;
          30                 :            : } tokenizeriterobject;
          31                 :            :
          32                 :            : /*[clinic input]
          33                 :            : @classmethod
          34                 :            : _tokenizer.tokenizeriter.__new__ as tokenizeriter_new
          35                 :            :
          36                 :            :     source: str
          37                 :            : [clinic start generated code]*/
          38                 :            :
          39                 :            : static PyObject *
          40                 :          0 : tokenizeriter_new_impl(PyTypeObject *type, const char *source)
          41                 :            : /*[clinic end generated code: output=7fd9f46cf9263cbb input=4384b368407375c6]*/
          42                 :            : {
          43                 :          0 :     tokenizeriterobject *self = (tokenizeriterobject *)type->tp_alloc(type, 0);
          44         [ #  # ]:          0 :     if (self == NULL) {
          45                 :          0 :         return NULL;
          46                 :            :     }
          47                 :          0 :     PyObject *filename = PyUnicode_FromString("<string>");
          48         [ #  # ]:          0 :     if (filename == NULL) {
          49                 :          0 :         return NULL;
          50                 :            :     }
          51                 :          0 :     self->tok = _PyTokenizer_FromUTF8(source, 1);
          52         [ #  # ]:          0 :     if (self->tok == NULL) {
          53                 :          0 :         Py_DECREF(filename);
          54                 :          0 :         return NULL;
          55                 :            :     }
          56                 :          0 :     self->tok->filename = filename;
          57                 :          0 :     return (PyObject *)self;
          58                 :            : }
          59                 :            :
          60                 :            : static PyObject *
          61                 :          0 : tokenizeriter_next(tokenizeriterobject *it)
          62                 :            : {
          63                 :            :     struct token token;
          64                 :          0 :     int type = _PyTokenizer_Get(it->tok, &token);
          65   [ #  #  #  # ]:          0 :     if (type == ERRORTOKEN && PyErr_Occurred()) {
          66                 :          0 :         return NULL;
          67                 :            :     }
          68   [ #  #  #  # ]:          0 :     if (type == ERRORTOKEN || type == ENDMARKER) {
          69                 :          0 :         PyErr_SetString(PyExc_StopIteration, "EOF");
          70                 :          0 :         return NULL;
          71                 :            :     }
          72                 :          0 :     PyObject *str = NULL;
          73   [ #  #  #  # ]:          0 :     if (token.start == NULL || token.end == NULL) {
          74                 :          0 :         str = PyUnicode_FromString("");
          75                 :            :     }
          76                 :            :     else {
          77                 :          0 :         str = PyUnicode_FromStringAndSize(token.start, token.end - token.start);
          78                 :            :     }
          79         [ #  # ]:          0 :     if (str == NULL) {
          80                 :          0 :         return NULL;
          81                 :            :     }
          82                 :            :
          83                 :          0 :     Py_ssize_t size = it->tok->inp - it->tok->buf;
          84                 :          0 :     PyObject *line = PyUnicode_DecodeUTF8(it->tok->buf, size, "replace");
          85         [ #  # ]:          0 :     if (line == NULL) {
          86                 :          0 :         Py_DECREF(str);
          87                 :          0 :         return NULL;
          88                 :            :     }
          89         [ #  # ]:          0 :     const char *line_start = type == STRING ? it->tok->multi_line_start : it->tok->line_start;
          90         [ #  # ]:          0 :     int lineno = type == STRING ? it->tok->first_lineno : it->tok->lineno;
          91                 :          0 :     int end_lineno = it->tok->lineno;
          92                 :          0 :     int col_offset = -1;
          93                 :          0 :     int end_col_offset = -1;
          94   [ #  #  #  # ]:          0 :     if (token.start != NULL && token.start >= line_start) {
          95                 :          0 :         col_offset = (int)(token.start - line_start);
          96                 :            :     }
          97   [ #  #  #  # ]:          0 :     if (token.end != NULL && token.end >= it->tok->line_start) {
          98                 :          0 :         end_col_offset = (int)(token.end - it->tok->line_start);
          99                 :            :     }
         100                 :            :
         101                 :          0 :     return Py_BuildValue("(NiiiiiN)", str, type, lineno, end_lineno, col_offset, end_col_offset, line);
         102                 :            : }
         103                 :            :
         104                 :            : static void
         105                 :          0 : tokenizeriter_dealloc(tokenizeriterobject *it)
         106                 :            : {
         107                 :          0 :     PyTypeObject *tp = Py_TYPE(it);
         108                 :          0 :     _PyTokenizer_Free(it->tok);
         109                 :          0 :     tp->tp_free(it);
         110                 :          0 :     Py_DECREF(tp);
         111                 :          0 : }
         112                 :            :
         113                 :            : static PyType_Slot tokenizeriter_slots[] = {
         114                 :            :     {Py_tp_new, tokenizeriter_new},
         115                 :            :     {Py_tp_dealloc, tokenizeriter_dealloc},
         116                 :            :     {Py_tp_getattro, PyObject_GenericGetAttr},
         117                 :            :     {Py_tp_iter, PyObject_SelfIter},
         118                 :            :     {Py_tp_iternext, tokenizeriter_next},
         119                 :            :     {0, NULL},
         120                 :            : };
         121                 :            :
         122                 :            : static PyType_Spec tokenizeriter_spec = {
         123                 :            :     .name = "_tokenize.TokenizerIter",
         124                 :            :     .basicsize = sizeof(tokenizeriterobject),
         125                 :            :     .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE),
         126                 :            :     .slots = tokenizeriter_slots,
         127                 :            : };
         128                 :            :
         129                 :            : static int
         130                 :          1 : tokenizemodule_exec(PyObject *m)
         131                 :            : {
         132                 :          1 :     tokenize_state *state = get_tokenize_state(m);
         133         [ -  + ]:          1 :     if (state == NULL) {
         134                 :          0 :         return -1;
         135                 :            :     }
         136                 :            :
         137                 :          1 :     state->TokenizerIter = (PyTypeObject *)PyType_FromModuleAndSpec(m, &tokenizeriter_spec, NULL);
         138         [ -  + ]:          1 :     if (state->TokenizerIter == NULL) {
         139                 :          0 :         return -1;
         140                 :            :     }
         141         [ -  + ]:          1 :     if (PyModule_AddType(m, state->TokenizerIter) < 0) {
         142                 :          0 :         return -1;
         143                 :            :     }
         144                 :            :
         145                 :          1 :     return 0;
         146                 :            : }
         147                 :            :
         148                 :            : static PyMethodDef tokenize_methods[] = {
         149                 :            :     {NULL, NULL, 0, NULL} /* Sentinel */
         150                 :            : };
         151                 :            :
         152                 :            : static PyModuleDef_Slot tokenizemodule_slots[] = {
         153                 :            :     {Py_mod_exec, tokenizemodule_exec},
         154                 :            :     {0, NULL}
         155                 :            : };
         156                 :            :
         157                 :            : static int
         158                 :          6 : tokenizemodule_traverse(PyObject *m, visitproc visit, void *arg)
         159                 :            : {
         160                 :          6 :     tokenize_state *state = get_tokenize_state(m);
         161   [ +  -  -  + ]:          6 :     Py_VISIT(state->TokenizerIter);
         162                 :          6 :     return 0;
         163                 :            : }
         164                 :            :
         165                 :            : static int
         166                 :          2 : tokenizemodule_clear(PyObject *m)
         167                 :            : {
         168                 :          2 :     tokenize_state *state = get_tokenize_state(m);
         169         [ +  + ]:          2 :     Py_CLEAR(state->TokenizerIter);
         170                 :          2 :     return 0;
         171                 :            : }
         172                 :            :
         173                 :            : static void
         174                 :          1 : tokenizemodule_free(void *m)
         175                 :            : {
         176                 :          1 :     tokenizemodule_clear((PyObject *)m);
         177                 :          1 : }
         178                 :            :
         179                 :            : static struct PyModuleDef _tokenizemodule = {
         180                 :            :     PyModuleDef_HEAD_INIT,
         181                 :            :     .m_name = "_tokenize",
         182                 :            :     .m_size = sizeof(tokenize_state),
         183                 :            :     .m_slots = tokenizemodule_slots,
         184                 :            :     .m_methods = tokenize_methods,
         185                 :            :     .m_traverse = tokenizemodule_traverse,
         186                 :            :     .m_clear = tokenizemodule_clear,
         187                 :            :     .m_free = tokenizemodule_free,
         188                 :            : };
         189                 :            :
         190                 :            : PyMODINIT_FUNC
         191                 :          1 : PyInit__tokenize(void)
         192                 :            : {
         193                 :          1 :     return PyModuleDef_Init(&_tokenizemodule);
         194                 :            : }

Generated by: LCOV version 1.14