LCOV - code coverage report
Current view: top level - Modules/_multiprocessing/clinic - semaphore.c.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 0 92 0.0 %
Date: 2023-03-20 08:15:36 Functions: 0 11 0.0 %
Branches: 0 64 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*[clinic input]
       2                 :            : preserve
       3                 :            : [clinic start generated code]*/
       4                 :            : 
       5                 :            : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
       6                 :            : #  include "pycore_gc.h"            // PyGC_Head
       7                 :            : #  include "pycore_runtime.h"       // _Py_ID()
       8                 :            : #endif
       9                 :            : 
      10                 :            : 
      11                 :            : #if defined(HAVE_MP_SEMAPHORE) && defined(MS_WINDOWS)
      12                 :            : 
      13                 :            : PyDoc_STRVAR(_multiprocessing_SemLock_acquire__doc__,
      14                 :            : "acquire($self, /, block=True, timeout=None)\n"
      15                 :            : "--\n"
      16                 :            : "\n"
      17                 :            : "Acquire the semaphore/lock.");
      18                 :            : 
      19                 :            : #define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF    \
      20                 :            :     {"acquire", _PyCFunction_CAST(_multiprocessing_SemLock_acquire), METH_FASTCALL|METH_KEYWORDS, _multiprocessing_SemLock_acquire__doc__},
      21                 :            : 
      22                 :            : static PyObject *
      23                 :            : _multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
      24                 :            :                                       PyObject *timeout_obj);
      25                 :            : 
      26                 :            : static PyObject *
      27                 :            : _multiprocessing_SemLock_acquire(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
      28                 :            : {
      29                 :            :     PyObject *return_value = NULL;
      30                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
      31                 :            : 
      32                 :            :     #define NUM_KEYWORDS 2
      33                 :            :     static struct {
      34                 :            :         PyGC_Head _this_is_not_used;
      35                 :            :         PyObject_VAR_HEAD
      36                 :            :         PyObject *ob_item[NUM_KEYWORDS];
      37                 :            :     } _kwtuple = {
      38                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
      39                 :            :         .ob_item = { &_Py_ID(block), &_Py_ID(timeout), },
      40                 :            :     };
      41                 :            :     #undef NUM_KEYWORDS
      42                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
      43                 :            : 
      44                 :            :     #else  // !Py_BUILD_CORE
      45                 :            :     #  define KWTUPLE NULL
      46                 :            :     #endif  // !Py_BUILD_CORE
      47                 :            : 
      48                 :            :     static const char * const _keywords[] = {"block", "timeout", NULL};
      49                 :            :     static _PyArg_Parser _parser = {
      50                 :            :         .keywords = _keywords,
      51                 :            :         .fname = "acquire",
      52                 :            :         .kwtuple = KWTUPLE,
      53                 :            :     };
      54                 :            :     #undef KWTUPLE
      55                 :            :     PyObject *argsbuf[2];
      56                 :            :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
      57                 :            :     int blocking = 1;
      58                 :            :     PyObject *timeout_obj = Py_None;
      59                 :            : 
      60                 :            :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
      61                 :            :     if (!args) {
      62                 :            :         goto exit;
      63                 :            :     }
      64                 :            :     if (!noptargs) {
      65                 :            :         goto skip_optional_pos;
      66                 :            :     }
      67                 :            :     if (args[0]) {
      68                 :            :         blocking = PyObject_IsTrue(args[0]);
      69                 :            :         if (blocking < 0) {
      70                 :            :             goto exit;
      71                 :            :         }
      72                 :            :         if (!--noptargs) {
      73                 :            :             goto skip_optional_pos;
      74                 :            :         }
      75                 :            :     }
      76                 :            :     timeout_obj = args[1];
      77                 :            : skip_optional_pos:
      78                 :            :     return_value = _multiprocessing_SemLock_acquire_impl(self, blocking, timeout_obj);
      79                 :            : 
      80                 :            : exit:
      81                 :            :     return return_value;
      82                 :            : }
      83                 :            : 
      84                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) && defined(MS_WINDOWS) */
      85                 :            : 
      86                 :            : #if defined(HAVE_MP_SEMAPHORE) && defined(MS_WINDOWS)
      87                 :            : 
      88                 :            : PyDoc_STRVAR(_multiprocessing_SemLock_release__doc__,
      89                 :            : "release($self, /)\n"
      90                 :            : "--\n"
      91                 :            : "\n"
      92                 :            : "Release the semaphore/lock.");
      93                 :            : 
      94                 :            : #define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF    \
      95                 :            :     {"release", (PyCFunction)_multiprocessing_SemLock_release, METH_NOARGS, _multiprocessing_SemLock_release__doc__},
      96                 :            : 
      97                 :            : static PyObject *
      98                 :            : _multiprocessing_SemLock_release_impl(SemLockObject *self);
      99                 :            : 
     100                 :            : static PyObject *
     101                 :            : _multiprocessing_SemLock_release(SemLockObject *self, PyObject *Py_UNUSED(ignored))
     102                 :            : {
     103                 :            :     return _multiprocessing_SemLock_release_impl(self);
     104                 :            : }
     105                 :            : 
     106                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) && defined(MS_WINDOWS) */
     107                 :            : 
     108                 :            : #if defined(HAVE_MP_SEMAPHORE) && !defined(MS_WINDOWS)
     109                 :            : 
     110                 :            : PyDoc_STRVAR(_multiprocessing_SemLock_acquire__doc__,
     111                 :            : "acquire($self, /, block=True, timeout=None)\n"
     112                 :            : "--\n"
     113                 :            : "\n"
     114                 :            : "Acquire the semaphore/lock.");
     115                 :            : 
     116                 :            : #define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF    \
     117                 :            :     {"acquire", _PyCFunction_CAST(_multiprocessing_SemLock_acquire), METH_FASTCALL|METH_KEYWORDS, _multiprocessing_SemLock_acquire__doc__},
     118                 :            : 
     119                 :            : static PyObject *
     120                 :            : _multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
     121                 :            :                                       PyObject *timeout_obj);
     122                 :            : 
     123                 :            : static PyObject *
     124                 :          0 : _multiprocessing_SemLock_acquire(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     125                 :            : {
     126                 :          0 :     PyObject *return_value = NULL;
     127                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     128                 :            : 
     129                 :            :     #define NUM_KEYWORDS 2
     130                 :            :     static struct {
     131                 :            :         PyGC_Head _this_is_not_used;
     132                 :            :         PyObject_VAR_HEAD
     133                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     134                 :            :     } _kwtuple = {
     135                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     136                 :            :         .ob_item = { &_Py_ID(block), &_Py_ID(timeout), },
     137                 :            :     };
     138                 :            :     #undef NUM_KEYWORDS
     139                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     140                 :            : 
     141                 :            :     #else  // !Py_BUILD_CORE
     142                 :            :     #  define KWTUPLE NULL
     143                 :            :     #endif  // !Py_BUILD_CORE
     144                 :            : 
     145                 :            :     static const char * const _keywords[] = {"block", "timeout", NULL};
     146                 :            :     static _PyArg_Parser _parser = {
     147                 :            :         .keywords = _keywords,
     148                 :            :         .fname = "acquire",
     149                 :            :         .kwtuple = KWTUPLE,
     150                 :            :     };
     151                 :            :     #undef KWTUPLE
     152                 :            :     PyObject *argsbuf[2];
     153         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     154                 :          0 :     int blocking = 1;
     155                 :          0 :     PyObject *timeout_obj = Py_None;
     156                 :            : 
     157   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
             #  #  #  # ]
     158         [ #  # ]:          0 :     if (!args) {
     159                 :          0 :         goto exit;
     160                 :            :     }
     161         [ #  # ]:          0 :     if (!noptargs) {
     162                 :          0 :         goto skip_optional_pos;
     163                 :            :     }
     164         [ #  # ]:          0 :     if (args[0]) {
     165                 :          0 :         blocking = PyObject_IsTrue(args[0]);
     166         [ #  # ]:          0 :         if (blocking < 0) {
     167                 :          0 :             goto exit;
     168                 :            :         }
     169         [ #  # ]:          0 :         if (!--noptargs) {
     170                 :          0 :             goto skip_optional_pos;
     171                 :            :         }
     172                 :            :     }
     173                 :          0 :     timeout_obj = args[1];
     174                 :          0 : skip_optional_pos:
     175                 :          0 :     return_value = _multiprocessing_SemLock_acquire_impl(self, blocking, timeout_obj);
     176                 :            : 
     177                 :          0 : exit:
     178                 :          0 :     return return_value;
     179                 :            : }
     180                 :            : 
     181                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) && !defined(MS_WINDOWS) */
     182                 :            : 
     183                 :            : #if defined(HAVE_MP_SEMAPHORE) && !defined(MS_WINDOWS)
     184                 :            : 
     185                 :            : PyDoc_STRVAR(_multiprocessing_SemLock_release__doc__,
     186                 :            : "release($self, /)\n"
     187                 :            : "--\n"
     188                 :            : "\n"
     189                 :            : "Release the semaphore/lock.");
     190                 :            : 
     191                 :            : #define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF    \
     192                 :            :     {"release", (PyCFunction)_multiprocessing_SemLock_release, METH_NOARGS, _multiprocessing_SemLock_release__doc__},
     193                 :            : 
     194                 :            : static PyObject *
     195                 :            : _multiprocessing_SemLock_release_impl(SemLockObject *self);
     196                 :            : 
     197                 :            : static PyObject *
     198                 :          0 : _multiprocessing_SemLock_release(SemLockObject *self, PyObject *Py_UNUSED(ignored))
     199                 :            : {
     200                 :          0 :     return _multiprocessing_SemLock_release_impl(self);
     201                 :            : }
     202                 :            : 
     203                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) && !defined(MS_WINDOWS) */
     204                 :            : 
     205                 :            : #if defined(HAVE_MP_SEMAPHORE)
     206                 :            : 
     207                 :            : static PyObject *
     208                 :            : _multiprocessing_SemLock_impl(PyTypeObject *type, int kind, int value,
     209                 :            :                               int maxvalue, const char *name, int unlink);
     210                 :            : 
     211                 :            : static PyObject *
     212                 :          0 : _multiprocessing_SemLock(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     213                 :            : {
     214                 :          0 :     PyObject *return_value = NULL;
     215                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     216                 :            : 
     217                 :            :     #define NUM_KEYWORDS 5
     218                 :            :     static struct {
     219                 :            :         PyGC_Head _this_is_not_used;
     220                 :            :         PyObject_VAR_HEAD
     221                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     222                 :            :     } _kwtuple = {
     223                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     224                 :            :         .ob_item = { &_Py_ID(kind), &_Py_ID(value), &_Py_ID(maxvalue), &_Py_ID(name), &_Py_ID(unlink), },
     225                 :            :     };
     226                 :            :     #undef NUM_KEYWORDS
     227                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     228                 :            : 
     229                 :            :     #else  // !Py_BUILD_CORE
     230                 :            :     #  define KWTUPLE NULL
     231                 :            :     #endif  // !Py_BUILD_CORE
     232                 :            : 
     233                 :            :     static const char * const _keywords[] = {"kind", "value", "maxvalue", "name", "unlink", NULL};
     234                 :            :     static _PyArg_Parser _parser = {
     235                 :            :         .keywords = _keywords,
     236                 :            :         .fname = "SemLock",
     237                 :            :         .kwtuple = KWTUPLE,
     238                 :            :     };
     239                 :            :     #undef KWTUPLE
     240                 :            :     PyObject *argsbuf[5];
     241                 :            :     PyObject * const *fastargs;
     242                 :          0 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
     243                 :            :     int kind;
     244                 :            :     int value;
     245                 :            :     int maxvalue;
     246                 :            :     const char *name;
     247                 :            :     int unlink;
     248                 :            : 
     249   [ #  #  #  #  :          0 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 5, 5, 0, argsbuf);
             #  #  #  # ]
     250         [ #  # ]:          0 :     if (!fastargs) {
     251                 :          0 :         goto exit;
     252                 :            :     }
     253                 :          0 :     kind = _PyLong_AsInt(fastargs[0]);
     254   [ #  #  #  # ]:          0 :     if (kind == -1 && PyErr_Occurred()) {
     255                 :          0 :         goto exit;
     256                 :            :     }
     257                 :          0 :     value = _PyLong_AsInt(fastargs[1]);
     258   [ #  #  #  # ]:          0 :     if (value == -1 && PyErr_Occurred()) {
     259                 :          0 :         goto exit;
     260                 :            :     }
     261                 :          0 :     maxvalue = _PyLong_AsInt(fastargs[2]);
     262   [ #  #  #  # ]:          0 :     if (maxvalue == -1 && PyErr_Occurred()) {
     263                 :          0 :         goto exit;
     264                 :            :     }
     265         [ #  # ]:          0 :     if (!PyUnicode_Check(fastargs[3])) {
     266                 :          0 :         _PyArg_BadArgument("SemLock", "argument 'name'", "str", fastargs[3]);
     267                 :          0 :         goto exit;
     268                 :            :     }
     269                 :            :     Py_ssize_t name_length;
     270                 :          0 :     name = PyUnicode_AsUTF8AndSize(fastargs[3], &name_length);
     271         [ #  # ]:          0 :     if (name == NULL) {
     272                 :          0 :         goto exit;
     273                 :            :     }
     274         [ #  # ]:          0 :     if (strlen(name) != (size_t)name_length) {
     275                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
     276                 :          0 :         goto exit;
     277                 :            :     }
     278                 :          0 :     unlink = PyObject_IsTrue(fastargs[4]);
     279         [ #  # ]:          0 :     if (unlink < 0) {
     280                 :          0 :         goto exit;
     281                 :            :     }
     282                 :          0 :     return_value = _multiprocessing_SemLock_impl(type, kind, value, maxvalue, name, unlink);
     283                 :            : 
     284                 :          0 : exit:
     285                 :          0 :     return return_value;
     286                 :            : }
     287                 :            : 
     288                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) */
     289                 :            : 
     290                 :            : #if defined(HAVE_MP_SEMAPHORE)
     291                 :            : 
     292                 :            : PyDoc_STRVAR(_multiprocessing_SemLock__rebuild__doc__,
     293                 :            : "_rebuild($type, handle, kind, maxvalue, name, /)\n"
     294                 :            : "--\n"
     295                 :            : "\n");
     296                 :            : 
     297                 :            : #define _MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF    \
     298                 :            :     {"_rebuild", _PyCFunction_CAST(_multiprocessing_SemLock__rebuild), METH_FASTCALL|METH_CLASS, _multiprocessing_SemLock__rebuild__doc__},
     299                 :            : 
     300                 :            : static PyObject *
     301                 :            : _multiprocessing_SemLock__rebuild_impl(PyTypeObject *type, SEM_HANDLE handle,
     302                 :            :                                        int kind, int maxvalue,
     303                 :            :                                        const char *name);
     304                 :            : 
     305                 :            : static PyObject *
     306                 :          0 : _multiprocessing_SemLock__rebuild(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs)
     307                 :            : {
     308                 :          0 :     PyObject *return_value = NULL;
     309                 :            :     SEM_HANDLE handle;
     310                 :            :     int kind;
     311                 :            :     int maxvalue;
     312                 :            :     const char *name;
     313                 :            : 
     314         [ #  # ]:          0 :     if (!_PyArg_ParseStack(args, nargs, ""F_SEM_HANDLE"iiz:_rebuild",
     315                 :            :         &handle, &kind, &maxvalue, &name)) {
     316                 :          0 :         goto exit;
     317                 :            :     }
     318                 :          0 :     return_value = _multiprocessing_SemLock__rebuild_impl(type, handle, kind, maxvalue, name);
     319                 :            : 
     320                 :          0 : exit:
     321                 :          0 :     return return_value;
     322                 :            : }
     323                 :            : 
     324                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) */
     325                 :            : 
     326                 :            : #if defined(HAVE_MP_SEMAPHORE)
     327                 :            : 
     328                 :            : PyDoc_STRVAR(_multiprocessing_SemLock__count__doc__,
     329                 :            : "_count($self, /)\n"
     330                 :            : "--\n"
     331                 :            : "\n"
     332                 :            : "Num of `acquire()`s minus num of `release()`s for this process.");
     333                 :            : 
     334                 :            : #define _MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF    \
     335                 :            :     {"_count", (PyCFunction)_multiprocessing_SemLock__count, METH_NOARGS, _multiprocessing_SemLock__count__doc__},
     336                 :            : 
     337                 :            : static PyObject *
     338                 :            : _multiprocessing_SemLock__count_impl(SemLockObject *self);
     339                 :            : 
     340                 :            : static PyObject *
     341                 :          0 : _multiprocessing_SemLock__count(SemLockObject *self, PyObject *Py_UNUSED(ignored))
     342                 :            : {
     343                 :          0 :     return _multiprocessing_SemLock__count_impl(self);
     344                 :            : }
     345                 :            : 
     346                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) */
     347                 :            : 
     348                 :            : #if defined(HAVE_MP_SEMAPHORE)
     349                 :            : 
     350                 :            : PyDoc_STRVAR(_multiprocessing_SemLock__is_mine__doc__,
     351                 :            : "_is_mine($self, /)\n"
     352                 :            : "--\n"
     353                 :            : "\n"
     354                 :            : "Whether the lock is owned by this thread.");
     355                 :            : 
     356                 :            : #define _MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF    \
     357                 :            :     {"_is_mine", (PyCFunction)_multiprocessing_SemLock__is_mine, METH_NOARGS, _multiprocessing_SemLock__is_mine__doc__},
     358                 :            : 
     359                 :            : static PyObject *
     360                 :            : _multiprocessing_SemLock__is_mine_impl(SemLockObject *self);
     361                 :            : 
     362                 :            : static PyObject *
     363                 :          0 : _multiprocessing_SemLock__is_mine(SemLockObject *self, PyObject *Py_UNUSED(ignored))
     364                 :            : {
     365                 :          0 :     return _multiprocessing_SemLock__is_mine_impl(self);
     366                 :            : }
     367                 :            : 
     368                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) */
     369                 :            : 
     370                 :            : #if defined(HAVE_MP_SEMAPHORE)
     371                 :            : 
     372                 :            : PyDoc_STRVAR(_multiprocessing_SemLock__get_value__doc__,
     373                 :            : "_get_value($self, /)\n"
     374                 :            : "--\n"
     375                 :            : "\n"
     376                 :            : "Get the value of the semaphore.");
     377                 :            : 
     378                 :            : #define _MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF    \
     379                 :            :     {"_get_value", (PyCFunction)_multiprocessing_SemLock__get_value, METH_NOARGS, _multiprocessing_SemLock__get_value__doc__},
     380                 :            : 
     381                 :            : static PyObject *
     382                 :            : _multiprocessing_SemLock__get_value_impl(SemLockObject *self);
     383                 :            : 
     384                 :            : static PyObject *
     385                 :          0 : _multiprocessing_SemLock__get_value(SemLockObject *self, PyObject *Py_UNUSED(ignored))
     386                 :            : {
     387                 :          0 :     return _multiprocessing_SemLock__get_value_impl(self);
     388                 :            : }
     389                 :            : 
     390                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) */
     391                 :            : 
     392                 :            : #if defined(HAVE_MP_SEMAPHORE)
     393                 :            : 
     394                 :            : PyDoc_STRVAR(_multiprocessing_SemLock__is_zero__doc__,
     395                 :            : "_is_zero($self, /)\n"
     396                 :            : "--\n"
     397                 :            : "\n"
     398                 :            : "Return whether semaphore has value zero.");
     399                 :            : 
     400                 :            : #define _MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF    \
     401                 :            :     {"_is_zero", (PyCFunction)_multiprocessing_SemLock__is_zero, METH_NOARGS, _multiprocessing_SemLock__is_zero__doc__},
     402                 :            : 
     403                 :            : static PyObject *
     404                 :            : _multiprocessing_SemLock__is_zero_impl(SemLockObject *self);
     405                 :            : 
     406                 :            : static PyObject *
     407                 :          0 : _multiprocessing_SemLock__is_zero(SemLockObject *self, PyObject *Py_UNUSED(ignored))
     408                 :            : {
     409                 :          0 :     return _multiprocessing_SemLock__is_zero_impl(self);
     410                 :            : }
     411                 :            : 
     412                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) */
     413                 :            : 
     414                 :            : #if defined(HAVE_MP_SEMAPHORE)
     415                 :            : 
     416                 :            : PyDoc_STRVAR(_multiprocessing_SemLock__after_fork__doc__,
     417                 :            : "_after_fork($self, /)\n"
     418                 :            : "--\n"
     419                 :            : "\n"
     420                 :            : "Rezero the net acquisition count after fork().");
     421                 :            : 
     422                 :            : #define _MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF    \
     423                 :            :     {"_after_fork", (PyCFunction)_multiprocessing_SemLock__after_fork, METH_NOARGS, _multiprocessing_SemLock__after_fork__doc__},
     424                 :            : 
     425                 :            : static PyObject *
     426                 :            : _multiprocessing_SemLock__after_fork_impl(SemLockObject *self);
     427                 :            : 
     428                 :            : static PyObject *
     429                 :          0 : _multiprocessing_SemLock__after_fork(SemLockObject *self, PyObject *Py_UNUSED(ignored))
     430                 :            : {
     431                 :          0 :     return _multiprocessing_SemLock__after_fork_impl(self);
     432                 :            : }
     433                 :            : 
     434                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) */
     435                 :            : 
     436                 :            : #if defined(HAVE_MP_SEMAPHORE)
     437                 :            : 
     438                 :            : PyDoc_STRVAR(_multiprocessing_SemLock___enter____doc__,
     439                 :            : "__enter__($self, /)\n"
     440                 :            : "--\n"
     441                 :            : "\n"
     442                 :            : "Enter the semaphore/lock.");
     443                 :            : 
     444                 :            : #define _MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF    \
     445                 :            :     {"__enter__", (PyCFunction)_multiprocessing_SemLock___enter__, METH_NOARGS, _multiprocessing_SemLock___enter____doc__},
     446                 :            : 
     447                 :            : static PyObject *
     448                 :            : _multiprocessing_SemLock___enter___impl(SemLockObject *self);
     449                 :            : 
     450                 :            : static PyObject *
     451                 :          0 : _multiprocessing_SemLock___enter__(SemLockObject *self, PyObject *Py_UNUSED(ignored))
     452                 :            : {
     453                 :          0 :     return _multiprocessing_SemLock___enter___impl(self);
     454                 :            : }
     455                 :            : 
     456                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) */
     457                 :            : 
     458                 :            : #if defined(HAVE_MP_SEMAPHORE)
     459                 :            : 
     460                 :            : PyDoc_STRVAR(_multiprocessing_SemLock___exit____doc__,
     461                 :            : "__exit__($self, exc_type=None, exc_value=None, exc_tb=None, /)\n"
     462                 :            : "--\n"
     463                 :            : "\n"
     464                 :            : "Exit the semaphore/lock.");
     465                 :            : 
     466                 :            : #define _MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF    \
     467                 :            :     {"__exit__", _PyCFunction_CAST(_multiprocessing_SemLock___exit__), METH_FASTCALL, _multiprocessing_SemLock___exit____doc__},
     468                 :            : 
     469                 :            : static PyObject *
     470                 :            : _multiprocessing_SemLock___exit___impl(SemLockObject *self,
     471                 :            :                                        PyObject *exc_type,
     472                 :            :                                        PyObject *exc_value, PyObject *exc_tb);
     473                 :            : 
     474                 :            : static PyObject *
     475                 :          0 : _multiprocessing_SemLock___exit__(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs)
     476                 :            : {
     477                 :          0 :     PyObject *return_value = NULL;
     478                 :          0 :     PyObject *exc_type = Py_None;
     479                 :          0 :     PyObject *exc_value = Py_None;
     480                 :          0 :     PyObject *exc_tb = Py_None;
     481                 :            : 
     482   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("__exit__", nargs, 0, 3)) {
                   #  # ]
     483                 :          0 :         goto exit;
     484                 :            :     }
     485         [ #  # ]:          0 :     if (nargs < 1) {
     486                 :          0 :         goto skip_optional;
     487                 :            :     }
     488                 :          0 :     exc_type = args[0];
     489         [ #  # ]:          0 :     if (nargs < 2) {
     490                 :          0 :         goto skip_optional;
     491                 :            :     }
     492                 :          0 :     exc_value = args[1];
     493         [ #  # ]:          0 :     if (nargs < 3) {
     494                 :          0 :         goto skip_optional;
     495                 :            :     }
     496                 :          0 :     exc_tb = args[2];
     497                 :          0 : skip_optional:
     498                 :          0 :     return_value = _multiprocessing_SemLock___exit___impl(self, exc_type, exc_value, exc_tb);
     499                 :            : 
     500                 :          0 : exit:
     501                 :          0 :     return return_value;
     502                 :            : }
     503                 :            : 
     504                 :            : #endif /* defined(HAVE_MP_SEMAPHORE) */
     505                 :            : 
     506                 :            : #ifndef _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
     507                 :            :     #define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
     508                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF) */
     509                 :            : 
     510                 :            : #ifndef _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
     511                 :            :     #define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
     512                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF) */
     513                 :            : 
     514                 :            : #ifndef _MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF
     515                 :            :     #define _MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF
     516                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF) */
     517                 :            : 
     518                 :            : #ifndef _MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF
     519                 :            :     #define _MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF
     520                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF) */
     521                 :            : 
     522                 :            : #ifndef _MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF
     523                 :            :     #define _MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF
     524                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF) */
     525                 :            : 
     526                 :            : #ifndef _MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF
     527                 :            :     #define _MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF
     528                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF) */
     529                 :            : 
     530                 :            : #ifndef _MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF
     531                 :            :     #define _MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF
     532                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF) */
     533                 :            : 
     534                 :            : #ifndef _MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF
     535                 :            :     #define _MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF
     536                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF) */
     537                 :            : 
     538                 :            : #ifndef _MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF
     539                 :            :     #define _MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF
     540                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF) */
     541                 :            : 
     542                 :            : #ifndef _MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF
     543                 :            :     #define _MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF
     544                 :            : #endif /* !defined(_MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF) */
     545                 :            : /*[clinic end generated code: output=dae57a702cc01512 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14