AEDesc_Convert, &contextName, &parentContext)) return NULL; _err = OSAMakeContext(_self->ob_itself, &contextName, parentContext, &resultingContextID); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("l", resultingContextID); return _res; } static PyMethodDef OSAObj_methods[] = { {"OSALoad", (PyCFunction)OSAObj_OSALoad, 1, PyDoc_STR("(AEDesc scriptData, long modeFlags) -> (OSAID resultingScriptID)")}, {"OSAStore", (PyCFunction)OSAObj_OSAStore, 1, PyDoc_STR("(OSAID scriptID, DescType desiredType, long modeFlags) -> (AEDesc resultingScriptData)")}, {"OSAExecute", (PyCFunction)OSAObj_OSAExecute, 1, PyDoc_STR("(OSAID compiledScriptID, OSAID contextID, long modeFlags) -> (OSAID resultingScriptValueID)")}, {"OSADisplay", (PyCFunction)OSAObj_OSADisplay, 1, PyDoc_STR("(OSAID scriptValueID, DescType desiredType, long modeFlags) -> (AEDesc resultingText)")}, {"OSAScriptError", (PyCFunction)OSAObj_OSAScriptError, 1, PyDoc_STR("(OSType selector, DescType desiredType) -> (AEDesc resultingErrorDescription)")}, {"OSADispose", (PyCFunction)OSAObj_OSADispose, 1, PyDoc_STR("(OSAID scriptID) -> None")}, {"OSASetScriptInfo", (PyCFunction)OSAObj_OSASetScriptInfo, 1, PyDoc_STR("(OSAID scriptID, OSType selector, long value) -> None")}, {"OSAGetScriptInfo", (PyCFunction)OSAObj_OSAGetScriptInfo, 1, PyDoc_STR("(OSAID scriptID, OSType selector) -> (long result)")}, {"OSAScriptingComponentName", (PyCFunction)OSAObj_OSAScriptingComponentName, 1,
if (!PyArg_ParseTuple(_args, "hl", &vRefNum, &dirID)) return NULL; _err = IdentifyFolder(vRefNum, dirID, &foldType); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", PyMac_BuildOSType, foldType); return _res; } static PyMethodDef Folder_methods[] = { {"FindFolder", (PyCFunction)Folder_FindFolder, 1, PyDoc_STR("(short vRefNum, OSType folderType, Boolean createFolder) -> (short foundVRefNum, long foundDirID)")}, {"ReleaseFolder", (PyCFunction)Folder_ReleaseFolder, 1, PyDoc_STR("(short vRefNum, OSType folderType) -> None")}, {"FSFindFolder", (PyCFunction)Folder_FSFindFolder, 1, PyDoc_STR("(short vRefNum, OSType folderType, Boolean createFolder) -> (FSRef foundRef)")}, {"AddFolderDescriptor", (PyCFunction)Folder_AddFolderDescriptor, 1, PyDoc_STR("(FolderType foldType, FolderDescFlags flags, FolderClass foldClass, FolderLocation foldLocation, OSType badgeSignature, OSType badgeType, Str255 name, Boolean replaceFlag) -> None")}, {"GetFolderTypes", (PyCFunction)Folder_GetFolderTypes, 1, PyDoc_STR("(UInt32 requestedTypeCount) -> (UInt32 totalTypeCount, FolderType theTypes)")}, {"RemoveFolderDescriptor", (PyCFunction)Folder_RemoveFolderDescriptor, 1, PyDoc_STR("(FolderType foldType) -> None")}, #ifndef __LP64__ {"GetFolderName", (PyCFunction)Folder_GetFolderName, 1, PyDoc_STR("(short vRefNum, OSType foldType, Str255 name) -> (short foundVRefNum)")}, {"AddFolderRouting", (PyCFunction)Folder_AddFolderRouting, 1, PyDoc_STR("(OSType fileType, FolderType routeFromFolder, FolderType routeToFolder, RoutingFlags flags, Boolean replaceFlag) -> None")},
OptResObj_Convert, &mouseregion)) return NULL; _rv = WaitNextEvent(eventMask, &theEvent, sleep, (RgnHandle)mouseregion); _res = Py_BuildValue("bO&", _rv, PyMac_BuildEventRecord, &theEvent); return _res; } static PyMethodDef Evt_methods[] = { {"GetMouse", (PyCFunction)Evt_GetMouse, 1, PyDoc_STR("() -> (Point mouseLoc)")}, {"Button", (PyCFunction)Evt_Button, 1, PyDoc_STR("() -> (Boolean _rv)")}, {"StillDown", (PyCFunction)Evt_StillDown, 1, PyDoc_STR("() -> (Boolean _rv)")}, {"WaitMouseUp", (PyCFunction)Evt_WaitMouseUp, 1, PyDoc_STR("() -> (Boolean _rv)")}, {"GetCaretTime", (PyCFunction)Evt_GetCaretTime, 1, PyDoc_STR("() -> (UInt32 _rv)")}, {"GetKeys", (PyCFunction)Evt_GetKeys, 1, PyDoc_STR("() -> (KeyMap theKeys)")}, {"GetDblTime", (PyCFunction)Evt_GetDblTime, 1, PyDoc_STR("() -> (UInt32 _rv)")}, {"SetEventMask", (PyCFunction)Evt_SetEventMask, 1, PyDoc_STR("(EventMask value) -> None")}, {"GetNextEvent", (PyCFunction)Evt_GetNextEvent, 1,
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser Public License for more details. * * You should have received a copy of the GNU Lesser Public License * along with the ZBar Bar Code Reader; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301 USA * * http://sourceforge.net/projects/zbar *------------------------------------------------------------------------*/ #include "zbarmodule.h" static char symbolset_doc[] = PyDoc_STR( "symbol result container.\n" "\n" "collection of symbols."); static int symbolset_clear (zbarSymbolSet *self) { if(self->zsyms) { zbar_symbol_set_t *zsyms = (zbar_symbol_set_t*)self->zsyms; self->zsyms = NULL; zbar_symbol_set_ref(zsyms, -1); } return(0); } static void symbolset_dealloc (zbarSymbolSet *self)
Py_INCREF(Py_None); return Py_None; } void converters_init(PyObject* dict) { converters = PyDict_New(); if (!converters) { return; } PyDict_SetItemString(dict, "converters", converters); } static PyMethodDef module_methods[] = { {"connect", (PyCFunction)module_connect, METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Creates a connection.")}, {"complete_statement", (PyCFunction)module_complete, METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Checks if a string contains a complete SQL statement. Non-standard.")}, #ifdef HAVE_SHARED_CACHE {"enable_shared_cache", (PyCFunction)module_enable_shared_cache, METH_VARARGS|METH_KEYWORDS, PyDoc_STR("Enable or disable shared cache mode for the calling thread. Experimental/Non-standard.")}, #endif {"register_adapter", (PyCFunction)module_register_adapter, METH_VARARGS, PyDoc_STR("Registers an adapter with pysqlite's adapter registry. Non-standard.")}, {"register_converter", (PyCFunction)module_register_converter, METH_VARARGS, PyDoc_STR("Registers a converter with pysqlite. Non-standard.")}, {"adapt", (PyCFunction)psyco_microprotocols_adapt, METH_VARARGS, psyco_microprotocols_adapt_doc}, {"enable_callback_tracebacks", (PyCFunction)enable_callback_tracebacks, METH_VARARGS, PyDoc_STR("Enable or disable callback functions throwing errors to stderr.")}, {NULL, NULL} }; struct _IntConstantPair { char* constant_name; int constant_value; };
static int __Pyx_Generator_set_qualname(__pyx_GeneratorObject *self, PyObject *value) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) { #else if (unlikely(value == NULL || !PyString_Check(value))) { #endif PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } tmp = self->gi_qualname; Py_INCREF(value); self->gi_qualname = value; Py_XDECREF(tmp); return 0; } static PyGetSetDef __pyx_Generator_getsets[] = { {(char *) "__name__", (getter)__Pyx_Generator_get_name, (setter)__Pyx_Generator_set_name, (char*) PyDoc_STR("name of the generator"), 0}, {(char *) "__qualname__", (getter)__Pyx_Generator_get_qualname, (setter)__Pyx_Generator_set_qualname, (char*) PyDoc_STR("qualified name of the generator"), 0}, {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_Generator_memberlist[] = { {(char *) "gi_running", T_BOOL, offsetof(__pyx_GeneratorObject, is_running), READONLY, NULL}, {0, 0, 0, 0, 0} }; static PyMethodDef __pyx_Generator_methods[] = { {"send", (PyCFunction) __Pyx_Generator_Send, METH_O, 0}, {"throw", (PyCFunction) __Pyx_Generator_Throw, METH_VARARGS, 0}, {"close", (PyCFunction) __Pyx_Generator_Close, METH_NOARGS, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_GeneratorType_type = { PyVarObject_HEAD_INIT(0, 0) "generator", /*tp_name*/ sizeof(__pyx_GeneratorObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ (destructor) __Pyx_Generator_dealloc,/*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ 0, /*tp_doc*/ (traverseproc) __Pyx_Generator_traverse, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ offsetof(__pyx_GeneratorObject, gi_weakreflist), /*tp_weaklistoffset*/ 0, /*tp_iter*/ (iternextfunc) __Pyx_Generator_Next, /*tp_iternext*/ __pyx_Generator_methods, /*tp_methods*/ __pyx_Generator_memberlist, /*tp_members*/ __pyx_Generator_getsets, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ 0, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_del*/ #else __Pyx_Generator_del, /*tp_del*/ #endif 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 __Pyx_Generator_del, /*tp_finalize*/ #endif }; static __pyx_GeneratorObject *__Pyx_Generator_New(__pyx_generator_body_t body, PyObject *closure, PyObject *name, PyObject *qualname) { __pyx_GeneratorObject *gen = PyObject_GC_New(__pyx_GeneratorObject, &__pyx_GeneratorType_type); if (gen == NULL) return NULL; gen->body = body; gen->closure = closure; Py_XINCREF(closure); gen->is_running = 0; gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; gen->exc_type = NULL; gen->exc_value = NULL; gen->exc_traceback = NULL; gen->gi_weakreflist = NULL; Py_XINCREF(qualname); gen->gi_qualname = qualname; Py_XINCREF(name); gen->gi_name = name; PyObject_GC_Track(gen); return gen; }
args, kwds, "O!:eval_string", kwlist, &PyString_Type, &string_arg)) return NULL; PyObject *result = scm_with_guile( (void *(*)(void *))eval_string_wrapper, string_arg); if (result == NULL && !PyErr_Occurred()) PyErr_SetNone(guile_error); return result; } static PyMethodDef methods[] = { { "lookup", (PyCFunction)lookup, METH_KEYWORDS, PyDoc_STR("lookup(name)\n\n" "Return the variable bound to the symbol indicated by " "name. If there\nis no such binding or the symbol is not " "bound to a variable, signal\nan error.") }, { "define", (PyCFunction)define, METH_KEYWORDS, PyDoc_STR("define(name, value)\n\n" "Create a top level variable. If the named variable " "already exists,\njust change its value.") }, { "load", (PyCFunction)load, METH_KEYWORDS, PyDoc_STR("load(name)\n\n" "Load a file and evaluate its contents " "in the top-level environment.") }, { "eval_string", (PyCFunction)eval_string, METH_KEYWORDS, PyDoc_STR("eval_string(string)\n\n" "Parse string as Scheme, and evaluate the expressions it "
else { const char *name = PyModule_GetName(self); if (name) PyErr_Format(PyExc_TypeError, "%.200s.__dict__ is not a dictionary", name); } } Py_XDECREF(dict); return result; } static PyMethodDef module_methods[] = { {"__dir__", module_dir, METH_NOARGS, PyDoc_STR("__dir__() -> list\nspecialized dir() implementation")}, {0} }; PyDoc_STRVAR(module_doc, "module(name[, doc])\n\ \n\ Create a module object.\n\ The name must be a string; the optional doc argument can have any type."); PyTypeObject PyModule_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "module", /* tp_name */ sizeof(PyModuleObject), /* tp_size */ 0, /* tp_itemsize */
self->data.angle0 = angle0_arg; self->data.pitch0 = pitch0_arg; self->data.angle1 = angle1_arg; self->data.pitch1 = pitch1_arg; return 0; } static void FillAttr_dealloc(FillAttr *self) { self->ob_type->tp_free((PyObject *)self); } static PyMemberDef FillAttr_members[] = { { "type", T_INT, offsetof(FillAttr, data.type), 0, PyDoc_STR("") }, { "width", T_DOUBLE, offsetof(FillAttr, data.width), 0, PyDoc_STR("") }, { "angle0", T_INT, offsetof(FillAttr, data.angle0), 0, PyDoc_STR("") }, { "pitch0", T_DOUBLE, offsetof(FillAttr, data.pitch0), 0, PyDoc_STR("") }, { "angle1", T_INT, offsetof(FillAttr, data.angle1), 0, PyDoc_STR("") }, { "pitch1", T_DOUBLE, offsetof(FillAttr, data.pitch1), 0, PyDoc_STR("") }, { NULL } /* Sentinel */ }; PyTypeObject FillAttrType = { PyObject_HEAD_INIT(NULL)
error: if(ops != &_tnetstring_ops_bytes) { free(ops); Py_DECREF(encoding); } Py_DECREF(object); return NULL; } static PyMethodDef _tnetstring_methods[] = { {"load", (PyCFunction)_tnetstring_load, METH_VARARGS, PyDoc_STR("load(file,encoding=None) -> object\n" "This function reads a tnetstring from a file and parses it\n" "into a python object.")}, {"loads", (PyCFunction)_tnetstring_loads, METH_VARARGS, PyDoc_STR("loads(string,encoding=None) -> object\n" "This function parses a tnetstring into a python object.")}, {"pop", (PyCFunction)_tnetstring_pop, METH_VARARGS, PyDoc_STR("pop(string,encoding=None) -> (object, remain)\n" "This function parses a tnetstring into a python object.\n" "It returns a tuple giving the parsed object and a string\n" "containing any unparsed data.")},
static PyObject * LRU_get_size(LRU *self) { return Py_BuildValue("i", self->size); } static PyObject * LRU_get_stats(LRU *self) { return Py_BuildValue("nn", self->hits, self->misses); } static PyMethodDef LRU_methods[] = { {"keys", (PyCFunction)LRU_keys, METH_NOARGS, PyDoc_STR("L.keys() -> list of L's keys in MRU order")}, {"values", (PyCFunction)LRU_values, METH_NOARGS, PyDoc_STR("L.values() -> list of L's values in MRU order")}, {"items", (PyCFunction)LRU_items, METH_NOARGS, PyDoc_STR("L.items() -> list of L's items (key,value) in MRU order")}, {"has_key", (PyCFunction)LRU_contains, METH_VARARGS, PyDoc_STR("L.has_key(key) -> Check if key is there in L")}, {"get", (PyCFunction)LRU_get, METH_VARARGS, PyDoc_STR("L.get(key, instead) -> If L has key return its value, otherwise instead")}, {"set_size", (PyCFunction)LRU_set_size, METH_VARARGS, PyDoc_STR("L.set_size() -> set size of LRU")}, {"get_size", (PyCFunction)LRU_get_size, METH_NOARGS, PyDoc_STR("L.get_size() -> get size of LRU")}, {"clear", (PyCFunction)LRU_clear, METH_NOARGS, PyDoc_STR("L.clear() -> clear LRU")}, {"get_stats", (PyCFunction)LRU_get_stats, METH_NOARGS,
* other than a string object. */ if (value == NULL || !PyUnicode_Check(value)) { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } tmp = op->gi_qualname; Py_INCREF(value); op->gi_qualname = value; Py_DECREF(tmp); return 0; } static PyGetSetDef gen_getsetlist[] = { {"__name__", (getter)gen_get_name, (setter)gen_set_name, PyDoc_STR("name of the generator")}, {"__qualname__", (getter)gen_get_qualname, (setter)gen_set_qualname, PyDoc_STR("qualified name of the generator")}, {NULL} /* Sentinel */ }; static PyMemberDef gen_memberlist[] = { {"gi_frame", T_OBJECT, offsetof(PyGenObject, gi_frame), READONLY}, {"gi_running", T_BOOL, offsetof(PyGenObject, gi_running), READONLY}, {"gi_code", T_OBJECT, offsetof(PyGenObject, gi_code), READONLY}, {NULL} /* Sentinel */ }; static PyMethodDef gen_methods[] = { {"send",(PyCFunction)_PyGen_Send, METH_O, send_doc}, {"throw",(PyCFunction)gen_throw, METH_VARARGS, throw_doc},
#ifndef ComponentSetTarget PyMac_PRECHECK(ComponentSetTarget); #endif if (!PyArg_ParseTuple(_args, "O&", CmpInstObj_Convert, &target)) return NULL; _rv = ComponentSetTarget(_self->ob_itself, target); _res = Py_BuildValue("l", _rv); return _res; } static PyMethodDef CmpInstObj_methods[] = { {"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1, PyDoc_STR("() -> None")}, {"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1, PyDoc_STR("() -> None")}, {"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1, PyDoc_STR("(OSErr theError) -> None")}, {"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1, PyDoc_STR("() -> (Handle _rv)")}, {"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1, PyDoc_STR("(Handle theStorage) -> None")}, {"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1, PyDoc_STR("(short ftnNumber) -> (long _rv)")}, {"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1, PyDoc_STR("() -> (long _rv)")}, {"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1, PyDoc_STR("(ComponentInstance target) -> (long _rv)")}, {NULL, NULL, 0}
if (!(result = PyString_FromStringAndSize(NULL,size))) return NULL; /* Second pass: actually decode this time. */ out = PyString_AsString(result); size = percent_decode(in, inlen, out); return result; } static PyMethodDef Codec_methods[] = { {"encode", (PyCFunction)Codec_encode, METH_VARARGS, PyDoc_STR("encode(str) -> str")}, {"decode", (PyCFunction)Codec_decode, METH_VARARGS, PyDoc_STR("decode(str) -> str")}, {NULL, NULL} /* sentinel */ }; PyTypeObject CodecType = { /* The ob_type field must be initialized in the module init function * to be portable to Windows without using C++. */ PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "percentcoding.cext.Codec", /*tp_name*/ sizeof(Codec), /*tp_basicsize*/ 0, /*tp_itemsize*/ /* methods */
Py_DECREF(res); return PyObject_RichCompare(self->data, other->data, opid); } } Py_RETURN_NOTIMPLEMENTED; } PyMappingMethods pysqlite_row_as_mapping = { /* mp_length */ (lenfunc)pysqlite_row_length, /* mp_subscript */ (binaryfunc)pysqlite_row_subscript, /* mp_ass_subscript */ (objobjargproc)0, }; static PyMethodDef pysqlite_row_methods[] = { {"keys", (PyCFunction)pysqlite_row_keys, METH_NOARGS, PyDoc_STR("Returns the keys of the row.")}, {NULL, NULL} }; PyTypeObject pysqlite_RowType = { PyVarObject_HEAD_INIT(NULL, 0) MODULE_NAME ".Row", /* tp_name */ sizeof(pysqlite_Row), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)pysqlite_row_dealloc, /* tp_dealloc */ (printfunc)pysqlite_row_print, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_reserved */ 0, /* tp_repr */
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser Public License for more details. * * You should have received a copy of the GNU Lesser Public License * along with the ZBar Bar Code Reader; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301 USA * * http://sourceforge.net/projects/zbar *------------------------------------------------------------------------*/ #include "zbarmodule.h" static char decoder_doc[] = PyDoc_STR( "low level decode of measured bar/space widths.\n" "\n" "FIXME."); static zbarDecoder* decoder_new (PyTypeObject *type, PyObject *args, PyObject *kwds) { static char *kwlist[] = { NULL }; if(!PyArg_ParseTupleAndKeywords(args, kwds, "", kwlist)) return(NULL); zbarDecoder *self = (zbarDecoder*)type->tp_alloc(type, 0); if(!self) return(NULL);
static PyObj tupd_get_column_types(PyObj self, void *unused) { return(PyPgTupleDesc_GetTypes(self)); } static PyObj tupd_get_pg_column_types(PyObj self, void *unused) { return(PyPgTupleDesc_GetTypeOids(self)); } static PyGetSetDef PyPgTupleDesc_GetSet[] = { {"column_types", tupd_get_column_types, NULL, PyDoc_STR("the descriptor's attribute types that have not been dropped")}, {"pg_column_types", tupd_get_pg_column_types, NULL, PyDoc_STR("the descriptor's attribute type Oids that have not been dropped")}, {NULL} }; static PyMemberDef PyPgTupleDesc_Members[] = { {"column_names", T_OBJECT, offsetof(struct PyPgTupleDesc, td_names), READONLY, PyDoc_STR("the descriptor's attribute names that have not been dropped")}, {"column_count", T_INT, offsetof(struct PyPgTupleDesc, td_natts), READONLY, PyDoc_STR("the count of the descriptor's attributes that have not been dropped ")}, {NULL} }; static Py_ssize_t tupd_length(PyObj self)
} cur = Py_BuildValue("HKK", LCB_MUTATION_TOKEN_VB(mt), LCB_MUTATION_TOKEN_ID(mt), LCB_MUTATION_TOKEN_SEQ(mt)); PyList_Append(ll, cur); Py_DECREF(cur); } return ll; } static PyGetSetDef Bucket_TABLE_getset[] = { { "default_format", (getter)Bucket_get_format, (setter)Bucket_set_format, PyDoc_STR("The default format to use for encoding values " "(passed to transcoder)") }, { "server_nodes", (getter)Bucket_server_nodes, NULL, PyDoc_STR("Get a list of the current nodes in the cluster") }, { "configured_replica_count", (getter)Bucket_get_configured_replica_count, NULL, PyDoc_STR("Get the number of configured replicas for the bucket") }, { "transcoder", (getter)Bucket_get_transcoder, (setter)Bucket_set_transcoder,
Py_XDECREF(self->x_attr); PyObject_Del(self); } static PyObject * Xxo_demo(XxoObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":demo")) return NULL; Py_INCREF(Py_None); return Py_None; } static PyMethodDef Xxo_methods[] = { {"demo", (PyCFunction)Xxo_demo, METH_VARARGS, PyDoc_STR("demo() -> None")}, {NULL, NULL} /* sentinel */ }; static PyObject * Xxo_getattr(XxoObject *self, char *name) { if (self->x_attr != NULL) { PyObject *v = PyDict_GetItemString(self->x_attr, name); if (v != NULL) { Py_INCREF(v); return v; } } return Py_FindMethod(Xxo_methods, (PyObject *)self, name); }
Py_XSETREF(op->gi_qualname, value); return 0; } static PyObject * gen_getyieldfrom(PyGenObject *gen) { PyObject *yf = _PyGen_yf(gen); if (yf == NULL) Py_RETURN_NONE; return yf; } static PyGetSetDef gen_getsetlist[] = { {"__name__", (getter)gen_get_name, (setter)gen_set_name, PyDoc_STR("name of the generator")}, {"__qualname__", (getter)gen_get_qualname, (setter)gen_set_qualname, PyDoc_STR("qualified name of the generator")}, {"gi_yieldfrom", (getter)gen_getyieldfrom, NULL, PyDoc_STR("object being iterated by yield from, or None")}, {NULL} /* Sentinel */ }; static PyMemberDef gen_memberlist[] = { {"gi_frame", T_OBJECT, offsetof(PyGenObject, gi_frame), READONLY}, {"gi_running", T_BOOL, offsetof(PyGenObject, gi_running), READONLY}, {"gi_code", T_OBJECT, offsetof(PyGenObject, gi_code), READONLY}, {NULL} /* Sentinel */ }; static PyMethodDef gen_methods[] = {
PyObject *_res = NULL; Handle _rv; #ifndef as_Resource PyMac_PRECHECK(as_Resource); #endif if (!PyArg_ParseTuple(_args, "")) return NULL; _rv = as_Resource(_self->ob_itself); _res = Py_BuildValue("O&", ResObj_New, _rv); return _res; } static PyMethodDef TEObj_methods[] = { {"TESetText", (PyCFunction)TEObj_TESetText, 1, PyDoc_STR("(Buffer text) -> None")}, {"TEGetText", (PyCFunction)TEObj_TEGetText, 1, PyDoc_STR("() -> (CharsHandle _rv)")}, {"TEIdle", (PyCFunction)TEObj_TEIdle, 1, PyDoc_STR("() -> None")}, {"TESetSelect", (PyCFunction)TEObj_TESetSelect, 1, PyDoc_STR("(long selStart, long selEnd) -> None")}, {"TEActivate", (PyCFunction)TEObj_TEActivate, 1, PyDoc_STR("() -> None")}, {"TEDeactivate", (PyCFunction)TEObj_TEDeactivate, 1, PyDoc_STR("() -> None")}, {"TEKey", (PyCFunction)TEObj_TEKey, 1, PyDoc_STR("(CharParameter key) -> None")}, {"TECut", (PyCFunction)TEObj_TECut, 1, PyDoc_STR("() -> None")}, {"TECopy", (PyCFunction)TEObj_TECopy, 1,
// BoundingBox typedef struct { PyObject_HEAD int left; int right; int top; int bottom; } PyBoundingBox; extern "C" { static int PyBoundingBox_init(PyBoundingBox *self, PyObject *args, PyObject *kwargs); static PyObject* PyBoundingBox_offset(PyBoundingBox *self, PyObject *args); } static PyMemberDef PyBoundingBox_members[] = { { "left", T_INT, offsetof(PyBoundingBox, left), 0, PyDoc_STR("Left edge of the bounding box") }, { "right", T_INT, offsetof(PyBoundingBox, right), 0, PyDoc_STR("Right edge of the bounding box") }, { "top", T_INT, offsetof(PyBoundingBox, top), 0, PyDoc_STR("Top edge of the bounding box") }, { "bottom", T_INT, offsetof(PyBoundingBox, bottom), 0, PyDoc_STR("Bottom edge of the bounding box") }, { NULL }, // sentinel }; static PyMethodDef PyBoundingBox_methods[] = { { "offset", (PyCFunction)PyBoundingBox_offset, METH_VARARGS, PyDoc_STR("offset(left_offset, top_offset)\n\nAdds a fixed offset to the coordinates in the bounding box") }, { NULL, NULL } // sentinel }; static PyTypeObject PyBoundingBox_Type = { PyVarObject_HEAD_INIT(NULL, 0) "tesserpy.BoundingBox", // tp_name sizeof(PyBoundingBox), // tp_basicsize
PyPgTypeInfo typinfo = PyPgTypeInfo(Py_TYPE(self)); rob = typinfo->array.x_yes.typelem_Type; /* * The array type shouldn't exist without having an element type. */ Assert(rob != NULL); Py_INCREF(rob); return(rob); } static PyGetSetDef array_getset[] = { {"Element", array_get_Element_type, NULL, PyDoc_STR("The array's element type")}, {"dimensions", array_get_dimensions, NULL, PyDoc_STR("The array's dimensions")}, {"has_null", array_has_null, NULL, PyDoc_STR("Whether the array has a NULL inside of it")}, {"lowerbounds", array_get_lowerbounds, NULL, PyDoc_STR("The array's lower bounds")}, {"ndim", array_get_ndim, NULL, PyDoc_STR("The number of array dimensions")}, {"nelements", array_get_nelements, NULL, PyDoc_STR("The number of elements in the array")}, {NULL} }; /* * Array.get_element(indexes) - Get an element from the array.
int data; if (!PyArg_ParseTuple(args, "ii:SetInteger", &field, &data)) return NULL; if ((status = MsiRecordSetInteger(record->h, field, data)) != ERROR_SUCCESS) return msierror(status); Py_RETURN_NONE; } static PyMethodDef record_methods[] = { { "GetFieldCount", (PyCFunction)record_getfieldcount, METH_NOARGS, PyDoc_STR("GetFieldCount() -> int\nWraps MsiRecordGetFieldCount")}, { "GetInteger", (PyCFunction)record_getinteger, METH_VARARGS, PyDoc_STR("GetInteger(field) -> int\nWraps MsiRecordGetInteger")}, { "GetString", (PyCFunction)record_getstring, METH_VARARGS, PyDoc_STR("GetString(field) -> string\nWraps MsiRecordGetString")}, { "SetString", (PyCFunction)record_setstring, METH_VARARGS, PyDoc_STR("SetString(field,str) -> None\nWraps MsiRecordSetString")}, { "SetStream", (PyCFunction)record_setstream, METH_VARARGS, PyDoc_STR("SetStream(field,filename) -> None\nWraps MsiRecordSetInteger")}, { "SetInteger", (PyCFunction)record_setinteger, METH_VARARGS, PyDoc_STR("SetInteger(field,int) -> None\nWraps MsiRecordSetInteger")}, { "ClearData", (PyCFunction)record_cleardata, METH_NOARGS, PyDoc_STR("ClearData() -> int\nWraps MsiRecordGClearData")}, { NULL, NULL } };
Py_BEGIN_ALLOW_THREADS _err = AE_SendMessageThreadSafe(&_self->ob_itself, &reply, sendMode, timeOutInTicks); Py_END_ALLOW_THREADS if (_err != noErr) return AE_MacOSError(_err); _res = Py_BuildValue("O&", AE_AEDesc_New, &reply); return _res; } static PyMethodDef AEDesc_methods[] = { {"flatten", (PyCFunction)AEDesc_AEFlattenDesc, 1, PyDoc_STR( "D.flatten() -> (Ptr buffer)\n" "Flattens the specified descriptor and stores the data in the\n" "supplied buffer.")}, {"coerce", (PyCFunction)AEDesc_AECoerceDesc, 1, PyDoc_STR( "D.coerce(DescType toType) -> (AEDesc result)\n" "Coerces the data in a descriptor to another descriptor type and\n" "creates a descriptor containing the newly coerced data.")}, {"duplicate", (PyCFunction)AEDesc_AEDuplicateDesc, 1, PyDoc_STR( "D.duplicate() -> (AEDesc result)\n" "Creates a copy of a descriptor.")}, {"count", (PyCFunction)AEDesc_AECountItems, 1, PyDoc_STR( "D.count() -> (long theCount)\n" "Counts the number of descriptors in a descriptor list.")},
self = Py_None; if (kw == NULL) kw = Py_None; Py_INCREF(self); PyTuple_SET_ITEM(result, 0, self); Py_INCREF(args); PyTuple_SET_ITEM(result, 1, args); Py_INCREF(kw); PyTuple_SET_ITEM(result, 2, kw); } return result; } static PyMethodDef spamlist_methods[] = { {"getstate", (PyCFunction)spamlist_getstate, METH_VARARGS, PyDoc_STR("getstate() -> state")}, {"setstate", (PyCFunction)spamlist_setstate, METH_VARARGS, PyDoc_STR("setstate(state)")}, /* These entries differ only in the flags; they are used by the tests in test.test_descr. */ {"classmeth", (PyCFunction)spamlist_specialmeth, METH_VARARGS | METH_KEYWORDS | METH_CLASS, PyDoc_STR("classmeth(*args, **kw)")}, {"staticmeth", (PyCFunction)spamlist_specialmeth, METH_VARARGS | METH_KEYWORDS | METH_STATIC, PyDoc_STR("staticmeth(*args, **kw)")}, {NULL, NULL}, }; static int spamlist_init(spamlistobject *self, PyObject *args, PyObject *kwds)
CFURLRef inURL; CFURLRef outLaunchedURL; if (!PyArg_ParseTuple(_args, "O&", CFURLRefObj_Convert, &inURL)) return NULL; _err = LSOpenCFURLRef(inURL, &outLaunchedURL); if (_err != noErr) return PyMac_Error(_err); _res = Py_BuildValue("O&", CFURLRefObj_New, outLaunchedURL); return _res; } static PyMethodDef Launch_methods[] = { {"LSCopyItemInfoForRef", (PyCFunction)Launch_LSCopyItemInfoForRef, 1, PyDoc_STR("(FSRef inItemRef, LSRequestedInfo inWhichInfo) -> (LSItemInfoRecord outItemInfo)")}, {"LSCopyItemInfoForURL", (PyCFunction)Launch_LSCopyItemInfoForURL, 1, PyDoc_STR("(CFURLRef inURL, LSRequestedInfo inWhichInfo) -> (LSItemInfoRecord outItemInfo)")}, {"LSGetExtensionInfo", (PyCFunction)Launch_LSGetExtensionInfo, 1, PyDoc_STR("(Buffer inNameLen) -> (UniCharCount outExtStartIndex)")}, {"LSCopyDisplayNameForRef", (PyCFunction)Launch_LSCopyDisplayNameForRef, 1, PyDoc_STR("(FSRef inRef) -> (CFStringRef outDisplayName)")}, {"LSCopyDisplayNameForURL", (PyCFunction)Launch_LSCopyDisplayNameForURL, 1, PyDoc_STR("(CFURLRef inURL) -> (CFStringRef outDisplayName)")}, {"LSSetExtensionHiddenForRef", (PyCFunction)Launch_LSSetExtensionHiddenForRef, 1, PyDoc_STR("(FSRef inRef, Boolean inHide) -> None")}, {"LSSetExtensionHiddenForURL", (PyCFunction)Launch_LSSetExtensionHiddenForURL, 1, PyDoc_STR("(CFURLRef inURL, Boolean inHide) -> None")}, {"LSCopyKindStringForRef", (PyCFunction)Launch_LSCopyKindStringForRef, 1, PyDoc_STR("(FSRef inFSRef) -> (CFStringRef outKindString)")}, {"LSCopyKindStringForURL", (PyCFunction)Launch_LSCopyKindStringForURL, 1,
"symtable() arg 3 must be 'exec' or 'eval' or 'single'"); return NULL; } st = Py_SymtableString(str, filename, start); if (st == NULL) return NULL; t = st->st_symbols; Py_INCREF(t); PyMem_Free((void *)st->st_future); PySymtable_Free(st); return t; } static PyMethodDef symtable_methods[] = { {"symtable", symtable_symtable, METH_VARARGS, PyDoc_STR("Return symbol and scope dictionaries" " used internally by compiler.")}, {NULL, NULL} /* sentinel */ }; PyMODINIT_FUNC init_symtable(void) { PyObject *m; m = Py_InitModule("_symtable", symtable_methods); if (m == NULL) return; PyModule_AddIntConstant(m, "USE", USE); PyModule_AddIntConstant(m, "DEF_GLOBAL", DEF_GLOBAL); PyModule_AddIntConstant(m, "DEF_LOCAL", DEF_LOCAL); PyModule_AddIntConstant(m, "DEF_PARAM", DEF_PARAM);
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser Public License for more details. * * You should have received a copy of the GNU Lesser Public License * along with the ZBar Bar Code Reader; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301 USA * * http://sourceforge.net/projects/zbar *------------------------------------------------------------------------*/ #include "zbarmodule.h" static char symbol_doc[] = PyDoc_STR( "symbol result object.\n" "\n" "data and associated information about a successful decode."); static int symbol_traverse (zbarSymbol *self, visitproc visit, void *arg) { return(0); } static int symbol_clear (zbarSymbol *self) { if(self->zsym) { zbar_symbol_t *zsym = (zbar_symbol_t*)self->zsym;
varAssign = malloc(strlen(varName) + strlen(varValue) + 2); sprintf(varAssign, "%s=%s", varName, varValue); if (putenv(varAssign) == 0) { Py_INCREF(Py_None); returnObj = Py_None; } else PyErr_SetString(PyExc_SystemError, "Error calling putenv"); } return returnObj; } /* registration table */ static PyMethodDef cenviron_methods[] = { {"getenv", (PyCFunction)wrap_getenv, METH_VARARGS, PyDoc_STR("getenv -> displays the value of an enviroment variable.")}, {"putenv", (PyCFunction)wrap_putenv, METH_VARARGS, PyDoc_STR("putenv -> sets a value of an enviroment variable.")}, {NULL, NULL, 0, NULL} /* sentinel */ }; PyDoc_STRVAR(cenviron_doc, "cenviron documentation."); // static PyTypeObject cenviron_CenvironType = { // PyVarObject_HEAD_INIT(NULL, 0) // "cenviron", /*tp_name*/ // sizeof(cenviron_CenvironObject), /*tp_basicsize*/ // 0, /*tp_itemsize*/ // /* methods */