static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { char message[200]; PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); #if PY_VERSION_HEX < 0x02050000 return PyErr_Warn(NULL, message); #else return PyErr_WarnEx(NULL, message, 1); #endif } return 0; }
/*! * \brief Draw ellipse * * Not optional on the PyDia side. If not implemented a runtime warning * will be generated when called. * * \memberof _DiaPyRenderer */ static void draw_ellipse(DiaRenderer *renderer, Point *center, real width, real height, Color *fill, Color *stroke) { PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer); func = PyObject_GetAttrString (self, "draw_ellipse"); if (func && PyCallable_Check(func)) { PyObject *opoint = PyDiaPoint_New (center); PyObject *fill_po; PyObject *stroke_po; Py_INCREF(self); Py_INCREF(func); /* we have to provide a Python object even if there is no color */ if (fill) fill_po = PyDiaColor_New (fill); else Py_INCREF(Py_None), fill_po = Py_None; if (stroke) stroke_po = PyDiaColor_New (stroke); else Py_INCREF(Py_None), stroke_po = Py_None; arg = Py_BuildValue ("(OddOO)", opoint, width, height, fill_po, stroke_po); if (arg) { res = PyEval_CallObject (func, arg); ON_RES(res, FALSE); } Py_XDECREF (arg); Py_XDECREF (opoint); Py_XDECREF (fill_po); Py_XDECREF (stroke_po); Py_DECREF(func); Py_DECREF(self); } else { /* member not optional */ gchar *msg = g_strdup_printf ("%s.draw_ellipse() implementation missing.", G_OBJECT_CLASS_NAME (G_OBJECT_GET_CLASS (renderer))); PyErr_Clear(); PyErr_Warn (PyExc_RuntimeWarning, msg); g_free (msg); } }
static PyObject * pyg_enum_richcompare(PyGEnum *self, PyObject *other, int op) { static char warning[256]; if (!PYGLIB_PyLong_Check(other)) { Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } if (PyObject_TypeCheck(other, &PyGEnum_Type) && ((PyGEnum*)other)->gtype != self->gtype) { g_snprintf(warning, sizeof(warning), "comparing different enum types: %s and %s", g_type_name(self->gtype), g_type_name(((PyGEnum*)other)->gtype)); if (PyErr_Warn(PyExc_Warning, warning)) return NULL; } return pyg_integer_richcompare((PyObject *)self, other, op); }
/*! * \brief Draw string * * Not optional on the PyDia side. If not implemented a runtime warning * will be generated when called. * * \memberof _DiaPyRenderer */ static void draw_string(DiaRenderer *renderer, const char *text, Point *pos, Alignment alignment, Color *colour) { PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer); switch (alignment) { case ALIGN_LEFT: break; case ALIGN_CENTER: break; case ALIGN_RIGHT: break; } func = PyObject_GetAttrString (self, "draw_string"); if (func && PyCallable_Check(func)) { PyObject *opoint = PyDiaPoint_New (pos); PyObject *ocolor = PyDiaColor_New (colour); Py_INCREF(self); Py_INCREF(func); arg = Py_BuildValue ("(sOiO)", text, opoint, alignment, ocolor); if (arg) { res = PyEval_CallObject (func, arg); ON_RES(res, FALSE); } Py_XDECREF (arg); Py_XDECREF (opoint); Py_XDECREF (ocolor); Py_DECREF(func); Py_DECREF(self); } else { /* member not optional */ gchar *msg = g_strdup_printf ("%s.draw_string() implmentation missing.", G_OBJECT_CLASS_NAME (G_OBJECT_GET_CLASS (renderer))); PyErr_Clear(); PyErr_Warn (PyExc_RuntimeWarning, msg); g_free (msg); } }
static PyObject * int_classic_div(PyIntObject *x, PyIntObject *y) { long xi, yi; long d, m; CONVERT_TO_LONG(x, xi); CONVERT_TO_LONG(y, yi); if (Py_DivisionWarningFlag && PyErr_Warn(PyExc_DeprecationWarning, "classic int division") < 0) return NULL; switch (i_divmod(xi, yi, &d, &m)) { case DIVMOD_OK: return PyInt_FromLong(d); case DIVMOD_OVERFLOW: return PyLong_Type.tp_as_number->nb_divide((PyObject *)x, (PyObject *)y); default: return NULL; } }
static PyObject * complex_int_div(PyObject *v, PyObject *w) { PyObject *t, *r; Py_complex a, b; TO_COMPLEX(v, a); TO_COMPLEX(w, b); if (PyErr_Warn(PyExc_DeprecationWarning, "complex divmod(), // and % are deprecated") < 0) return NULL; t = complex_divmod(v, w); if (t != NULL) { r = PyTuple_GET_ITEM(t, 0); Py_INCREF(r); Py_DECREF(t); return r; } return NULL; }
static PyObject * complex_classic_div(PyComplexObject *v, PyComplexObject *w) { Py_complex quot; if (Py_DivisionWarningFlag >= 2 && PyErr_Warn(PyExc_DeprecationWarning, "classic complex division") < 0) return NULL; PyFPE_START_PROTECT("complex_classic_div", return 0) errno = 0; quot = c_quot(v->cval,w->cval); PyFPE_END_PROTECT(quot) if (errno == EDOM) { PyErr_SetString(PyExc_ZeroDivisionError, "complex division"); return NULL; } return PyComplex_FromCComplex(quot); }
static PyObject * complex_remainder(PyComplexObject *v, PyComplexObject *w) { Py_complex div, mod; if (PyErr_Warn(PyExc_DeprecationWarning, "complex divmod(), // and % are deprecated") < 0) return NULL; errno = 0; div = c_quot(v->cval,w->cval); /* The raw divisor value. */ if (errno == EDOM) { PyErr_SetString(PyExc_ZeroDivisionError, "complex remainder"); return NULL; } div.real = floor(div.real); /* Use the floor of the real part. */ div.imag = 0.0; mod = c_diff(v->cval, c_prod(w->cval, div)); return PyComplex_FromCComplex(mod); }
/*! * \brief Set linestyle for later use * * Optional on the PyDia side. * * \memberof _DiaPyRenderer */ static void set_linestyle(DiaRenderer *renderer, LineStyle mode, real dash_length) { PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer); /* line type */ switch (mode) { case LINESTYLE_SOLID: break; case LINESTYLE_DASHED: break; case LINESTYLE_DASH_DOT: break; case LINESTYLE_DASH_DOT_DOT: break; case LINESTYLE_DOTTED: break; case LINESTYLE_DEFAULT: default: PyErr_Warn (PyExc_RuntimeWarning, "DiaPyRenderer : Unsupported fill mode specified!\n"); } func = PyObject_GetAttrString (self, "set_linestyle"); if (func && PyCallable_Check(func)) { Py_INCREF(self); Py_INCREF(func); arg = Py_BuildValue ("(id)", mode, dash_length); if (arg) { res = PyEval_CallObject (func, arg); ON_RES(res, FALSE); } Py_XDECREF (arg); Py_DECREF(func); Py_DECREF(self); } else /* member optional */ PyErr_Clear(); }
/*! * \brief Draw polygon * * Optional on the PyDia side. If not implemented fallback to base class member. * * \memberof _DiaPyRenderer */ static void draw_polygon(DiaRenderer *renderer, Point *points, int num_points, Color *fill, Color *stroke) { PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer); func = PyObject_GetAttrString (self, "draw_polygon"); if (func && PyCallable_Check(func)) { PyObject *optt = PyDiaPointTuple_New (points, num_points); PyObject *fill_po, *stroke_po; if (fill) fill_po = PyDiaColor_New (fill); else Py_INCREF(Py_None), fill_po = Py_None; if (stroke) stroke_po = PyDiaColor_New (stroke); else Py_INCREF(Py_None), stroke_po = Py_None; Py_INCREF(self); Py_INCREF(func); arg = Py_BuildValue ("(OOO)", optt, fill_po, stroke_po); if (arg) { res = PyEval_CallObject (func, arg); ON_RES(res, FALSE); } Py_XDECREF (arg); Py_XDECREF (optt); Py_XDECREF (fill_po); Py_XDECREF (stroke_po); Py_DECREF(func); Py_DECREF(self); } else { /* fill_polygon was not an optional member */ PyErr_Warn (PyExc_RuntimeWarning, "DiaPyRenderer : draw_polygon() method missing!\n"); } }
/*! * \brief Fill arc * * Not optional on the PyDia side. If not implemented a runtime warning * will be generated when called. * * \memberof _DiaPyRenderer */ static void fill_arc(DiaRenderer *renderer, Point *center, real width, real height, real angle1, real angle2, Color *colour) { PyObject *func, *res, *arg, *self = PYDIA_RENDERER (renderer); func = PyObject_GetAttrString (self, "fill_arc"); if (func && PyCallable_Check(func)) { PyObject *opoint = PyDiaPoint_New (center); PyObject *ocolor = PyDiaColor_New (colour); Py_INCREF(self); Py_INCREF(func); arg = Py_BuildValue ("(OddddO)", opoint, width, height, angle1, angle2, ocolor); if (arg) { res = PyEval_CallObject (func, arg); ON_RES(res, FALSE); } Py_XDECREF (arg); Py_XDECREF (opoint); Py_XDECREF (ocolor); Py_DECREF(func); Py_DECREF(self); } else { /* member not optional */ gchar *msg = g_strdup_printf ("%s.fill_arc() implmentation missing.", G_OBJECT_CLASS_NAME (G_OBJECT_GET_CLASS (renderer))); PyErr_Clear(); PyErr_Warn (PyExc_RuntimeWarning, msg); g_free (msg); } }
VOID CALLBACK py_win32_timer_callback (HWND hwnd, UINT msg, UINT_PTR timer_id, DWORD time) { CEnterLeavePython _celp; PyObject * py_timer_id = PyWinLong_FromVoidPtr((void *)timer_id); if (!py_timer_id){ PyErr_Print(); return; } // is this timer id recognized? PyObject * callback_function = PyDict_GetItem (timer_id_callback_map, py_timer_id); if (!callback_function){ ::KillTimer (NULL, timer_id); PyErr_Warn(PyExc_RuntimeWarning, "Unrecognized timer id"); Py_DECREF(py_timer_id); return; } // call the user's function // create a 'death grip' on the callback function, just incase // the callback itself removes the function from the map. Py_INCREF(callback_function); PyObject * callback_args = Py_BuildValue ("(Ok)", py_timer_id, time); PyObject * result = PyEval_CallObject (callback_function, callback_args); if (!result) { // Is this necessary, or will python already have flagged // an exception? Can we even catch exceptions here? PyErr_Print(); } // everything's ok, return Py_DECREF(callback_function); Py_XDECREF(callback_args); Py_XDECREF(result); Py_DECREF (py_timer_id); return; }
void invoke(const string& methodName, const Ice::ConnectionPtr& con) { AdoptThread adoptThread; // Ensure the current thread is able to call into Python. #ifndef NDEBUG ConnectionObject* c = reinterpret_cast<ConnectionObject*>(_con); assert(con == *(c->connection)); #endif if(!PyObject_HasAttrString(_cb, STRCAST(methodName.c_str()))) { ostringstream ostr; ostr << "connection callback object does not define " << methodName << "()"; string str = ostr.str(); PyErr_Warn(PyExc_RuntimeWarning, const_cast<char*>(str.c_str())); } else { PyObjectHandle args = Py_BuildValue(STRCAST("(O)"), _con); PyObjectHandle method = PyObject_GetAttrString(_cb, STRCAST(methodName.c_str())); assert(method.get()); PyObjectHandle tmp = PyObject_Call(method.get(), args.get(), 0); if(PyErr_Occurred()) { PyException ex; // Retrieve it before another Python API call clears it. // // A callback that calls sys.exit() will raise the SystemExit exception. // This is normally caught by the interpreter, causing it to exit. // However, we have no way to pass this exception to the interpreter, // so we act on it directly. // ex.checkSystemExit(); ex.raise(); } } }
// @object PyADSVALUE|A tuple: // @tupleitem 0|object|value|The value as a Python object. // @tupleitem 1|int|type|The AD type of the value. PyObject *PyADSIObject_FromADSVALUE(ADSVALUE &v) { PyObject *ob = NULL; switch (v.dwType) { case ADSTYPE_DN_STRING: ob = PyWinObject_FromWCHAR(v.DNString); break; case ADSTYPE_CASE_EXACT_STRING: ob = PyWinObject_FromWCHAR(v.CaseExactString); break; case ADSTYPE_CASE_IGNORE_STRING: ob = PyWinObject_FromWCHAR(v.CaseIgnoreString); break; case ADSTYPE_PRINTABLE_STRING: ob = PyWinObject_FromWCHAR(v.PrintableString); break; case ADSTYPE_NUMERIC_STRING: ob = PyWinObject_FromWCHAR(v.NumericString); break; case ADSTYPE_BOOLEAN: ob = v.Boolean ? Py_True : Py_False; Py_INCREF(ob); break; case ADSTYPE_INTEGER: ob = PyInt_FromLong(v.Integer); break; case ADSTYPE_OCTET_STRING: { void *buf; DWORD bufSize = v.OctetString.dwLength; if (!(ob=PyBuffer_New(bufSize))) return NULL; if (!PyWinObject_AsWriteBuffer(ob, &buf, &bufSize)){ Py_DECREF(ob); return NULL; } memcpy(buf, v.OctetString.lpValue, bufSize); } break; case ADSTYPE_UTC_TIME: ob = PyWinObject_FromSYSTEMTIME(v.UTCTime); break; case ADSTYPE_LARGE_INTEGER: ob = PyWinObject_FromLARGE_INTEGER(v.LargeInteger); break; case ADSTYPE_OBJECT_CLASS: ob = PyWinObject_FromWCHAR(v.ClassName); break; case ADSTYPE_PROV_SPECIFIC: { void *buf; DWORD bufSize = v.ProviderSpecific.dwLength; if (!(ob=PyBuffer_New(bufSize))) return NULL; if (!PyWinObject_AsWriteBuffer(ob, &buf, &bufSize)){ Py_DECREF(ob); return NULL; } memcpy(buf, v.ProviderSpecific.lpValue, bufSize); break; } case ADSTYPE_NT_SECURITY_DESCRIPTOR: { // Get a pointer to the security descriptor. PSECURITY_DESCRIPTOR pSD = (PSECURITY_DESCRIPTOR)(v.SecurityDescriptor.lpValue); DWORD SDSize = v.SecurityDescriptor.dwLength; // eeek - we don't pass the length - pywintypes relies on // GetSecurityDescriptorLength - make noise if this may bite us. if (SDSize != GetSecurityDescriptorLength(pSD)) PyErr_Warn(PyExc_RuntimeWarning, "Security-descriptor size mis-match"); ob = PyWinObject_FromSECURITY_DESCRIPTOR(pSD); break; } default: { char msg[100]; sprintf(msg, "Unknown ADS type code 0x%x - None will be returned", v.dwType); PyErr_Warn(PyExc_RuntimeWarning, msg); ob = Py_None; Py_INCREF(ob); } } if (ob==NULL) return NULL; PyObject *ret = Py_BuildValue("Oi", ob, (int)v.dwType); Py_DECREF(ob); return ret; }
// find and call a method on this object that matches the python args. // typically called by way of pyjmethod when python invokes __call__. // // steals reference to self, methodname and args. PyObject* find_method(JNIEnv *env, PyObject *methodName, Py_ssize_t methodCount, PyObject *attr, PyObject *args) { // all possible method candidates PyJmethod_Object **cand = NULL; Py_ssize_t pos, i, listSize, argsSize; pos = i = listSize = argsSize = 0; // not really likely if we were called from pyjmethod, but hey... if(methodCount < 1) { PyErr_Format(PyExc_RuntimeError, "I have no methods."); return NULL; } if(!attr || !PyList_CheckExact(attr)) { PyErr_Format(PyExc_RuntimeError, "Invalid attr list."); return NULL; } cand = (PyJmethod_Object **) PyMem_Malloc(sizeof(PyJmethod_Object*) * methodCount); // just for safety for(i = 0; i < methodCount; i++) cand[i] = NULL; listSize = PyList_GET_SIZE(attr); for(i = 0; i < listSize; i++) { PyObject *tuple = PyList_GetItem(attr, i); /* borrowed */ if(PyErr_Occurred()) break; if(!tuple || tuple == Py_None || !PyTuple_CheckExact(tuple)) continue; if(PyTuple_Size(tuple) == 2) { PyObject *key = PyTuple_GetItem(tuple, 0); /* borrowed */ if(PyErr_Occurred()) break; if(!key || !PyString_Check(key)) continue; if(PyObject_Compare(key, methodName) == 0) { PyObject *method = PyTuple_GetItem(tuple, 1); /* borrowed */ if(pyjmethod_check(method)) cand[pos++] = (PyJmethod_Object *) method; } } } if(PyErr_Occurred()) goto EXIT_ERROR; // makes more sense to work with... pos--; if(pos < 0) { // didn't find a method by that name.... // that shouldn't happen unless the search above is broken. PyErr_Format(PyExc_NameError, "No such method."); goto EXIT_ERROR; } if(pos == 0) { // we're done, call that one PyObject *ret = pyjmethod_call_internal(cand[0], args); PyMem_Free(cand); return ret; } // first, find out if there's only one method that // has the correct number of args argsSize = PyTuple_Size(args); { PyJmethod_Object *matching = NULL; int count = 0; for(i = 0; i <= pos && cand[i]; i++) { // make sure method is fully initialized if(!cand[i]->parameters) { if(!pyjmethod_init(env, cand[i])) { // init failed, that's not good. cand[i] = NULL; PyErr_Warn(PyExc_Warning, "pyjmethod init failed."); continue; } } if(cand[i]->lenParameters == argsSize) { matching = cand[i]; count++; } else cand[i] = NULL; // eliminate non-matching } if(matching && count == 1) { PyMem_Free(cand); return pyjmethod_call_internal(matching, args); } } // local scope for(i = 0; i <= pos; i++) { int parmpos = 0; // already eliminated? if(!cand[i]) continue; // check if argument types match (*env)->PushLocalFrame(env, 20); for(parmpos = 0; parmpos < cand[i]->lenParameters; parmpos++) { PyObject *param = PyTuple_GetItem(args, parmpos); int paramTypeId = -1; jclass pclazz; jclass paramType = (jclass) (*env)->GetObjectArrayElement(env, cand[i]->parameters, parmpos); if(process_java_exception(env) || !paramType) break; pclazz = (*env)->GetObjectClass(env, paramType); if(process_java_exception(env) || !pclazz) break; paramTypeId = get_jtype(env, paramType, pclazz); if(pyarg_matches_jtype(env, param, paramType, paramTypeId)) { if(PyErr_Occurred()) break; continue; } // args don't match break; } (*env)->PopLocalFrame(env, NULL); // this method matches? if(parmpos == cand[i]->lenParameters) { PyObject *ret = pyjmethod_call_internal(cand[i], args); PyMem_Free(cand); return ret; } } EXIT_ERROR: PyMem_Free(cand); if(!PyErr_Occurred()) PyErr_Format(PyExc_NameError, "Matching overloaded method not found."); return NULL; }
/****************************************************************************** * * Call the python object with all arguments * */ static void _CallPythonObject(void *mem, ffi_type *restype, SETFUNC setfunc, PyObject *callable, PyObject *converters, void **pArgs) { int i; PyObject *result; PyObject *arglist = NULL; int nArgs; #ifdef WITH_THREAD PyGILState_STATE state = PyGILState_Ensure(); #endif nArgs = PySequence_Length(converters); /* Hm. What to return in case of error? For COM, 0xFFFFFFFF seems better than 0. */ if (nArgs < 0) { PrintError("BUG: PySequence_Length"); goto Done; } arglist = PyTuple_New(nArgs); if (!arglist) { PrintError("PyTuple_New()"); goto Done; } for (i = 0; i < nArgs; ++i) { /* Note: new reference! */ PyObject *cnv = PySequence_GetItem(converters, i); StgDictObject *dict; if (cnv) dict = PyType_stgdict(cnv); else { PrintError("Getting argument converter %d\n", i); goto Done; } if (dict && dict->getfunc && !IsSimpleSubType(cnv)) { PyObject *v = dict->getfunc(*pArgs, dict->size); if (!v) { PrintError("create argument %d:\n", i); Py_DECREF(cnv); goto Done; } PyTuple_SET_ITEM(arglist, i, v); /* XXX XXX XX We have the problem that c_byte or c_short have dict->size of 1 resp. 4, but these parameters are pushed as sizeof(int) bytes. BTW, the same problem occurrs when they are pushed as parameters */ } else if (dict) { /* Hm, shouldn't we use CData_AtAddress() or something like that instead? */ CDataObject *obj = (CDataObject *)PyObject_CallFunctionObjArgs(cnv, NULL); if (!obj) { PrintError("create argument %d:\n", i); Py_DECREF(cnv); goto Done; } if (!CDataObject_Check(obj)) { Py_DECREF(obj); Py_DECREF(cnv); PrintError("unexpected result of create argument %d:\n", i); goto Done; } memcpy(obj->b_ptr, *pArgs, dict->size); PyTuple_SET_ITEM(arglist, i, (PyObject *)obj); #ifdef MS_WIN32 TryAddRef(dict, obj); #endif } else { PyErr_SetString(PyExc_TypeError, "cannot build parameter"); PrintError("Parsing argument %d\n", i); Py_DECREF(cnv); goto Done; } Py_DECREF(cnv); /* XXX error handling! */ pArgs++; } #define CHECK(what, x) \ if (x == NULL) _AddTraceback(what, __FILE__, __LINE__ - 1), PyErr_Print() result = PyObject_CallObject(callable, arglist); CHECK("'calling callback function'", result); if ((restype != &ffi_type_void) && result) { PyObject *keep; assert(setfunc); #ifdef WORDS_BIGENDIAN /* See the corresponding code in callproc.c, around line 961 */ if (restype->type != FFI_TYPE_FLOAT && restype->size < sizeof(ffi_arg)) mem = (char *)mem + sizeof(ffi_arg) - restype->size; #endif keep = setfunc(mem, result, 0); CHECK("'converting callback result'", keep); /* keep is an object we have to keep alive so that the result stays valid. If there is no such object, the setfunc will have returned Py_None. If there is such an object, we have no choice than to keep it alive forever - but a refcount and/or memory leak will be the result. EXCEPT when restype is py_object - Python itself knows how to manage the refcount of these objects. */ if (keep == NULL) /* Could not convert callback result. */ PyErr_WriteUnraisable(callable); else if (keep == Py_None) /* Nothing to keep */ Py_DECREF(keep); else if (setfunc != getentry("O")->setfunc) { if (-1 == PyErr_Warn(PyExc_RuntimeWarning, "memory leak in callback function.")) PyErr_WriteUnraisable(callable); } } Py_XDECREF(result); Done: Py_XDECREF(arglist); #ifdef WITH_THREAD PyGILState_Release(state); #endif }
static int pylzma_compfile_init(CCompressionFileObject *self, PyObject *args, PyObject *kwargs) { PyObject *inFile; CLzmaEncProps props; Byte header[LZMA_PROPS_SIZE]; size_t headerSize = LZMA_PROPS_SIZE; int result = -1; // possible keywords for this function static char *kwlist[] = {"infile", "dictionary", "fastBytes", "literalContextBits", "literalPosBits", "posBits", "algorithm", "eos", "multithreading", "matchfinder", NULL}; int dictionary = 23; // [0,28], default 23 (8MB) int fastBytes = 128; // [5,255], default 128 int literalContextBits = 3; // [0,8], default 3 int literalPosBits = 0; // [0,4], default 0 int posBits = 2; // [0,4], default 2 int eos = 1; // write "end of stream" marker? int multithreading = 1; // use multithreading if available? char *matchfinder = NULL; // matchfinder algorithm int algorithm = 2; int res; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|iiiiiiiis", kwlist, &inFile, &dictionary, &fastBytes, &literalContextBits, &literalPosBits, &posBits, &algorithm, &eos, &multithreading, &matchfinder)) return -1; CHECK_RANGE(dictionary, 0, 28, "dictionary must be between 0 and 28"); CHECK_RANGE(fastBytes, 5, 255, "fastBytes must be between 5 and 255"); CHECK_RANGE(literalContextBits, 0, 8, "literalContextBits must be between 0 and 8"); CHECK_RANGE(literalPosBits, 0, 4, "literalPosBits must be between 0 and 4"); CHECK_RANGE(posBits, 0, 4, "posBits must be between 0 and 4"); CHECK_RANGE(algorithm, 0, 2, "algorithm must be between 0 and 2"); if (matchfinder != NULL) { #if (PY_VERSION_HEX >= 0x02050000) PyErr_WarnEx(PyExc_DeprecationWarning, "matchfinder selection is deprecated and will be ignored", 1); #else PyErr_Warn(PyExc_DeprecationWarning, "matchfinder selection is deprecated and will be ignored"); #endif } if (PyString_Check(inFile)) { // create new cStringIO object from string inFile = PycStringIO->NewInput(inFile); if (inFile == NULL) { PyErr_NoMemory(); return -1; } } else if (!PyObject_HasAttrString(inFile, "read")) { PyErr_SetString(PyExc_ValueError, "first parameter must be a file-like object"); return -1; } else { // protect object from being refcounted out... Py_INCREF(inFile); } self->encoder = LzmaEnc_Create(&allocator); if (self->encoder == NULL) { Py_DECREF(inFile); PyErr_NoMemory(); return -1; } LzmaEncProps_Init(&props); props.dictSize = 1 << dictionary; props.lc = literalContextBits; props.lp = literalPosBits; props.pb = posBits; props.algo = algorithm; props.fb = fastBytes; // props.btMode = 1; // props.numHashBytes = 4; // props.mc = 32; props.writeEndMark = eos ? 1 : 0; props.numThreads = multithreading ? 2 : 1; LzmaEncProps_Normalize(&props); res = LzmaEnc_SetProps(self->encoder, &props); if (res != SZ_OK) { Py_DECREF(inFile); PyErr_Format(PyExc_TypeError, "could not set encoder properties: %d", res); return -1; } self->inFile = inFile; CreatePythonInStream(&self->inStream, inFile); CreateMemoryOutStream(&self->outStream); LzmaEnc_WriteProperties(self->encoder, header, &headerSize); if (self->outStream.s.Write(&self->outStream, header, headerSize) != headerSize) { PyErr_SetString(PyExc_TypeError, "could not generate stream header"); goto exit; } LzmaEnc_Prepare(self->encoder, &self->inStream.s, &self->outStream.s, &allocator, &allocator); result = 0; exit: return result; }
static PyObject* splinsolve(PyObject *self, PyObject *args, PyObject *kwrds) { spmatrix *A, *B, *X; matrix *P=NULL; int n, nnz; cholmod_sparse *Ac=NULL, *Bc=NULL, *Xc=NULL; cholmod_factor *L=NULL; #if PY_MAJOR_VERSION >= 3 int uplo_='L'; #endif char uplo='L'; char *kwlist[] = {"A", "B", "p", "uplo", NULL}; if (!set_options()) return NULL; #if PY_MAJOR_VERSION >= 3 if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|OC", kwlist, &A, &B, &P, &uplo_)) return NULL; uplo = (char) uplo_; #else if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|Oc", kwlist, &A, &B, &P, &uplo)) return NULL; #endif if (!SpMatrix_Check(A) || SP_NROWS(A) != SP_NCOLS(A)) PY_ERR_TYPE("A is not a square sparse matrix"); n = SP_NROWS(A); nnz = SP_NNZ(A); if (!SpMatrix_Check(B) || SP_ID(A) != SP_ID(B)) PY_ERR_TYPE("B must be a sparse matrix of the same type as A"); if (SP_NROWS(B) != n) PY_ERR(PyExc_ValueError, "incompatible dimensions for B"); if (P) { if (!Matrix_Check(P) || MAT_ID(P) != INT) err_int_mtrx("p"); if (MAT_LGT(P) != n) err_buf_len("p"); if (!CHOL(check_perm)(P->buffer, n, n, &Common)) PY_ERR(PyExc_ValueError, "not a valid permutation"); } if (uplo != 'U' && uplo != 'L') err_char("uplo", "'L', 'U'"); if (!(Ac = pack(A, uplo))) return PyErr_NoMemory(); L = CHOL(analyze_p) (Ac, P ? MAT_BUFI(P): NULL, NULL, 0, &Common); if (Common.status != CHOLMOD_OK){ CHOL(free_factor)(&L, &Common); CHOL(free_sparse)(&Ac, &Common); if (Common.status == CHOLMOD_OUT_OF_MEMORY) return PyErr_NoMemory(); else { PyErr_SetString(PyExc_ValueError, "symbolic factorization " "failed"); return NULL; } } CHOL(factorize) (Ac, L, &Common); CHOL(free_sparse)(&Ac, &Common); if (Common.status > 0) switch (Common.status) { case CHOLMOD_NOT_POSDEF: PyErr_SetObject(PyExc_ArithmeticError, Py_BuildValue("i", L->minor)); CHOL(free_factor)(&L, &Common); return NULL; break; case CHOLMOD_DSMALL: /* This never happens unless we change the default value * of Common.dbound (0.0). */ if (L->is_ll) PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal " "elements in L"); else PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal " "elements in D"); break; default: PyErr_Warn(PyExc_UserWarning, ""); } if (L->minor<n) { CHOL(free_factor)(&L, &Common); PY_ERR(PyExc_ArithmeticError, "singular matrix"); } if (!(Bc = create_matrix(B))) { CHOL(free_factor)(&L, &Common); return PyErr_NoMemory(); } Xc = CHOL(spsolve)(0, L, Bc, &Common); free_matrix(Bc); CHOL(free_factor)(&L, &Common); if (Common.status != CHOLMOD_OK){ CHOL(free_sparse)(&Xc, &Common); if (Common.status == CHOLMOD_OUT_OF_MEMORY) return PyErr_NoMemory(); else PY_ERR(PyExc_ValueError, "solve step failed"); } if (!(X = SpMatrix_New(Xc->nrow, Xc->ncol, ((int_t*)Xc->p)[Xc->ncol], SP_ID(A)))) { CHOL(free_sparse)(&Xc, &Common); return PyErr_NoMemory(); } memcpy(SP_COL(X), (int_t *) Xc->p, (Xc->ncol+1)*sizeof(int_t)); memcpy(SP_ROW(X), (int_t *) Xc->i, ((int_t *) Xc->p)[Xc->ncol]*sizeof(int_t)); memcpy(SP_VAL(X), (double *) Xc->x, ((int_t *) Xc->p)[Xc->ncol]*E_SIZE[SP_ID(X)]); CHOL(free_sparse)(&Xc, &Common); return (PyObject *) X; }
static PyObject* linsolve(PyObject *self, PyObject *args, PyObject *kwrds) { spmatrix *A; matrix *B, *P=NULL; int i, n, nnz, oB=0, ldB=0, nrhs=-1; cholmod_sparse *Ac=NULL; cholmod_factor *L=NULL; cholmod_dense *x=NULL, *b=NULL; void *b_old; #if PY_MAJOR_VERSION >= 3 int uplo_ = 'L'; #endif char uplo='L'; char *kwlist[] = {"A", "B", "p", "uplo", "nrhs", "ldB", "offsetB", NULL}; if (!set_options()) return NULL; #if PY_MAJOR_VERSION >= 3 if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|OCiii", kwlist, &A, &B, &P, &uplo_, &nrhs, &ldB, &oB)) return NULL; uplo = (char) uplo_; #else if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|Ociii", kwlist, &A, &B, &P, &uplo, &nrhs, &ldB, &oB)) return NULL; #endif if (!SpMatrix_Check(A) || SP_NROWS(A) != SP_NCOLS(A)) PY_ERR_TYPE("A is not a sparse matrix"); n = SP_NROWS(A); nnz = SP_NNZ(A); if (!Matrix_Check(B) || MAT_ID(B) != SP_ID(A)) PY_ERR_TYPE("B must be a dense matrix of the same numerical " "type as A"); if (nrhs < 0) nrhs = MAT_NCOLS(B); if (n == 0 || nrhs == 0) return Py_BuildValue(""); if (ldB == 0) ldB = MAX(1,MAT_NROWS(B)); if (ldB < MAX(1,n)) err_ld("ldB"); if (oB < 0) err_nn_int("offsetB"); if (oB + (nrhs-1)*ldB + n > MAT_LGT(B)) err_buf_len("B"); if (P) { if (!Matrix_Check(P) || MAT_ID(P) != INT) err_int_mtrx("p"); if (MAT_LGT(P) != n) err_buf_len("p"); if (!CHOL(check_perm)(P->buffer, n, n, &Common)) PY_ERR(PyExc_ValueError, "not a valid permutation"); } if (uplo != 'U' && uplo != 'L') err_char("uplo", "'L', 'U'"); if (!(Ac = pack(A, uplo))) return PyErr_NoMemory(); L = CHOL(analyze_p)(Ac, P ? MAT_BUFI(P): NULL, NULL, 0, &Common); if (Common.status != CHOLMOD_OK){ free_matrix(Ac); CHOL(free_sparse)(&Ac, &Common); CHOL(free_factor)(&L, &Common); if (Common.status == CHOLMOD_OUT_OF_MEMORY) return PyErr_NoMemory(); else { PyErr_SetString(PyExc_ValueError, "symbolic factorization " "failed"); return NULL; } } CHOL(factorize) (Ac, L, &Common); CHOL(free_sparse)(&Ac, &Common); if (Common.status < 0) { CHOL(free_factor)(&L, &Common); switch (Common.status) { case CHOLMOD_OUT_OF_MEMORY: return PyErr_NoMemory(); default: PyErr_SetString(PyExc_ValueError, "factorization " "failed"); return NULL; } } if (Common.status > 0) switch (Common.status) { case CHOLMOD_NOT_POSDEF: PyErr_SetObject(PyExc_ArithmeticError, Py_BuildValue("i", L->minor)); CHOL(free_factor)(&L, &Common); return NULL; break; case CHOLMOD_DSMALL: /* This never happens unless we change the default value * of Common.dbound (0.0). */ if (L->is_ll) PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal " "elements in L"); else PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal " "elements in D"); break; default: PyErr_Warn(PyExc_UserWarning, ""); } if (L->minor<n) { CHOL(free_factor)(&L, &Common); PY_ERR(PyExc_ArithmeticError, "singular matrix"); } b = CHOL(allocate_dense)(n, 1, n, (MAT_ID(B) == DOUBLE ? CHOLMOD_REAL : CHOLMOD_COMPLEX) , &Common); if (Common.status == CHOLMOD_OUT_OF_MEMORY) { CHOL(free_factor)(&L, &Common); CHOL(free_dense)(&b, &Common); return PyErr_NoMemory(); } b_old = b->x; for (i=0; i<nrhs; i++) { b->x = MAT_BUF(B) + (i*ldB + oB)*E_SIZE[MAT_ID(B)]; x = CHOL(solve) (CHOLMOD_A, L, b, &Common); if (Common.status != CHOLMOD_OK){ PyErr_SetString(PyExc_ValueError, "solve step failed"); CHOL(free_factor)(&L, &Common); b->x = b_old; CHOL(free_dense)(&b, &Common); CHOL(free_dense)(&x, &Common); return NULL; } memcpy(b->x, x->x, SP_NROWS(A)*E_SIZE[MAT_ID(B)]); CHOL(free_dense)(&x, &Common); } b->x = b_old; CHOL(free_dense)(&b, &Common); CHOL(free_factor)(&L, &Common); return Py_BuildValue(""); }
static PyObject* numeric(PyObject *self, PyObject *args) { spmatrix *A; PyObject *F; cholmod_factor *Lc; cholmod_sparse *Ac = NULL; char uplo; #if PY_MAJOR_VERSION >= 3 const char *descr; #else char *descr; #endif if (!set_options()) return NULL; if (!PyArg_ParseTuple(args, "OO", &A, &F)) return NULL; if (!SpMatrix_Check(A) || SP_NROWS(A) != SP_NCOLS(A)) PY_ERR_TYPE("A is not a sparse matrix"); #if PY_MAJOR_VERSION >= 3 if (!PyCapsule_CheckExact(F) || !(descr = PyCapsule_GetName(F))) err_CO("F"); #else if (!PyCObject_Check(F)) err_CO("F"); descr = PyCObject_GetDesc(F); if (!descr) PY_ERR_TYPE("F is not a CHOLMOD factor"); #endif if (SP_ID(A) == DOUBLE){ if (!strcmp(descr, "CHOLMOD FACTOR D L")) uplo = 'L'; else if (!strcmp(descr, "CHOLMOD FACTOR D U")) uplo = 'U'; else PY_ERR_TYPE("F is not the CHOLMOD factor of a 'd' matrix"); } else { if (!strcmp(descr, "CHOLMOD FACTOR Z L")) uplo = 'L'; else if (!strcmp(descr, "CHOLMOD FACTOR Z U")) uplo = 'U'; else PY_ERR_TYPE("F is not the CHOLMOD factor of a 'z' matrix"); } #if PY_MAJOR_VERSION >= 3 Lc = (cholmod_factor *) PyCapsule_GetPointer(F, descr); #else Lc = (cholmod_factor *) PyCObject_AsVoidPtr(F); #endif if (!(Ac = pack(A, uplo))) return PyErr_NoMemory(); CHOL(factorize) (Ac, Lc, &Common); CHOL(free_sparse)(&Ac, &Common); if (Common.status < 0) switch (Common.status) { case CHOLMOD_OUT_OF_MEMORY: return PyErr_NoMemory(); default: PyErr_SetString(PyExc_ValueError, "factorization failed"); return NULL; } if (Common.status > 0) switch (Common.status) { case CHOLMOD_NOT_POSDEF: PyErr_SetObject(PyExc_ArithmeticError, Py_BuildValue("i", Lc->minor)); return NULL; break; case CHOLMOD_DSMALL: /* This never happens unless we change the default value * of Common.dbound (0.0). */ if (Lc->is_ll) PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal "\ "elements in L"); else PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal "\ "elements in D"); break; default: PyErr_Warn(PyExc_UserWarning, ""); } return Py_BuildValue(""); }
static int encode_common(PyObject **o, void **buf, size_t *nbuf, lcb_uint32_t flags) { PyObject *bytesobj; Py_ssize_t plen; int rv; if (flags == PYCBC_FMT_UTF8) { #if PY_MAJOR_VERSION == 2 if (PyString_Check(*o)) { #else if (0) { #endif bytesobj = *o; Py_INCREF(*o); } else { if (!PyUnicode_Check(*o)) { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ENCODING, 0, "Must be unicode or string", *o); return -1; } bytesobj = PyUnicode_AsUTF8String(*o); } } else if (flags == PYCBC_FMT_BYTES) { if (PyBytes_Check(*o) || PyByteArray_Check(*o)) { bytesobj = *o; Py_INCREF(*o); } else { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ENCODING, 0, "Must be bytes or bytearray", *o); return -1; } } else { PyObject *args = NULL; PyObject *helper; if (flags == PYCBC_FMT_PICKLE) { helper = pycbc_helpers.pickle_encode; } else if (flags == PYCBC_FMT_JSON) { helper = pycbc_helpers.json_encode; } else { PYCBC_EXC_WRAP(PYCBC_EXC_ARGUMENTS, 0, "Unrecognized format"); return -1; } args = PyTuple_Pack(1, *o); bytesobj = PyObject_CallObject(helper, args); Py_DECREF(args); if (!bytesobj) { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ENCODING, 0, "Couldn't encode value", *o); return -1; } if (!PyBytes_Check(bytesobj)) { PyObject *old = bytesobj; bytesobj = convert_to_bytesobj(old); Py_DECREF(old); if (!bytesobj) { return -1; } } } if (PyByteArray_Check(bytesobj)) { *buf = PyByteArray_AS_STRING(bytesobj); plen = PyByteArray_GET_SIZE(bytesobj); rv = 0; } else { rv = PyBytes_AsStringAndSize(bytesobj, (char**)buf, &plen); } if (rv < 0) { Py_DECREF(bytesobj); PYCBC_EXC_WRAP(PYCBC_EXC_ENCODING, 0, "Couldn't encode value"); return -1; } *nbuf = plen; *o = bytesobj; return 0; } static int decode_common(PyObject **vp, const char *buf, size_t nbuf, lcb_uint32_t flags) { PyObject *decoded = NULL; lcb_U32 c_flags, l_flags; c_flags = flags & PYCBC_FMT_COMMON_MASK; l_flags = flags & PYCBC_FMT_LEGACY_MASK; #define FMT_MATCHES(fmtbase) \ (c_flags == PYCBC_FMT_COMMON_##fmtbase || l_flags == PYCBC_FMT_LEGACY_##fmtbase) if (FMT_MATCHES(UTF8)) { decoded = convert_to_string(buf, nbuf, CONVERT_MODE_UTF8_ONLY); if (!decoded) { return -1; } } else if (FMT_MATCHES(BYTES)) { GT_BYTES: decoded = convert_to_string(buf, nbuf, CONVERT_MODE_BYTES_ONLY); pycbc_assert(decoded); } else { PyObject *converter = NULL; PyObject *args = NULL; PyObject *first_arg = NULL; if (FMT_MATCHES(PICKLE)) { converter = pycbc_helpers.pickle_decode; first_arg = convert_to_string(buf, nbuf, CONVERT_MODE_BYTES_ONLY); pycbc_assert(first_arg); } else if (FMT_MATCHES(JSON)) { converter = pycbc_helpers.json_decode; first_arg = convert_to_string(buf, nbuf, CONVERT_MODE_UTF8_ONLY); if (!first_arg) { return -1; } } else { PyErr_Warn(PyExc_UserWarning, "Unrecognized flags. Forcing bytes"); goto GT_BYTES; } pycbc_assert(first_arg); args = PyTuple_Pack(1, first_arg); decoded = PyObject_CallObject(converter, args); Py_DECREF(args); Py_DECREF(first_arg); } if (!decoded) { PyObject *bytes_tmp = PyBytes_FromStringAndSize(buf, nbuf); PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ENCODING, 0, "Failed to decode bytes", bytes_tmp); Py_XDECREF(bytes_tmp); return -1; } *vp = decoded; return 0; #undef FMT_MATCHES }
static PyObject * Session_browse_artist(PyObject *self, PyObject *args, PyObject *kwds) { PyErr_Warn(PyExc_DeprecationWarning, "use the artist browser directly."); return PyObject_Call((PyObject *)&ArtistBrowserType, args, kwds); }
static PyObject* get_runs(PyObject* obj, PyObject* args) { garmin_unit garmin; if (!initialize_garmin(&garmin)) return NULL; garmin_data * data; if ( (data = garmin_get(&garmin, GET_RUNS)) == NULL ) { PyErr_SetString(PyExc_RuntimeError, "Unable to extract any data."); return NULL; } /* We should have a list with three elements: 1) The runs (which identify the track and lap indices) 2) The laps (which are related to the runs) 3) The tracks (which are related to the runs) */ garmin_data * tmpdata; garmin_list * runs = NULL; garmin_list * laps = NULL; garmin_list * tracks = NULL; tmpdata = garmin_list_data(data, 0); if ( tmpdata == NULL ) { PyErr_SetString(PyExc_RuntimeError, "Toplevel data missing element 0 (runs)"); return NULL; } runs = tmpdata->data; if ( runs == NULL ) { PyErr_SetString(PyExc_RuntimeError, "No runs extracted."); return NULL; } tmpdata = garmin_list_data(data, 1); if ( tmpdata == NULL ) { PyErr_SetString(PyExc_RuntimeError, "Toplevel data missing element 1 (laps)"); return NULL; } laps = tmpdata->data; if ( laps == NULL ) { PyErr_SetString(PyExc_RuntimeError, "No laps extracted."); return NULL; } tmpdata = garmin_list_data(data, 2); if ( tmpdata == NULL ) { PyErr_SetString(PyExc_RuntimeError, "Toplevel data missing element 2 (tracks)"); return NULL; } tracks = tmpdata->data; if ( tracks == NULL ) { PyErr_SetString(PyExc_RuntimeError, "No tracks extracted."); return NULL; } garmin_list_node * n; garmin_list_node * m; garmin_list_node * o; uint32 trk; uint32 f_lap; uint32 l_lap; uint32 l_idx; time_type start; /* Print some debug output if requested. */ if ( verbose != 0 ) { for ( m = laps->head; m != NULL; m = m->next ) { if ( get_lap_index(m->data,&l_idx) != 0 ) printf("[garmin] lap: index [%d]\n", l_idx); else printf("[garmin] lap: index [??]\n"); } } /* For each run, get its laps and track points. */ PyObject* dict = PyDict_New(); for ( n = runs->head; n != NULL; n = n->next ) { if ( get_run_track_lap_info(n->data, &trk, &f_lap, &l_lap) != 0 ) { time_type f_lap_start = 0; PyObject* run = PyDict_New(); PyObject* rlaps = PyDict_New(); PyDict_SetItem(run, PyString_FromString("track"), Py_BuildValue("i", trk)); PyDict_SetItem(run, PyString_FromString("first_lap"), Py_BuildValue("i", f_lap)); PyDict_SetItem(run, PyString_FromString("last_lap"), Py_BuildValue("i", l_lap)); PyDict_SetItem(run, PyString_FromString("type"), Py_BuildValue("i", (int)n->data->type)); /* TODO: Implement something similar for the other run types, D1000 and D1010 See src/run.c get_run_track_lap_info() for more information */ if (n->data->type == data_D1009) { D1009 * d1009; d1009 = n->data->data; PyDict_SetItem(run, PyString_FromString("multisport"), PyBool_FromLong(d1009->multisport)); switch (d1009->sport_type) { case D1000_running: PyDict_SetItem(run, PyString_FromString("sport"), PyString_FromString("running")); break; case D1000_biking: PyDict_SetItem(run, PyString_FromString("sport"), PyString_FromString("biking")); break; case D1000_other: PyDict_SetItem(run, PyString_FromString("sport"), PyString_FromString("other")); break; } } if (verbose != 0) printf("[garmin] run: track [%d], laps [%d:%d]\n",trk,f_lap,l_lap); for ( m = laps->head; m != NULL; m = m->next ) { if ( get_lap_index(m->data, &l_idx) != 0 ) { if ( l_idx >= f_lap && l_idx <= l_lap ) { PyObject* lap = PyDict_New(); if (verbose != 0) printf("[garmin] lap [%d] falls within laps [%d:%d]\n", l_idx,f_lap,l_lap); start = 0; get_lap_start_time(m->data, &start); if (start != 0) { if (l_idx == f_lap) f_lap_start = start; PyDict_SetItem(lap, PyString_FromString("start_time"), Py_BuildValue("i", (int)start)); PyDict_SetItem(lap, PyString_FromString("type"), Py_BuildValue("i", (int)m->data->type)); if (m->data->type == data_D1015) { D1015 * d1015; d1015 = m->data->data; PyDict_SetItem(lap, PyString_FromString("duration"), Py_BuildValue("i", d1015->total_time)); PyDict_SetItem(lap, PyString_FromString("distance"), Py_BuildValue("f", d1015->total_dist)); PyDict_SetItem(lap, PyString_FromString("max_speed"), Py_BuildValue("f", d1015->max_speed)); } PyObject * points = PyList_New(0); bool have_track = 0; bool done = 0; for ( o = tracks->head; o != NULL; o = o->next ) { if ( o->data != NULL ) { if (o->data->type == data_D311) { if ( ! have_track ) { D311 * d311; d311 = o->data->data; if ( d311->index == trk ) have_track = 1; } else /* We've reached the end of the track */ done = 1; } else if (o->data->type == data_D304 && have_track) { D304 * d304; d304 = o->data->data; PyObject* point = PyDict_New(); if (d304->posn.lat != 2147483647 && d304->posn.lon != 2147483647) { PyDict_SetItem(point, PyString_FromString("position"), Py_BuildValue("(ff)", SEMI2DEG(d304->posn.lat), SEMI2DEG(d304->posn.lon))); PyDict_SetItem(point, PyString_FromString("type"), Py_BuildValue("i", (int)o->data->type)); PyDict_SetItem(point, PyString_FromString("time"), Py_BuildValue("f", (float)(d304->time + TIME_OFFSET))); PyDict_SetItem(point, PyString_FromString("distance"), Py_BuildValue("f", d304->distance)); PyDict_SetItem(point, PyString_FromString("altitude"), Py_BuildValue("f", d304->alt)); PyDict_SetItem(point, PyString_FromString("heart_rate"), Py_BuildValue("i", d304->heart_rate)); if (d304->cadence != 255) PyDict_SetItem(point, PyString_FromString("cadence"), Py_BuildValue("i", d304->cadence)); PyList_Append(points, Py_BuildValue("N", point)); } } else if (have_track) printf("get_track: point type %d invalid!\n",o->data->type); } if ( done ) break; } PyDict_SetItem(lap, PyString_FromString("points"), Py_BuildValue("N", points)); } else PyErr_Warn(PyExc_Warning, "Start time of first lap not found."); PyDict_SetItem(rlaps, PyString_FromFormat("%d", (int)l_idx), Py_BuildValue("N", lap)); } } } PyDict_SetItem(run, PyString_FromString("laps"), Py_BuildValue("N", rlaps)); PyDict_SetItem(dict, PyString_FromFormat("%d", (int)f_lap_start), Py_BuildValue("N", run)); } } garmin_free_data(data); garmin_close(&garmin); return Py_BuildValue("N", dict); }
static PyObject* sdpa_write (PyObject *self, PyObject *args, PyObject *kwrds) { int i,Il,Jl,Bl,Ml; int_t n; spmatrix *A; matrix *b,*bstruct; PyObject *f; PyObject *neg = Py_False; char *kwlist[] = {"f","A","b","bstruct","neg",NULL}; const char* fname; double v; if (!PyArg_ParseTupleAndKeywords(args,kwrds, "OOOO|O", kwlist, &f, &A, &b, &bstruct,&neg)) return NULL; #if PY_MAJOR_VERSION >= 3 if (PyUnicode_Check(f)) fname = PyUnicode_AsUTF8AndSize(f,NULL); #elif PY_MAJOR_VERSION == 2 if (PyString_Check(f)) fname = PyString_AsString(f); #endif FILE *fp = fopen(fname,"r"); if (!fp) { Py_DECREF(f); return NULL; } fprintf(fp,"* sparse SDPA data file (created by SMCP)\n"); fprintf(fp,"%i = m\n",(int) MAT_NROWS(b)); fprintf(fp,"%i = nBlocks\n", (int) MAT_NROWS(bstruct)); // compute n and write blockstruct n = 0; for (i=0;i<MAT_NROWS(bstruct);i++) { fprintf(fp,"%i ", (int) MAT_BUFI(bstruct)[i]); n += (int_t) labs(MAT_BUFI(bstruct)[i]); } fprintf(fp,"\n"); // write vector b if (neg == Py_True) { for (i=0;i<MAT_NROWS(b);i++) fprintf(fp,"%.12g ",-MAT_BUFD(b)[i]); } else { for (i=0;i<MAT_NROWS(b);i++) fprintf(fp,"%.12g ",MAT_BUFD(b)[i]); } fprintf(fp,"\n"); // Write data matrices A0,A1,A2,...,Am for (Ml=0;Ml<=MAT_NROWS(b);Ml++) { for (i=0;i<SP_COL(A)[Ml+1]-SP_COL(A)[Ml];i++){ Jl = 1 + SP_ROW(A)[SP_COL(A)[Ml]+i] / n; Il = 1 + SP_ROW(A)[SP_COL(A)[Ml]+i] % n; // Skip if element is in strict upper triangle if (Jl > Il) PyErr_Warn(PyExc_Warning,"Ignored strictly upper triangular element."); Bl = 1; while ((Il > labs(MAT_BUFI(bstruct)[Bl-1])) && (Jl > labs(MAT_BUFI(bstruct)[Bl-1]))) { Il -= (int_t) labs(MAT_BUFI(bstruct)[Bl-1]); Jl -= (int_t) labs(MAT_BUFI(bstruct)[Bl-1]); Bl += 1; } /* Error check */ if ((Il > labs(MAT_BUFI(bstruct)[Bl-1])) || (Jl > labs(MAT_BUFI(bstruct)[Bl-1]))) printf("Error: Matrix contains elements outside blocks!\n"); // print upper triangle entries: // <matno> <blkno> <i> <j> <entry> v = SP_VALD(A)[SP_COL(A)[Ml]+i]; if ( v != 0.0) { if (neg == Py_True) fprintf(fp,"%i %i %i %i %.12g\n", (int) Ml,(int) Bl,(int) Jl,(int) Il, -v); else fprintf(fp,"%i %i %i %i %.12g\n", (int) Ml,(int) Bl,(int) Jl,(int) Il, v); } } } fclose(fp); Py_DECREF(f); Py_RETURN_NONE; }
NPY_NO_EXPORT int _error_handler(int method, PyObject *errobj, char *errtype, int retstatus, int *first) { PyObject *pyfunc, *ret, *args; char *name = PyBytes_AS_STRING(PyTuple_GET_ITEM(errobj,0)); char msg[100]; NPY_ALLOW_C_API_DEF /* don't need C API for a simple print */ if (method == UFUNC_ERR_PRINT) { if (*first) { fprintf(stderr, "Warning: %s encountered in %s\n", errtype, name); *first = 0; } return 0; } NPY_ALLOW_C_API; switch(method) { case UFUNC_ERR_WARN: PyOS_snprintf(msg, sizeof(msg), "%s encountered in %s", errtype, name); if (PyErr_Warn(PyExc_RuntimeWarning, msg) < 0) { goto fail; } break; case UFUNC_ERR_RAISE: PyErr_Format(PyExc_FloatingPointError, "%s encountered in %s", errtype, name); goto fail; case UFUNC_ERR_CALL: pyfunc = PyTuple_GET_ITEM(errobj, 1); if (pyfunc == Py_None) { PyErr_Format(PyExc_NameError, "python callback specified for %s (in " \ " %s) but no function found.", errtype, name); goto fail; } args = Py_BuildValue("NN", PyUString_FromString(errtype), PyInt_FromLong((long) retstatus)); if (args == NULL) { goto fail; } ret = PyObject_CallObject(pyfunc, args); Py_DECREF(args); if (ret == NULL) { goto fail; } Py_DECREF(ret); break; case UFUNC_ERR_LOG: if (first) { *first = 0; pyfunc = PyTuple_GET_ITEM(errobj, 1); if (pyfunc == Py_None) { PyErr_Format(PyExc_NameError, "log specified for %s (in %s) but no " \ "object with write method found.", errtype, name); goto fail; } PyOS_snprintf(msg, sizeof(msg), "Warning: %s encountered in %s\n", errtype, name); ret = PyObject_CallMethod(pyfunc, "write", "s", msg); if (ret == NULL) { goto fail; } Py_DECREF(ret); } break; } NPY_DISABLE_C_API; return 0; fail: NPY_DISABLE_C_API; return -1; }
PyObject * pylzma_compress(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject *result = NULL; CLzmaEncProps props; CLzmaEncHandle encoder=NULL; CMemoryOutStream outStream; CMemoryInStream inStream; Byte header[LZMA_PROPS_SIZE]; size_t headerSize = LZMA_PROPS_SIZE; int res; // possible keywords for this function static char *kwlist[] = {"data", "dictionary", "fastBytes", "literalContextBits", "literalPosBits", "posBits", "algorithm", "eos", "multithreading", "matchfinder", NULL}; int dictionary = 23; // [0,27], default 23 (8MB) int fastBytes = 128; // [5,273], default 128 int literalContextBits = 3; // [0,8], default 3 int literalPosBits = 0; // [0,4], default 0 int posBits = 2; // [0,4], default 2 int eos = 1; // write "end of stream" marker? int multithreading = 1; // use multithreading if available? char *matchfinder = NULL; // matchfinder algorithm int algorithm = 2; char *data; int length; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|iiiiiiiis", kwlist, &data, &length, &dictionary, &fastBytes, &literalContextBits, &literalPosBits, &posBits, &algorithm, &eos, &multithreading, &matchfinder)) return NULL; outStream.data = NULL; CHECK_RANGE(dictionary, 0, 27, "dictionary must be between 0 and 27"); CHECK_RANGE(fastBytes, 5, 273, "fastBytes must be between 5 and 273"); CHECK_RANGE(literalContextBits, 0, 8, "literalContextBits must be between 0 and 8"); CHECK_RANGE(literalPosBits, 0, 4, "literalPosBits must be between 0 and 4"); CHECK_RANGE(posBits, 0, 4, "posBits must be between 0 and 4"); CHECK_RANGE(algorithm, 0, 2, "algorithm must be between 0 and 2"); if (matchfinder != NULL) { #if (PY_VERSION_HEX >= 0x02050000) PyErr_WarnEx(PyExc_DeprecationWarning, "matchfinder selection is deprecated and will be ignored", 1); #else PyErr_Warn(PyExc_DeprecationWarning, "matchfinder selection is deprecated and will be ignored"); #endif } encoder = LzmaEnc_Create(&allocator); if (encoder == NULL) return PyErr_NoMemory(); CreateMemoryInStream(&inStream, (Byte *) data, length); CreateMemoryOutStream(&outStream); LzmaEncProps_Init(&props); props.dictSize = 1 << dictionary; props.lc = literalContextBits; props.lp = literalPosBits; props.pb = posBits; props.algo = algorithm; props.fb = fastBytes; // props.btMode = 1; // props.numHashBytes = 4; // props.mc = 32; props.writeEndMark = eos ? 1 : 0; props.numThreads = multithreading ? 2 : 1; LzmaEncProps_Normalize(&props); res = LzmaEnc_SetProps(encoder, &props); if (res != SZ_OK) { PyErr_Format(PyExc_TypeError, "could not set encoder properties: %d", res); goto exit; } Py_BEGIN_ALLOW_THREADS LzmaEnc_WriteProperties(encoder, header, &headerSize); if (outStream.s.Write(&outStream, header, headerSize) != headerSize) { res = SZ_ERROR_WRITE; } else { res = LzmaEnc_Encode(encoder, &outStream.s, &inStream.s, NULL, &allocator, &allocator); } Py_END_ALLOW_THREADS if (res != SZ_OK) { PyErr_Format(PyExc_TypeError, "Error during compressing: %d", res); goto exit; } result = PyBytes_FromStringAndSize((const char *) outStream.data, outStream.size); exit: if (encoder != NULL) { LzmaEnc_Destroy(encoder, &allocator, &allocator); } if (outStream.data != NULL) { free(outStream.data); } return result; }