bool PythonPlugin::loadOrReloadModule(ScriptEntry &script) { const QByteArray name = script.name.toUtf8(); if (script.module) { PySys_WriteStdout("-- Reloading %s\n", name.constData()); PyObject *module = PyImport_ReloadModule(script.module); Py_DECREF(script.module); script.module = module; } else { PySys_WriteStdout("-- Loading %s\n", name.constData()); script.module = PyImport_ImportModule(name.constData()); } if (!script.module) return false; PyObject *pluginClass = findPluginSubclass(script.module); if (!pluginClass) { PySys_WriteStderr("Extension of tiled.Plugin not defined in " "script: %s\n", name.constData()); return false; } if (script.mapFormat) { script.mapFormat->setPythonClass(pluginClass); } else { script.mapFormat = new PythonMapFormat(name, pluginClass, *this); addObject(script.mapFormat); } return true; }
PyObject * pyotherside_find_module(PyObject *self, PyObject *args) { char *fullname, *path; int err = PyArg_ParseTuple(args, "s|z", &fullname, &path); QString filename(fullname); qDebug() << "Search for module " + filename.toUtf8(); if(err == 0) { PyObject_Print(PyErr_Occurred(), stdout, Py_PRINT_RAW); PySys_WriteStdout("\n"); PyErr_Print(); PySys_WriteStdout("\n"); return Py_None; } QDir qrc(":/"); if (((qrc.exists(filename+".py")) | (qrc.exists(filename+".pyc")) | (qrc.exists(filename+".pyo"))) | (QDir(":/"+filename).exists())) { Py_INCREF(self); qDebug() << "Found module "+filename.toUtf8(); return self; } qDebug() << "Can't found module "+filename.toUtf8(); Py_INCREF(Py_None); return Py_None; }
hlVoid PrintValidation(HLValidation eValidation) { switch(eValidation) { case HL_VALIDATES_ASSUMED_OK: PySys_WriteStdout("Assumed OK"); break; case HL_VALIDATES_OK: PySys_WriteStdout("OK"); break; case HL_VALIDATES_INCOMPLETE: PySys_WriteStderr("Incomplete"); break; case HL_VALIDATES_CORRUPT: PySys_WriteStderr("Corrupt"); break; case HL_VALIDATES_CANCELED: PySys_WriteStderr("Canceled"); break; case HL_VALIDATES_ERROR: PySys_WriteStderr("Error"); break; default: PySys_WriteStderr("Unknown"); break; } }
hlVoid ExtractItemStartCallback(HLDirectoryItem *pItem) { #if 0 PyEval_RestoreThread(g_extract_save); if( pStartExtractFunc == Py_None ) { if(!bSilent) { if(hlItemGetType(pItem) == HL_ITEM_FILE) { PySys_WriteStdout(" Extracting %s: ", hlItemGetName(pItem)); ProgressStart(); } else { PySys_WriteStdout(" Extracting %s:\n", hlItemGetName(pItem)); } } } else { PyEval_CallFunction(pStartExtractFunc, "si", hlItemGetName(pItem), hlItemGetType(pItem)); } g_extract_save = PyEval_SaveThread(); #endif // 0 }
static PyObject * Package_extract(PackageObject *self, PyObject *args) { hlUInt i; hlUInt uiExtractItems = 0; hlChar *lpExtractItems[MAX_ITEMS]; hlChar *lpDestination = 0;; HLDirectoryItem *pItem = 0; pUpdateFunc = Py_None; if (!PyArg_ParseTuple(args, "ss|O", &lpExtractItems[0], &lpDestination, &pUpdateFunc)) { return NULL; } uiExtractItems = 1; // Just before extracting set these globals hlSetBoolean(HL_OVERWRITE_FILES, self->bOverwriteFiles); hlSetBoolean(HL_FORCE_DEFRAGMENT, self->bForceDefragment); bSilent = self->bSilent; // Extract the requested items. for(i = 0; i < uiExtractItems; i++) { // Find the item. pItem = hlFolderGetItemByPath(hlPackageGetRoot(), lpExtractItems[i], HL_FIND_ALL); if(pItem == 0) { PySys_WriteStdout("%s not found in package.\n", lpExtractItems[i]); continue; } if(!self->bSilent) { PySys_WriteStdout("Extracting %s...\n\n", hlItemGetName(pItem)); } // Extract the item. // Item is extracted to cDestination\Item->GetName(). g_extract_save = PyEval_SaveThread(); g_bytesExtracted = 0; hlItemExtract(pItem, lpDestination); PyEval_RestoreThread(g_extract_save); if(!self->bSilent) { PySys_WriteStdout("\nDone.\n"); } } Py_INCREF(Py_None); return Py_None; }
void AppCompleteExport initComplete() { // load dependent module try { Base::Interpreter().loadModule("Part"); Base::Interpreter().loadModule("Mesh"); Base::Interpreter().loadModule("Points"); //Base::Interpreter().loadModule("MeshPart"); //Base::Interpreter().loadModule("Assembly"); Base::Interpreter().loadModule("Drawing"); Base::Interpreter().loadModule("Raytracing"); # ifdef COMPLETE_SHOW_SKETCHER Base::Interpreter().loadModule("Sketcher"); # endif Base::Interpreter().loadModule("PartDesign"); Base::Interpreter().loadModule("Image"); //Base::Interpreter().loadModule("Cam"); # ifdef COMPLETE_USE_DRAFTING try { Base::Interpreter().loadModule("Draft"); } catch (const Base::Exception& e) { // If called from console then issue a message but don't stop with an error PySys_WriteStdout("Import error: %s\n", e.what()); } # endif } catch(const Base::Exception& e) { PyErr_SetString(PyExc_ImportError, e.what()); return; } Py_InitModule3("Complete", Complete_methods, module_Complete_doc); /* mod name, table ptr */ Base::Console().Log("Loading Complete module... done\n"); }
hlVoid ProgressStart() { #ifndef _WIN32 uiProgressLast = 0; PySys_WriteStdout("0%%"); #endif }
static PyObject *ignp_fun_sumDegree(PyObject *self, PyObject *args) { PyObject* x_obj; PyObject* mem_addr_o; long int mem_addr; igraph_t* g; double value; /* Parse the input tuple */ if (!PyArg_ParseTuple(args, "O", &x_obj)) return NULL; mem_addr_o = PyObject_CallMethod(x_obj, "_raw_pointer", "()"); mem_addr = PyInt_AsLong(mem_addr_o); Py_DECREF(mem_addr_o); if (mem_addr == -1) { printf("PyInt to Long Failed"); return NULL; } g = (igraph_t*) mem_addr; /* Call the external C function to compute sum degree. */ value = sumDegree(g); /* Build the output tuple */ PyObject *ret = Py_BuildValue("d", value); PySys_WriteStdout("Finished Computing Sum\n"); return ret; }
static PyObject * Package_validate(PackageObject *self, PyObject *args) { hlUInt i; hlUInt uiValidateItems = 0; hlChar *lpValidateItems[MAX_ITEMS]; HLDirectoryItem *pItem = 0; if (!PyArg_ParseTuple(args, "s", &lpValidateItems[0])) { return NULL; } uiValidateItems = 1; // Validate the requested items. for(i = 0; i < uiValidateItems; i++) { // Find the item. pItem = hlFolderGetItemByPath(hlPackageGetRoot(), lpValidateItems[i], HL_FIND_ALL); if(pItem == 0) { printf("%s not found in package.\n", lpValidateItems[i]); continue; } if(!self->bSilent) { PySys_WriteStdout("Validating %s...\n\n", hlItemGetName(pItem)); } // Validate the item. Validate(self, pItem); if(!self->bSilent) { PySys_WriteStdout("\nDone.\n"); } } Py_INCREF(Py_None); return Py_None; }
hlVoid ProgressUpdate(hlULongLong uiBytesDone, hlULongLong uiBytesTotal) { if(!bSilent) { #ifdef _WIN32 HANDLE Handle = GetStdHandle(STD_OUTPUT_HANDLE); if (Handle != INVALID_HANDLE_VALUE) { CONSOLE_SCREEN_BUFFER_INFO Info; if(GetConsoleScreenBufferInfo(Handle, &Info)) { if(uiBytesTotal == 0) { PySys_WriteStdout("100.0%%"); } else { PySys_WriteStdout("%0.0f%%", (hlSingle)((hlDouble)uiBytesDone / (hlDouble)uiBytesTotal * 100.0)); } SetConsoleCursorPosition(Handle, Info.dwCursorPosition); } } #else hlUInt uiProgress = uiBytesTotal == 0 ? 100 : (hlUInt)((hlUInt64)uiBytesDone * 100 / (hlUInt64)uiBytesTotal); while(uiProgress >= uiProgressLast + 10) { uiProgressLast += 10; if(uiProgressLast == 100) { PySys_WriteStdout("100%% "); } else if(uiProgressLast == 50) { PySys_WriteStdout("50%%"); } else { PySys_WriteStdout("."); } } #endif } }
std::streamsize write(const char* rawString, std::streamsize stringSize) { std::streamsize charactersWritten; charactersWritten = std::min(stringSize, SIZE_STREAM_BUFFER); PySys_WriteStdout((boost::format("%%.%1%s") % charactersWritten).str().c_str(), rawString); return charactersWritten; } // PythonOutputStreamSink::write
/* Print complex to stdout*/ DYNAMIC_LIB_DECORATION void qcs_print_complex(tf_qcs_complex *a_in) { #ifdef PYTHON_SCRIPT if(a_in->im>0) PySys_WriteStdout("%2.2f + %2.2fi ", a_in->re, a_in->im); if(a_in->im<0) PySys_WriteStdout("%2.2f - %2.2fi ", a_in->re, -a_in->im); if(a_in->re!=0 && a_in->im == 0) PySys_WriteStdout("%2.2f ", a_in->re); if(a_in->re == 0 && a_in->im == 0) PySys_WriteStdout("0.00 "); #else if(a_in->im>0) printf("%2.2f + %2.2fi ", a_in->re, a_in->im); if(a_in->im<0) printf("%2.2f - %2.2fi ", a_in->re, -a_in->im); if(a_in->re!=0 && a_in->im == 0 ) printf("%2.2f ", a_in->re); if(a_in->re == 0 && a_in->im == 0) printf("0.00 "); #endif }
/* * FIXME: use module or package constants for the log levels, * either in pyipoptcore or in the parent package. * They are currently #defined in a header file. */ static PyObject *set_loglevel(PyObject * obj, PyObject * args) { int l; if (!PyArg_ParseTuple(args, "i", &l)) { PySys_WriteStdout("l is %d \n", l); return NULL; } if (l < 0 || l > 2) { return NULL; } user_log_level = l; Py_INCREF(Py_True); return Py_True; }
static _LevelData _get_level_data(pyGLTexture* self, GLint level, bool bgra, bool quiet) { GLint width, height; glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width); glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_HEIGHT, &height); GLenum fmt = bgra ? GL_BGRA_EXT : GL_RGBA; if (!quiet) PySys_WriteStdout(" Level #%i: %ix%i\n", level, width, height); size_t bufsz; bufsz = (width * height * 4); uint8_t* buf = new uint8_t[bufsz]; glGetTexImage(GL_TEXTURE_2D, level, fmt, GL_UNSIGNED_BYTE, reinterpret_cast<GLvoid*>(buf)); return _LevelData(width, height, buf, bufsz); }
/*.............................................................................. . This "helper" function does the actual computations; it isn't directly . accessed by Python. ..............................................................................*/ static void t2EA (double t, double *c, double *s) { double f, hi, lo, EA, W, EA_p, dE; int i; double imodf; double th, th2; double pi = 3.141592653; const int maxit = 20; /*** First, convert time to eccentric anomaly. We just copy the t2EA **** code here to avoid overhead. */ /*--- Convert time to phase mod 2*pi. */ f = modf((t-T0)/tau, &imodf); if (f > 0.5) f = f - 1.; else if (f < -0.5) f = f + 1.; f = 2*pi*f; /*--- Initial guess and bracket for root. */ EA = f; hi = pi; lo = - pi; /*--- Use Newton-Raphson; but if we jump too far, bisect. */ for (i=1; i<=maxit; i++) { W = EA - e*sin(EA) - f; if (W < 0.) lo = EA; else hi = EA; dE = - W/(1. - e*cos(EA)); EA_p = EA; EA = EA_p + dE; if (EA < lo || EA > hi) { EA = lo + 0.5*(hi-lo); dE = EA - EA_p; } if (fabs(dE) < err || EA == EA_p) goto EACalc; } PySys_WriteStdout("t2EA did not converge in t2EA!"); *c = -1.; *s = -1.; return; /*** Now get cos & sin of TA directly from tan(phi/2). */ EACalc: *c = cos(EA); *s = sin(EA); }
static PyObject * Package_close(PackageObject *self, PyObject *args) { // Close the package. hlPackageClose(); if(!self->bSilent) PySys_WriteStdout("%s closed.\n", self->lpPackage); // Free up the allocated memory. hlDeletePackage(self->uiPackage); self->uiPackage = HL_ID_INVALID; Py_INCREF(Py_None); return Py_None; }
static void Package_dealloc(PackageObject* self) { if( self->uiPackage != HL_ID_INVALID ) { // Close the package. hlPackageClose(); if(!self->bSilent) PySys_WriteStdout("%s closed.\n", self->lpPackage); // Free up the allocated memory. hlDeletePackage(self->uiPackage); } self->ob_type->tp_free((PyObject*)self); }
static PyObject * fkepler_t2TA (PyObject *self, PyObject *args) { double t; double f, hi, lo, EA, W, EA_p, dE; int i; double imodf; double c, s, th, th2; double pi = 3.141592653; const int maxit = 20; /*** Parse the double argument. */ Py_TRY(PyArg_ParseTuple(args, "d", &t)); /*** First, convert time to eccentric anomaly. We just copy the t2EA **** code here to avoid overhead. */ /*--- Convert time to phase mod 2*pi. */ f = modf((t-T0)/tau, &imodf); if (f > 0.5) f = f - 1.; else if (f < -0.5) f = f + 1.; f = 2*pi*f; /*--- Initial guess and bracket for root. */ EA = f; hi = pi; lo = - pi; /*--- Use Newton-Raphson; but if we jump too far, bisect. */ for (i=1; i<=maxit; i++) { W = EA - e*sin(EA) - f; if (W < 0.) lo = EA; else hi = EA; dE = - W/(1. - e*cos(EA)); EA_p = EA; EA = EA_p + dE; if (EA < lo || EA > hi) { EA = lo + 0.5*(hi-lo); dE = EA - EA_p; } if (fabs(dE) < err || EA == EA_p) goto TACalc; } PySys_WriteStdout("t2EA did not converge in t2TA!"); return NULL; /*** Now get cos & sin of TA directly from tan(phi/2). */ TACalc: if (EA == 0.) { c = 1.; s = 0.; } else if (abs(EA) == pi) { c = -1.; s = 0.; } else { th = sqrt((1.+e)/(1.-e)) * tan(0.5*EA); th2 = th*th; c = (1.-th2)/(1.+th2); s = (1.-c)/th; } return Py_BuildValue("dd", c, s); /** Misbehavior ends up here! */ FAIL: return NULL; }
static PyObject *pyop_call(PyObject *UNUSED(self), PyObject *args) { wmOperatorType *ot; int error_val = 0; PointerRNA ptr; int operator_ret = OPERATOR_CANCELLED; char *opname; char *context_str = NULL; PyObject *kw = NULL; /* optional args */ PyObject *context_dict = NULL; /* optional args */ PyObject *context_dict_back; /* note that context is an int, python does the conversion in this case */ int context = WM_OP_EXEC_DEFAULT; int is_undo = false; /* XXX Todo, work out a better solution for passing on context, * could make a tuple from self and pack the name and Context into it... */ bContext *C = (bContext *)BPy_GetContext(); if (C == NULL) { PyErr_SetString(PyExc_RuntimeError, "Context is None, cant poll any operators"); return NULL; } if (!PyArg_ParseTuple(args, "sO|O!si:_bpy.ops.call", &opname, &context_dict, &PyDict_Type, &kw, &context_str, &is_undo)) { return NULL; } ot = WM_operatortype_find(opname, true); if (ot == NULL) { PyErr_Format(PyExc_AttributeError, "Calling operator \"bpy.ops.%s\" error, " "could not be found", opname); return NULL; } if (!pyrna_write_check()) { PyErr_Format(PyExc_RuntimeError, "Calling operator \"bpy.ops.%s\" error, " "can't modify blend data in this state (drawing/rendering)", opname); return NULL; } if (context_str) { if (RNA_enum_value_from_id(operator_context_items, context_str, &context) == 0) { char *enum_str = BPy_enum_as_string(operator_context_items); PyErr_Format(PyExc_TypeError, "Calling operator \"bpy.ops.%s\" error, " "expected a string enum in (%.200s)", opname, enum_str); MEM_freeN(enum_str); return NULL; } } if (context_dict == NULL || context_dict == Py_None) { context_dict = NULL; } else if (!PyDict_Check(context_dict)) { PyErr_Format(PyExc_TypeError, "Calling operator \"bpy.ops.%s\" error, " "custom context expected a dict or None, got a %.200s", opname, Py_TYPE(context_dict)->tp_name); return NULL; } context_dict_back = CTX_py_dict_get(C); CTX_py_dict_set(C, (void *)context_dict); Py_XINCREF(context_dict); /* so we done loose it */ if (WM_operator_poll_context((bContext *)C, ot, context) == false) { const char *msg = CTX_wm_operator_poll_msg_get(C); PyErr_Format(PyExc_RuntimeError, "Operator bpy.ops.%.200s.poll() %.200s", opname, msg ? msg : "failed, context is incorrect"); CTX_wm_operator_poll_msg_set(C, NULL); /* better set to NULL else it could be used again */ error_val = -1; } else { WM_operator_properties_create_ptr(&ptr, ot); WM_operator_properties_sanitize(&ptr, 0); if (kw && PyDict_Size(kw)) error_val = pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: "); if (error_val == 0) { ReportList *reports; reports = MEM_mallocN(sizeof(ReportList), "wmOperatorReportList"); BKE_reports_init(reports, RPT_STORE | RPT_OP_HOLD); /* own so these don't move into global reports */ #ifdef BPY_RELEASE_GIL /* release GIL, since a thread could be started from an operator * that updates a driver */ /* note: I have not seen any examples of code that does this * so it may not be officially supported but seems to work ok. */ { PyThreadState *ts = PyEval_SaveThread(); #endif operator_ret = WM_operator_call_py(C, ot, context, &ptr, reports, is_undo); #ifdef BPY_RELEASE_GIL /* regain GIL */ PyEval_RestoreThread(ts); } #endif error_val = BPy_reports_to_error(reports, PyExc_RuntimeError, false); /* operator output is nice to have in the terminal/console too */ if (reports->list.first) { char *report_str = BKE_reports_string(reports, 0); /* all reports */ if (report_str) { PySys_WriteStdout("%s\n", report_str); MEM_freeN(report_str); } } BKE_reports_clear(reports); if ((reports->flag & RPT_FREE) == 0) { MEM_freeN(reports); } } WM_operator_properties_free(&ptr); #if 0 /* if there is some way to know an operator takes args we should use this */ { /* no props */ if (kw != NULL) { PyErr_Format(PyExc_AttributeError, "Operator \"%s\" does not take any args", opname); return NULL; } WM_operator_name_call(C, opname, WM_OP_EXEC_DEFAULT, NULL); } #endif } /* restore with original context dict, probably NULL but need this for nested operator calls */ Py_XDECREF(context_dict); CTX_py_dict_set(C, (void *)context_dict_back); if (error_val == -1) { return NULL; } /* when calling bpy.ops.wm.read_factory_settings() bpy.data's main pointer is freed by clear_globals(), * further access will crash blender. setting context is not needed in this case, only calling because this * function corrects bpy.data (internal Main pointer) */ BPY_modules_update(C); /* needed for when WM_OT_read_factory_settings us called from within a script */ bpy_import_main_set(CTX_data_main(C)); /* return operator_ret as a bpy enum */ return pyrna_enum_bitfield_to_py(operator_return_items, operator_ret); }
static PyObject * MidiListener_play(MidiListener *self) { int i, num_devices; PmError pmerr; /* always start the timer before you start midi */ Pt_Start(1, &process_midi, (void *)self); pmerr = Pm_Initialize(); if (pmerr) { PySys_WriteStdout("Portmidi warning: could not initialize Portmidi: %s\n", Pm_GetErrorText(pmerr)); } num_devices = Pm_CountDevices(); if (num_devices > 0) { if (self->mididev < num_devices) { if (self->mididev == -1) self->mididev = Pm_GetDefaultInputDeviceID(); const PmDeviceInfo *info = Pm_GetDeviceInfo(self->mididev); if (info != NULL) { if (info->input) { pmerr = Pm_OpenInput(&self->midiin[0], self->mididev, NULL, 100, NULL, NULL); if (pmerr) { PySys_WriteStdout("Portmidi warning: could not open midi input %d (%s): %s\n", self->mididev, info->name, Pm_GetErrorText(pmerr)); } else { self->midicount = 1; } } } } else if (self->mididev >= num_devices) { self->midicount = 0; for (i=0; i<num_devices; i++) { const PmDeviceInfo *info = Pm_GetDeviceInfo(i); if (info != NULL) { if (info->input) { pmerr = Pm_OpenInput(&self->midiin[self->midicount], i, NULL, 100, NULL, NULL); if (pmerr) { PySys_WriteStdout("Portmidi warning: could not open midi input %d (%s): %s\n", i, info->name, Pm_GetErrorText(pmerr)); } else { self->midicount++; } } } } } } for (i=0; i<self->midicount; i++) { Pm_SetFilter(self->midiin[i], PM_FILT_ACTIVE | PM_FILT_CLOCK); } if (self->midicount > 0) self->active = 1; Py_INCREF(Py_None); return Py_None; };
static int Package_init(PackageObject *self, PyObject *args, PyObject *kwds) { int volatileaccess; static char *kwlist[] = {"packagename", "volatileaccess", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|i", kwlist, &self->lpPackage, &volatileaccess)) { return -1; } self->bVolatileAccess = volatileaccess; /* if (!PyArg_ParseTuple(args, "s", &self->lpPackage)) { return -1; }*/ // Get the package type from the filename extension. self->ePackageType = hlGetPackageTypeFromName(self->lpPackage); // If the above fails, try getting the package type from the data at the start of the file. if(self->ePackageType == HL_PACKAGE_NONE) { self->pFile = fopen(self->lpPackage, "rb"); if(self->pFile != 0) { hlByte lpBuffer[HL_DEFAULT_PACKAGE_TEST_BUFFER_SIZE]; hlUInt uiBufferSize = (hlUInt)fread(lpBuffer, 1, HL_DEFAULT_PACKAGE_TEST_BUFFER_SIZE, self->pFile); self->ePackageType = hlGetPackageTypeFromMemory(lpBuffer, uiBufferSize); fclose(self->pFile); self->pFile = 0; } } if(self->ePackageType == HL_PACKAGE_NONE) { PyErr_Format(PyExc_Exception, "Error loading %s:\nUnsupported package type.\n", self->lpPackage); return -1; } // Create a package element, the element is allocated by the library and cleaned // up by the library. An ID is generated which must be bound to apply operations // to the package. if(!hlCreatePackage(self->ePackageType, &self->uiPackage)) { PyErr_Format(PyExc_Exception, "Error loading %s:\n%s\n", self->lpPackage, hlGetString(HL_ERROR_SHORT_FORMATED)); return -1; } hlBindPackage(self->uiPackage); self->uiMode = HL_MODE_READ | (self->bDefragment ? HL_MODE_WRITE : 0); self->uiMode |= !self->bFileMapping ? HL_MODE_NO_FILEMAPPING : 0; self->uiMode |= self->bQuickFileMapping ? HL_MODE_QUICK_FILEMAPPING : 0; self->uiMode |= self->bVolatileAccess ? HL_MODE_VOLATILE : 0; // Open the package. // Of the above modes, only HL_MODE_READ is required. HL_MODE_WRITE is present // only for future use. File mapping is recommended as an efficient way to load // packages. Quick file mapping maps the entire file (instead of bits as they are // needed) and thus should only be used in Windows 2000 and up (older versions of // Windows have poor virtual memory management which means large files won't be able // to find a continues block and will fail to load). Volatile access allows HLLib // to share files with other applications that have those file open for writing. // This is useful for, say, loading .gcf files while Steam is running. if(!hlPackageOpenFile(self->lpPackage, self->uiMode)) { PyErr_Format(PyExc_Exception, "Error loading %s:\n%s\n", self->lpPackage, hlGetString(HL_ERROR_SHORT_FORMATED)); return -1; } if(!self->bSilent) PySys_WriteStdout("%s opened.\n", self->lpPackage); // Package opened! return 0; }
hlVoid ExtractItemEndCallback(HLDirectoryItem *pItem, hlBool bSuccess) { #if 0 PyEval_RestoreThread(g_extract_save); hlUInt uiSize = 0; hlChar lpPath[512] = ""; if( pEndExtractFunc == Py_None ) { if(bSuccess) { if(!bSilent) { hlItemGetSize(pItem, &uiSize); if(hlItemGetType(pItem) == HL_ITEM_FILE) { PySys_WriteStdout("OK"); PySys_WriteStdout(" (%u B)\n", uiSize); } else { PySys_WriteStdout(" Done %s: ", hlItemGetName(pItem)); PySys_WriteStdout("OK"); PySys_WriteStdout(" (%u B)\n", uiSize); } } } else { if(!bSilent) { if(hlItemGetType(pItem) == HL_ITEM_FILE) { PySys_WriteStdout("Errored\n"); PySys_WriteStdout(" %s\n", hlGetString(HL_ERROR_SHORT_FORMATED)); } else { PySys_WriteStdout(" Done %s: ", hlItemGetName(pItem)); PySys_WriteStdout("Errored\n"); } } else { hlItemGetPath(pItem, lpPath, sizeof(lpPath)); if(hlItemGetType(pItem) == HL_ITEM_FILE) { PySys_WriteStdout(" Error extracting %s:\n", lpPath); PySys_WriteStdout(" %s\n", hlGetString(HL_ERROR_SHORT_FORMATED)); } else { PySys_WriteStdout(" Error extracting %s.\n", lpPath); } } } } else { hlItemGetSize(pItem, &uiSize); hlItemGetPath(pItem, lpPath, sizeof(lpPath)); PyEval_CallFunction(pEndExtractFunc, "bsisIs", bSuccess, hlItemGetName(pItem), hlItemGetType(pItem), lpPath, uiSize, bSuccess ? "" : hlGetString(HL_ERROR_SHORT_FORMATED)); } g_extract_save = PyEval_SaveThread(); #endif // 0 hlUInt uiSize = 0; hlChar lpPath[512] = ""; if(hlItemGetType(pItem) == HL_ITEM_FILE) { hlItemGetSize(pItem, &uiSize); g_bytesExtracted += uiSize; if( g_bytesExtracted > 10000000 && pUpdateFunc != Py_None ) { hlItemGetPath(pItem, lpPath, sizeof(lpPath)); PyEval_RestoreThread(g_extract_save); PyEval_CallFunction(pUpdateFunc, "bsisIs", bSuccess, hlItemGetName(pItem), hlItemGetType(pItem), lpPath, g_bytesExtracted, bSuccess ? "" : hlGetString(HL_ERROR_SHORT_FORMATED)); g_extract_save = PyEval_SaveThread(); g_bytesExtracted = 0; } } }
HLValidation Validate(PackageObject *self, HLDirectoryItem *pItem) { hlUInt i, uiItemCount; hlChar lpPath[512] = ""; HLValidation eValidation = HL_VALIDATES_OK, eTest; switch(hlItemGetType(pItem)) { case HL_ITEM_FOLDER: if(!self->bSilent) { PySys_WriteStdout(" Validating %s:\n", hlItemGetName(pItem)); } uiItemCount = hlFolderGetCount(pItem); for(i = 0; i < uiItemCount; i++) { eTest = Validate(self, hlFolderGetItem(pItem, i)); if(eTest > eValidation) { eValidation = eTest; } } if(!self->bSilent) { PySys_WriteStdout(" Done %s: ", hlItemGetName(pItem)); PrintValidation(eValidation); PySys_WriteStdout("\n"); } break; case HL_ITEM_FILE: if(!self->bSilent) { PySys_WriteStdout(" Validating %s: ", hlItemGetName(pItem)); //ProgressStart(); } eValidation = hlFileGetValidation(pItem); if(self->bSilent) { switch(eValidation) { case HL_VALIDATES_INCOMPLETE: case HL_VALIDATES_CORRUPT: hlItemGetPath(pItem, lpPath, sizeof(lpPath)); PySys_WriteStdout(" Validating %s: ", lpPath); PrintValidation(eValidation); PySys_WriteStdout("\n"); break; } } else { PrintValidation(eValidation); PySys_WriteStdout(" \n"); } break; } return eValidation; }
static void to_stdout(const char *text) { PySys_WriteStdout("%s", text); }
void jack_error_cb(const char *desc) { PySys_WriteStdout("JACK error: %s\n", desc); }