예제 #1
0
파일: cdlopen.c 프로젝트: 18600597055/hue
static PyObject *ffi_dlclose(PyObject *self, PyObject *args)
{
    LibObject *lib;
    void *libhandle;
    if (!PyArg_ParseTuple(args, "O!", &Lib_Type, &lib))
        return NULL;

    libhandle = lib->l_libhandle;
    lib->l_libhandle = NULL;

    if (libhandle == NULL) {
        PyErr_Format(FFIError, "library '%s' is already closed "
                     "or was not created with ffi.dlopen()",
                     PyText_AS_UTF8(lib->l_libname));
        return NULL;
    }

    /* Clear the dict to force further accesses to do cdlopen_fetch()
       again, and fail because the library was closed. */
    PyDict_Clear(lib->l_dict);

    if (cdlopen_close(lib->l_libname, libhandle) < 0)
        return NULL;

    Py_INCREF(Py_None);
    return Py_None;
}
예제 #2
0
      void initRegNamespace(PyObject* registersDict) {
        PyDict_Clear(registersDict);

        PyObject* x86RegistersDict      = xPyDict_New();
        PyObject* x86RegistersDictClass = xPyClass_New(nullptr, x86RegistersDict, xPyString_FromString("X86"));
        xPyDict_SetItemString(registersDict, "X86", x86RegistersDictClass);

        // Init X86 REG namespace
        #define REG_SPEC(UPPER_NAME, LOWER_NAME, X86_64_UPPER, X86_64_LOWER, X86_64_PARENT, X86_UPPER, X86_LOWER, X86_PARENT, X86_AVAIL)  \
          if (X86_AVAIL)                                                                                                                  \
            xPyDict_SetItemString(x86RegistersDict, #UPPER_NAME, PyLong_FromUint32(triton::arch::ID_REG_##UPPER_NAME));
        // Use REG not available in capstone as normal register
        #define REG_SPEC_NO_CAPSTONE REG_SPEC
        #include "triton/x86.spec"

        PyObject* x8664RegistersDict      = xPyDict_New();
        PyObject* x8664RegistersDictClass = xPyClass_New(nullptr, x8664RegistersDict, xPyString_FromString("X86_64"));
        xPyDict_SetItemString(registersDict, "X86_64", x8664RegistersDictClass);

        // Init X86_64 REG namespace
        #define REG_SPEC(UPPER_NAME, LOWER_NAME, X86_64_UPPER, X86_64_LOWER, X86_64_PARENT, X86_UPPER, X86_LOWER, X86_PARENT, X86_AVAIL)  \
          xPyDict_SetItemString(x8664RegistersDict, #UPPER_NAME, PyLong_FromUint32(triton::arch::ID_REG_##UPPER_NAME));
        // Use REG not available in capstone as normal register
        #define REG_SPEC_NO_CAPSTONE REG_SPEC
        #include "triton/x86.spec"
      }
예제 #3
0
/* atexit() handler that'll call unload_add_on() for every item in the
 * dictionary.
 */
static void beos_cleanup_dyn( void )
{
	if( beos_dyn_images ) {
		int idx;
		int list_size;
		PyObject *id_list;

#ifdef WITH_THREAD
		PyThread_acquire_lock( beos_dyn_lock, 1 );
#endif

		id_list = PyDict_Values( beos_dyn_images );

		list_size = PyList_Size( id_list );
		for( idx = 0; idx < list_size; idx++ ) {
			PyObject *the_item;
			
			the_item = PyList_GetItem( id_list, idx );
			beos_nuke_dyn( the_item );
		}

		PyDict_Clear( beos_dyn_images );

#ifdef WITH_THREAD
		PyThread_free_lock( beos_dyn_lock );
#endif
	}
}
예제 #4
0
static inline void
clean_cli(client_t *client)
{
    write_access_log(client, log_fd, log_path);
    if(client->req){
        free_request(client->req);
        client->req = NULL;
    }
    Py_CLEAR(client->http_status);
    Py_CLEAR(client->headers);
    Py_CLEAR(client->response_iter);
    
    Py_CLEAR(client->response);
#ifdef DEBUG
    printf("clean_cli environ status_code %d address %p \n", client->status_code, client->environ);
#endif
    if(client->environ){ 
        PyDict_Clear(client->environ);
        Py_DECREF(client->environ);
    }
    if(client->body){
        if(client->body_type == BODY_TYPE_TMPFILE){
            fclose(client->body);
        }else{
            free_buffer(client->body);
        }
        client->body = NULL;
    }
    client->header_done = 0;
    client->response_closed = 0;
    client->chunked_response = 0;
    client->content_length_set = 0;
    client->content_length = 0;
    client->write_bytes = 0;
}
예제 #5
0
PyObject *SCA_PythonKeyboard::pyattr_get_active_events(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
	SCA_PythonKeyboard* self = static_cast<SCA_PythonKeyboard*>(self_v);

	PyDict_Clear(self->m_event_dict);

	for (int i=SCA_IInputDevice::BEGINKEY; i<=SCA_IInputDevice::ENDKEY; i++)
	{
		SCA_InputEvent& input = self->m_keyboard->GetInput((SCA_IInputDevice::SCA_EnumInputs)i);

		if (input.Find(SCA_InputEvent::ACTIVE)) {
			int event = 0;
			if (input.m_queue.size() > 0) {
				event = input.m_queue[input.m_queue.size() - 1];
			}
			else {
				event = input.m_status[input.m_status.size() - 1];
			}

			PyObject *key = PyLong_FromLong(i);
			PyObject *value = PyLong_FromLong(event);

			PyDict_SetItem(self->m_event_dict, key, value);

			Py_DECREF(key);
			Py_DECREF(value);
		}
	}
	Py_INCREF(self->m_event_dict);
	return self->m_event_dict;
}
예제 #6
0
PyObject *
convertToDistArray(Domi::MDVector< Scalar > & mdVector)
{
  PyObject * distArrayProtocol;
  PyObject * buffer;
  PyObject * dimData;

  distArrayProtocol = PyDict_New();
  if (!distArrayProtocol) goto fail;
  if (PyDict_SetItemString(distArrayProtocol, "__version__",
                           Py_BuildValue("s","0.10.0")) == -1) goto fail;

  buffer = convertToNumPyArray(mdVector.getDataNonConst());
  if (!buffer) goto fail;
  if (PyDict_SetItemString(distArrayProtocol, "buffer", buffer) == -1)
    goto fail;

  dimData = convertToDimData(mdVector.getMDMap());
  if (!dimData) goto fail;
  if (PyDict_SetItemString(distArrayProtocol, "dim_data", dimData) == -1)
    goto fail;

  Py_DECREF(buffer);
  Py_DECREF(dimData);
  return distArrayProtocol;

  fail:
  if (distArrayProtocol) PyDict_Clear(distArrayProtocol);
  Py_XDECREF(distArrayProtocol);
  Py_XDECREF(buffer);
  Py_XDECREF(dimData);
  return NULL;
}
예제 #7
0
SCA_PythonKeyboard::~SCA_PythonKeyboard()
{
#ifdef WITH_PYTHON
	PyDict_Clear(m_event_dict);
	Py_DECREF(m_event_dict);
#endif
}
예제 #8
0
SCA_PythonMouse::~SCA_PythonMouse()
{
#ifdef WITH_PYTHON
	PyDict_Clear(m_event_dict);
	Py_DECREF(m_event_dict);
#endif
}
예제 #9
0
파일: dict.cpp 프로젝트: NeoAnomaly/xray
void dict_base::clear()
{
    if (check_exact(this))
        PyDict_Clear(this->ptr());
    else
        this->attr("clear")();
}
예제 #10
0
파일: xslt_root.c 프로젝트: abed-hawa/amara
void XsltRoot_Fini(void)
{
  Py_DECREF(setup_string);
  Py_DECREF(validate_string);
  Py_DECREF(prime_string);
  Py_DECREF(teardown_string);
  PyDict_Clear(XsltRoot_Type.tp_dict);
}
예제 #11
0
static void
planner_python_env_free (PlannerPythonEnv *env)
{
	g_free (env->filename);
	PyDict_Clear (env->globals);
	Py_DECREF (env->globals);
	g_free (env);
}
예제 #12
0
SCPyDictArg::~SCPyDictArg() {
  PYLOCK;

  if (NULL != pPyObject) {
    PyDict_Clear(pPyObject);
  }
  Py_XDECREF(pPyObject); 
}
예제 #13
0
static PyObject * pyGetRecords(PyObject *self, PyObject *args) {

    // retrieve 2 input parameters in char * format
    char *searchKey, *searchVal;
    if (!PyArg_ParseTuple(args, "ss", &searchKey, &searchVal)) {
        return Py_BuildValue("i", 1);   // ERROR - PyArg_ParseTuple
    }

    // get all recID that matches the searckKey and searchVal
    int *allId;
    unsigned recCount;
    MEsearchId(dbhandle, searchKey, searchVal, &allId, &recCount);
    if (recCount == 0) {
        return Py_BuildValue("i", 2);   // ERROR - no record found
    }

    // build output dict object
    int rc, i, j;
    unsigned size;
    long recid, dict_size;
    char *allData, *key, *val;
    PyObject* py_rdict;
    PyObject* py_adict;
    PyObject* py_key;
    PyObject* py_val;
    py_rdict = PyDict_New();
    py_adict = PyDict_New();

    // loop through all recIDs
    for ( i=0; i<recCount; ++i ) {
        recid = *(allId+i);
        PyDict_Clear(py_adict);

        // create kv and add to py_dict (recid: recid[searchKey])
        MEgetAllFieldsById(dbhandle, recid, &allData, &size);
        for (j=0; j<size; j+=2) {
            key = allData+j*ME_STRING_MAX_LENGTH;
            val = allData+(j+1)*ME_STRING_MAX_LENGTH;
            if (debugMode) {
                printf( "%i: %s %s\n", recid, key, val);
            }
            py_key = PyString_FromString(key);
            py_val = PyString_FromString(val);
            PyDict_SetItem(py_adict, py_key, py_val);
        }
        py_key = PyInt_FromLong(recid);
        PyDict_SetItem(py_rdict, py_key, PyDict_Copy(py_adict));
        free(allData);
    }
    free(allId);
    
    if (debugMode) {
        printf("pyGetRecords: records retrieved: %i\n", recCount);
    }

    // return 2 parameters: rc, dict
    return Py_BuildValue("iO", 0, py_rdict);
}
예제 #14
0
/**
 * Execute the current script
 * We are now in the thread.
 */
void PyApi::ExecuteInThread() const
{
  assert(Py_IsInitialized() );
  
  // get the lock so we can change things.
  PyEval_AcquireLock();

  // make sure that the main thread is the active one.
  const auto  mainInterpreterState = _mainThreadState->interp;
  PyThreadState_Swap(_mainThreadState);

  // create a new thread.
  const auto  myThreadState =  PyThreadState_New(mainInterpreterState);

  // make sure that the new thread has control
  // https://docs.python.org/3/c-api/init.html
  PyThreadState_Swap(myThreadState);

  //  execute it...
  {
    const auto main_module = PyImport_AddModule("__main__");
    const auto main_dict = PyModule_GetDict(main_module);
    Py_XINCREF(main_module);
 
    const auto local_dic = PyDict_New();
    Py_XINCREF(local_dic);

    // we can now run our script
    const auto s = _script.c_str();
    const auto pyRes = PyRun_String(s, Py_file_input, main_dict, local_dic);

    CheckForPythonErrors();

    PyDict_Clear(local_dic);
    Py_XDECREF(local_dic);

    // pending calls must be cleared out
    Py_XDECREF(main_module);
  }

  // swap back to this thread.
  PyThreadState_Swap(myThreadState);

  // clear anything left behind.
  PyThreadState_Clear(myThreadState);

  PyThreadState_Swap(nullptr);

  // delete my thread.
  PyThreadState_Delete(myThreadState);

  //  give control back to main thread
  PyThreadState_Swap(_mainThreadState);

  // release the lock one last time.
  PyEval_ReleaseLock();
}
예제 #15
0
void pyscript_clear_modules(PyObject *script)
{
    PyScript *self;

    g_return_if_fail(pyscript_check(script));

    self = (PyScript *) script;

    PyDict_Clear(self->modules);
}
예제 #16
0
static PyObject *
lru_cache_cache_clear(lru_cache_object *self, PyObject *unused)
{
    lru_list_elem *list = lru_cache_unlink_list(self);
    self->hits = self->misses = 0;
    self->full = 0;
    PyDict_Clear(self->cache);
    lru_cache_clear_list(list);
    Py_RETURN_NONE;
}
예제 #17
0
static PyObject *
pickle___setstate__(PyObject *self, PyObject *state)
{
    PyObject *slots=NULL;

    if (PyTuple_Check(state))
    {
        if (!PyArg_ParseTuple(state, "OO:__setstate__", &state, &slots))
            return NULL;
    }

    if (state != Py_None)
    {
        PyObject **dict;
        PyObject *d_key, *d_value;
        Py_ssize_t i;

        dict = _PyObject_GetDictPtr(self);
        
        if (!dict)
        {
            PyErr_SetString(PyExc_TypeError,
                            "this object has no instance dictionary");
            return NULL;
        }

        if (!*dict)
        {
            *dict = PyDict_New();
            if (!*dict)
                return NULL;
        }

        PyDict_Clear(*dict);

        i = 0;
        while (PyDict_Next(state, &i, &d_key, &d_value)) {
            /* normally the keys for instance attributes are
               interned.  we should try to do that here. */
            if (NATIVE_CHECK_EXACT(d_key)) {
                Py_INCREF(d_key);
                INTERN_INPLACE(&d_key);
                Py_DECREF(d_key);
            }
            if (PyObject_SetItem(*dict, d_key, d_value) < 0)
                return NULL;
        }
    }

    if (slots && pickle_setattrs_from_dict(self, slots) < 0)
        return NULL;

    Py_INCREF(Py_None);
    return Py_None;
}
예제 #18
0
/*
 * fcgi_Request methods
 */
static PyObject *
fcgi_Request_accept(fcgi_Request *self)
{
    int rc;
    char **e;

    Py_BEGIN_ALLOW_THREADS
    rc = FCGX_Accept_r(&self->r);
    Py_END_ALLOW_THREADS

    if (rc < 0) {
        /*
         * FCGX_Accept_r returns (0 - errno) on error,
         * so PyErr_SetFromErrno should work just fine
         */
        PyErr_SetFromErrno(PyExc_IOError);
        return NULL;
    }

    /* clear any existing environment */
    PyDict_Clear(self->env);

    if (self->r.envp == NULL) {
        Py_RETURN_NONE;
    }

    /* fill in the environment */
    for (e = self->r.envp; *e != NULL; e++)
    {
        PyObject *k, *v;
        char *p = strchr(*e, '=');
        if (p == NULL)
            continue;
        k = PyString_FromStringAndSize(*e, (int)(p-*e));
        if (k == NULL) {
            PyErr_Clear();
            continue;
        }
        v = PyString_FromString(p + 1);
        if (v == NULL) {
            PyErr_Clear();
            Py_DECREF(k);
            continue;
        }

        if (PyDict_SetItem(self->env, k, v) != 0)
            PyErr_Clear();

        Py_DECREF(k);
        Py_DECREF(v);
    }

    Py_RETURN_NONE;
}
예제 #19
0
SCA_PythonJoystick::~SCA_PythonJoystick()
{
	// The joystick reference we got in the constructor was a new instance,
	// so we release it here
	m_joystick->ReleaseInstance();

#ifdef WITH_PYTHON
	PyDict_Clear(m_event_dict);
	Py_DECREF(m_event_dict);
#endif
}
예제 #20
0
void *
pbs_python_ext_namespace_init(
	struct python_interpreter_data *interp_data)
{
	static char func_id[] = "pbs_python_namespace_init";

#ifdef PYTHON                        /* --- BEGIN PYTHON BLOCK --- */

	PyObject *namespace_dict = (PyObject *) NULL;

	namespace_dict = PyDict_New(); /* New Refrence MUST Decref */
	if (!namespace_dict) {
		pbs_python_write_error_to_log(func_id);
		goto ERROR_EXIT;
	}
	/*
	 * setup our namespace, by including all the modules that are needed to
	 * run the python scripts
	 */
	if ((PyDict_SetItemString(namespace_dict, "__builtins__",
		PyEval_GetBuiltins()) == -1)
		) {
		pbs_python_write_error_to_log(func_id);
		goto ERROR_EXIT;
	}

	/*
	 * Now, add our extension object/module to the namespace.
	 */
	if ((PyDict_SetItemString(namespace_dict,
		PBS_PYTHON_V1_MODULE_EXTENSION_NAME,
		pbs_v1_module_init()) == -1)
		) {
		snprintf(log_buffer, LOG_BUF_SIZE-1, "%s|adding extension object",
			func_id);
		log_buffer[LOG_BUF_SIZE-1] = '\0';
		pbs_python_write_error_to_log(func_id);
		goto ERROR_EXIT;
	}

	return namespace_dict;

ERROR_EXIT:
	if (namespace_dict) {
		PyDict_Clear(namespace_dict);
		Py_CLEAR(namespace_dict);
	}
	return namespace_dict;

#else	/* !PYTHON */
	return (void *) NULL;
#endif  /* --- END   PYTHON BLOCK --- */

}
예제 #21
0
파일: entity.c 프로젝트: abed-hawa/amara
static PyObject *entity_setstate(PyObject *self, PyObject *state)
{
  PyObject *dict, *public_id, *system_id, *unparsed_entities, *children, *temp;
  Py_ssize_t i, n;

  if (!PyArg_UnpackTuple(state, NULL, 5, 5,
                         &dict, &public_id, &system_id, &unparsed_entities,
                         &children))
    return NULL;

  if (!convert_arg(0, &PyDict_Type, &dict))
    return NULL;
  if (!convert_arg(3, &PyDict_Type, &unparsed_entities))
    return NULL;
  if (!convert_arg(4, &PyTuple_Type, &children))
    return NULL;

  if (dict) {
    if (PyType_HasFeature(self->ob_type, Py_TPFLAGS_HEAPTYPE)) {
      temp = PyObject_GetAttrString(self, "__dict__");
      if (temp == NULL)
        return NULL;
      if (PyDict_Update(temp, dict) < 0) {
        Py_DECREF(temp);
        return NULL;
      }
      Py_DECREF(temp);
    }
  }
  temp = Entity_GET_PUBLIC_ID(self);
  Entity_SET_PUBLIC_ID(self, public_id);
  Py_INCREF(public_id);
  Py_DECREF(temp);

  temp = Entity_GET_SYSTEM_ID(self);
  Entity_SET_SYSTEM_ID(self, system_id);
  Py_INCREF(system_id);
  Py_DECREF(temp);

  if (unparsed_entities) {
    temp = Entity_GET_UNPARSED_ENTITIES(self);
    PyDict_Clear(temp);
    if (PyDict_Update(temp, unparsed_entities) < 0)
      return NULL;
  }
  if (children) {
    for (i = 0, n = PyTuple_GET_SIZE(children); i < n; i++) {
      NodeObject *node = (NodeObject *)PyTuple_GET_ITEM(children, i);
      if (Container_Append((NodeObject *)self, node) < 0)
        return NULL;
    }
  }
  Py_RETURN_NONE;
}
예제 #22
0
      void initX86PrefixesNamespace(void) {
        if (!triton::bindings::python::initialized)
          return;

        PyDict_Clear(triton::bindings::python::prefixesDict);

        PyDict_SetItemString(triton::bindings::python::prefixesDict, "INVALID", PyLong_FromUint(triton::arch::x86::ID_PREFIX_INVALID));
        PyDict_SetItemString(triton::bindings::python::prefixesDict, "LOCK",    PyLong_FromUint(triton::arch::x86::ID_PREFIX_LOCK));
        PyDict_SetItemString(triton::bindings::python::prefixesDict, "REP",     PyLong_FromUint(triton::arch::x86::ID_PREFIX_REP));
        PyDict_SetItemString(triton::bindings::python::prefixesDict, "REPE",    PyLong_FromUint(triton::arch::x86::ID_PREFIX_REPE));
        PyDict_SetItemString(triton::bindings::python::prefixesDict, "REPNE",   PyLong_FromUint(triton::arch::x86::ID_PREFIX_REPNE));
      }
예제 #23
0
SCA_PythonController::~SCA_PythonController()
{

#ifdef WITH_PYTHON
	Py_XDECREF(m_bytecode);
	Py_XDECREF(m_function);
	
	if (m_pythondictionary) {
		// break any circular references in the dictionary
		PyDict_Clear(m_pythondictionary);
		Py_DECREF(m_pythondictionary);
	}
#endif
}
예제 #24
0
static PyObject *t_lm_dict_clear(t_lm *self, PyObject *args)
{
    PyDict_Clear(self->dict);
    if (self->aliases != Nil)
    {
        Py_DECREF(self->aliases);
        self->aliases = Nil; Py_INCREF(Nil);
    }

    t_lm___setFirstKey(self, Py_None, NULL);
    t_lm___setLastKey(self, Py_None, NULL);

    Py_RETURN_NONE;
}
예제 #25
0
void SCA_PythonController::SetNamespace(PyObject*	pythondictionary)
{
	if (m_pythondictionary)
	{
		PyDict_Clear(m_pythondictionary);
		Py_DECREF(m_pythondictionary);
	}
	m_pythondictionary = PyDict_Copy(pythondictionary); /* new reference */
	
	/* Without __file__ set the sys.argv[0] is used for the filename
	 * which ends up with lines from the blender binary being printed in the console */
	PyDict_SetItemString(m_pythondictionary, "__file__", PyUnicode_FromString(m_scriptName.Ptr()));
	
}
예제 #26
0
static PyObject *
GlobalHotkey_unbind_all (GlobalHotkey *self)
{
  PyObject *key, *value;
  Py_ssize_t pos = 0;
  char *str_key;

  while (PyDict_Next (self->binded, &pos, &key, &value))
    {
      str_key = PyString_AsString (key);
      keybinder_unbind (str_key, caller);
    }

  PyDict_Clear (self->binded);
  return Py_BuildValue ("i", 1);
}
예제 #27
0
파일: lru.c 프로젝트: pombredanne/lru-dict
static PyObject *
LRU_clear(LRU *self)
{
    Node *c = self->first;

    while (c) {
        Node* n = c;
        c = c->next;
        lru_remove_node(self, n);
    }
    PyDict_Clear(self->dict);

    self->hits = 0;
    self->misses = 0;
    Py_RETURN_NONE;
}
PyObject* SCA_PythonKeyboard::pyattr_get_active_events(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
{
	SCA_PythonKeyboard* self = static_cast<SCA_PythonKeyboard*>(self_v);

	PyDict_Clear(self->m_event_dict);
	
	for (int i=SCA_IInputDevice::KX_BEGINKEY; i<=SCA_IInputDevice::KX_ENDKEY; i++)
	{
		const SCA_InputEvent & inevent = self->m_keyboard->GetEventValue((SCA_IInputDevice::KX_EnumInputs)i);
		
		if (inevent.m_status != SCA_InputEvent::KX_NO_INPUTSTATUS)
			PyDict_SetItem(self->m_event_dict, PyLong_FromSsize_t(i), PyLong_FromSsize_t(inevent.m_status));
	}
	Py_INCREF(self->m_event_dict);
	return self->m_event_dict;
}
예제 #29
0
/* Update function, it gets rid of pydrivers global dictionary, forcing
 * BPY_driver_exec to recreate it. This function is used to force
 * reloading the Blender text module "pydrivers.py", if available, so
 * updates in it reach pydriver evaluation.
 */
void BPY_driver_reset(void)
{
	PyGILState_STATE gilstate;
	int use_gil= 1; // (PyThreadState_Get()==NULL);

	if(use_gil)
		gilstate = PyGILState_Ensure();

	if (bpy_pydriver_Dict) { /* free the global dict used by pydrivers */
		PyDict_Clear(bpy_pydriver_Dict);
		Py_DECREF(bpy_pydriver_Dict);
		bpy_pydriver_Dict = NULL;
	}

	if(use_gil)
		PyGILState_Release(gilstate);

	return;
}
예제 #30
0
static PyObject *
pickle___setstate__(PyObject *self, PyObject *state)
{
  PyObject *slots=NULL;

  if (PyTuple_Check(state))
    {
      if (! PyArg_ParseTuple(state, "OO", &state, &slots))
        return NULL;
    }

  if (state != Py_None)
    {
      PyObject **dict;

      dict = _PyObject_GetDictPtr(self);
      if (dict)
        {
          if (*dict == NULL)
            {
              *dict = PyDict_New();
              if (*dict == NULL)
                return NULL;
            }
        }

      if (*dict != NULL)
        {
          PyDict_Clear(*dict);
          if (PyDict_Update(*dict, state) < 0)
            return NULL;
        }
      else if (pickle_setattrs_from_dict(self, state) < 0)
        return NULL;
    }

  if (slots != NULL && pickle_setattrs_from_dict(self, slots) < 0)
    return NULL;

  Py_INCREF(Py_None);
  return Py_None;
}