Line data    Source code

       1             : /* Accumulator struct implementation */
       2             : 
       3             : #include "Python.h"
       4             : #include "pycore_accu.h"
       5             : 
       6             : static PyObject *
       7       12745 : join_list_unicode(PyObject *lst)
       8             : {
       9             :     /* return ''.join(lst) */
      10             :     PyObject *sep, *ret;
      11       12745 :     sep = PyUnicode_FromStringAndSize("", 0);
      12       12745 :     ret = PyUnicode_Join(sep, lst);
      13       12745 :     Py_DECREF(sep);
      14       12745 :     return ret;
      15             : }
      16             : 
      17             : int
      18     1480030 : _PyAccu_Init(_PyAccu *acc)
      19             : {
      20             :     /* Lazily allocated */
      21     1480030 :     acc->large = NULL;
      22     1480030 :     acc->small = PyList_New(0);
      23     1480030 :     if (acc->small == NULL)
      24           0 :         return -1;
      25     1480030 :     return 0;
      26             : }
      27             : 
      28             : static int
      29        1091 : flush_accumulator(_PyAccu *acc)
      30             : {
      31        1091 :     Py_ssize_t nsmall = PyList_GET_SIZE(acc->small);
      32        1091 :     if (nsmall) {
      33             :         int ret;
      34             :         PyObject *joined;
      35        1091 :         if (acc->large == NULL) {
      36        1091 :             acc->large = PyList_New(0);
      37        1091 :             if (acc->large == NULL)
      38           0 :                 return -1;
      39             :         }
      40        1091 :         joined = join_list_unicode(acc->small);
      41        1091 :         if (joined == NULL)
      42           0 :             return -1;
      43        1091 :         if (PyList_SetSlice(acc->small, 0, nsmall, NULL)) {
      44           0 :             Py_DECREF(joined);
      45           0 :             return -1;
      46             :         }
      47        1091 :         ret = PyList_Append(acc->large, joined);
      48        1091 :         Py_DECREF(joined);
      49        1091 :         return ret;
      50             :     }
      51           0 :     return 0;
      52             : }
      53             : 
      54             : int
      55      286284 : _PyAccu_Accumulate(_PyAccu *acc, PyObject *unicode)
      56             : {
      57             :     Py_ssize_t nsmall;
      58      286284 :     assert(PyUnicode_Check(unicode));
      59             : 
      60      286284 :     if (PyList_Append(acc->small, unicode))
      61           0 :         return -1;
      62      286284 :     nsmall = PyList_GET_SIZE(acc->small);
      63             :     /* Each item in a list of unicode objects has an overhead (in 64-bit
      64             :      * builds) of:
      65             :      *   - 8 bytes for the list slot
      66             :      *   - 56 bytes for the header of the unicode object
      67             :      * that is, 64 bytes.  100000 such objects waste more than 6 MiB
      68             :      * compared to a single concatenated string.
      69             :      */
      70      286284 :     if (nsmall < 100000)
      71      286284 :         return 0;
      72           0 :     return flush_accumulator(acc);
      73             : }
      74             : 
      75             : PyObject *
      76        1091 : _PyAccu_FinishAsList(_PyAccu *acc)
      77             : {
      78             :     int ret;
      79             :     PyObject *res;
      80             : 
      81        1091 :     ret = flush_accumulator(acc);
      82        1091 :     Py_CLEAR(acc->small);
      83        1091 :     if (ret) {
      84           0 :         Py_CLEAR(acc->large);
      85           0 :         return NULL;
      86             :     }
      87        1091 :     res = acc->large;
      88        1091 :     acc->large = NULL;
      89        1091 :     return res;
      90             : }
      91             : 
      92             : PyObject *
      93       11654 : _PyAccu_Finish(_PyAccu *acc)
      94             : {
      95             :     PyObject *list, *res;
      96       11654 :     if (acc->large == NULL) {
      97       11654 :         list = acc->small;
      98       11654 :         acc->small = NULL;
      99             :     }
     100             :     else {
     101           0 :         list = _PyAccu_FinishAsList(acc);
     102           0 :         if (!list)
     103           0 :             return NULL;
     104             :     }
     105       11654 :     res = join_list_unicode(list);
     106       11654 :     Py_DECREF(list);
     107       11654 :     return res;
     108             : }
     109             : 
     110             : void
     111     2962670 : _PyAccu_Destroy(_PyAccu *acc)
     112             : {
     113     2962670 :     Py_CLEAR(acc->small);
     114     2962670 :     Py_CLEAR(acc->large);
     115     2962670 : }