PyObject * skimage_write_ps_hex(PyObject * self, PyObject * args) { PyObject * pyfile; ImagingObject * imobj; int line_length = 80; char * prefix = NULL; if (!PyArg_ParseTuple(args, "OO!|is", &imobj, &PyFile_Type, &pyfile, &line_length, &prefix)) return NULL; line_length = line_length - 2; if (line_length < 0) line_length = 0; if (imobj->image->pixelsize == 4) write_ps_hex_rgb(PyFile_AsFile(pyfile), imobj->image->linesize, imobj->image->ysize, imobj->image->image, line_length, prefix); else if (imobj->image->pixelsize == 1) write_ps_hex_gray(PyFile_AsFile(pyfile), imobj->image->linesize, imobj->image->ysize, imobj->image->image, line_length, prefix); Py_INCREF(Py_None); return Py_None; }
static PyObject * svc_writefile(captureobject *self, PyObject *args) { PyObject *file; int size; FILE* fp; if (!PyArg_Parse(args, "O", &file)) return NULL; if (!PyFile_Check(file)) { PyErr_SetString(SvError, "not a file object"); return NULL; } if (!(fp = PyFile_AsFile(file))) return NULL; size = self->ob_info.width * self->ob_info.height; if (fwrite(self->ob_capture, sizeof(long), size, fp) != size) { PyErr_SetString(SvError, "writing failed"); return NULL; } Py_INCREF(Py_None); return Py_None; }
bool _update_files(PyObject* list, FILE** target, uint64_t elements){ PyObject* item; FILE* current; uint64_t i = 0; for (i = 0; i < elements; i++) { item = PySequence_Fast_GET_ITEM(list, i); if(Py_None == item){ target[i] = NULL; }else{ if(PyString_Check(item)){ current = fopen(PyString_AsString(item), i==0 ? "r": "w"); if(current == NULL){ fprintf(stderr, "ERROR WHILE OPENING FILE!\n"); // unable to open file PyErr_SetFromErrno(PyExc_OSError); return false; } }else{ current = PyFile_AsFile(item); } target[i] = current; } } return true; }
bool PythonInterpreter::runScript(const char* filename, const char* shortName) { PyEval_RestoreThread(state); PyObject* script = PyFile_FromString(const_cast<char*>(filename), const_cast<char*>("r")); if (script) { PyObject* ans = PyRun_File(PyFile_AsFile(script), const_cast<char*>(shortName), Py_file_input, mainNamespace, mainNamespace); Py_DECREF(script); if (ans) { Py_DECREF(ans); state = PyEval_SaveThread(); return true; } else { PyErr_Print(); state = PyEval_SaveThread(); return false; } } else { state = PyEval_SaveThread(); return false; } }
static PyObject * hashsplit_read_chunk(PyObject *self, PyObject *args) { PyObject *source_file = NULL; //gcc complains if these aren't initialized PyObject *max_chunk_size = NULL; long MAX_CHUNK_SIZE; PyObject *result = NULL; Chunk *chunk; FILE *source; if (!PyArg_UnpackTuple(args, "read_chunk", 1, 2, &source_file, &max_chunk_size)) return NULL; if (!(source = PyFile_AsFile(source_file))) { PyErr_SetString(PyExc_TypeError, "Expected file or file descriptor"); return NULL; } if (!max_chunk_size || max_chunk_size == Py_None) { MAX_CHUNK_SIZE = DEFAULT_MAX_CHUNK_SIZE; } else if ((MAX_CHUNK_SIZE = PyInt_AsLong(max_chunk_size))==-1 && PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "max_chunk_size should be an integer"); return NULL; } if (MAX_CHUNK_SIZE < MIN_CHUNK_SIZE) { PyErr_SetString(PyExc_ValueError, "max_chunk_size must be larger than MIN_CHUNK_SIZE"); return NULL; } if (!(chunk = chunk_new(MAX_CHUNK_SIZE))) return PyErr_NoMemory(); if (!read_chunk(source, chunk, MAX_CHUNK_SIZE)) { PyErr_SetString(PyExc_EOFError, ""); } else { result = PyString_FromStringAndSize((char*)chunk->data, chunk->length); } chunk_delete(chunk); return result; }
int main(int argc, char *argv[]) { // Set the python interpreter. setup_python(argc, argv); std::string filepath(argv[0]); // Get the path to the helper script. std::string helper_path; size_t path_end = filepath.find_last_of('\\'); if (path_end != std::string::npos) helper_path = filepath.substr(0, path_end + 1); helper_path += "wbadminhelper.py"; // Configures the execution of the script to take the same // parameters as this helper tool. Py_SetProgramName(argv[0]); PySys_SetArgv(argc, argv); // Executes the helper script. PyObject *pFileObject = PyFile_FromString(const_cast<char *>(helper_path.c_str()), "r"); PyRun_SimpleFileEx(PyFile_AsFile(pFileObject), "wbadminhelper.py", 1); finalize_python(); return 0; }
static foreign_t python_run_file(term_t file) { char *s; size_t len; char si[256]; s = si; if (PL_get_nchars(file, &len, &s, CVT_ALL | CVT_EXCEPTION)) { #if PY_MAJOR_VERSION < 3 PyObject *PyFileObject = PyFile_FromString(si, "r"); PyRun_SimpleFileEx(PyFile_AsFile(PyFileObject), "test.py", 1); #else FILE *f = fopen(s, "r"); if (f == NULL) { return false; } PyRun_SimpleFileEx(f, s, 1); #endif { { return true; } } } { return false; } }
static PyObject* cdb_py_print_records(PyObject *self, PyObject *args, PyObject *kwdict) { static char *kwlist[] = { "start", "end", "count", "cooked", "step", "file_obj", "date_format", NULL, }; cdb_time_t start = 0; cdb_time_t end = 0; int cooked = 1; long step = 0; int64_t count = 0; cdb_t *cdb; PyObject *file_obj, *date_format; if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|LLLOzil:print_records", kwlist, &start, &end, &count, &file_obj, &date_format, &cooked, &step)) { return NULL; } cdb_request_t request = _parse_cdb_request(start, end, count, cooked, step); if (Py_None == date_format) { date_format = PyString_FromString(""); } if (Py_None == file_obj || !PyFile_Check(file_obj)) { file_obj = PyString_FromString("stderr"); } cdb = ((StorageObject*)self)->cdb; cdb_print_records(cdb, &request, PyFile_AsFile(file_obj), PyString_AsString(date_format)); return self; }
/* Call with the basis file */ static PyObject* _librsync_new_patchmaker(PyObject* self, PyObject* args) { _librsync_PatchMakerObject* pm; PyObject *python_file; FILE *cfile; if (!PyArg_ParseTuple(args, "O:new_patchmaker", &python_file)) return NULL; if (!PyFile_Check(python_file)) { PyErr_SetString(PyExc_TypeError, "Need true file object"); return NULL; } Py_INCREF(python_file); pm = PyObject_New(_librsync_PatchMakerObject, &_librsync_PatchMakerType); if (pm == NULL) return NULL; pm->x_attr = NULL; pm->basis_file = python_file; cfile = PyFile_AsFile(python_file); pm->patch_job = rs_patch_begin(rs_file_copy_cb, cfile); return (PyObject*)pm; }
static PyObject *py_lp_service_dump(PyObject *self, PyObject *args) { PyObject *py_stream; bool show_defaults = false; FILE *f; struct loadparm_service *service = PyLoadparmService_AsLoadparmService(self); struct loadparm_service *default_service; PyObject *py_default_service; if (!PyArg_ParseTuple(args, "OO|b", &py_stream, &py_default_service, &show_defaults)) return NULL; f = PyFile_AsFile(py_stream); if (f == NULL) { PyErr_SetString(PyExc_TypeError, "Not a file stream"); return NULL; } if (!PyObject_TypeCheck(py_default_service, &PyLoadparmService)) { PyErr_SetNone(PyExc_TypeError); return NULL; } default_service = PyLoadparmService_AsLoadparmService(py_default_service); lpcfg_dump_one(f, show_defaults, service, default_service); Py_RETURN_NONE; }
/* METH_O | METH_CLASS */ static PyObject * image_surface_create_from_png (PyTypeObject *type, PyObject *o) { FILE *fp; cairo_surface_t *surface; if (PyObject_TypeCheck (o, &PyBaseString_Type)) { fp = fopen (PyString_AsString(o), "rb"); if (fp == NULL) { PyErr_SetString(PyExc_IOError, "unable to open file for reading"); return NULL; } } else if (PyObject_TypeCheck (o, &PyFile_Type)) { fp = PyFile_AsFile(o); } else { PyErr_SetString(PyExc_TypeError, "ImageSurface.create_from_png takes one argument " "which must be a filename (str) or file object"); return NULL; } surface = cairo_image_surface_create_from_png_stream (_read_func, fp); if (PyObject_TypeCheck (o, &PyBaseString_Type)) fclose (fp); return PycairoSurface_FromSurface (surface, &PycairoImageSurface_Type, NULL); }
DSN_PY_API dsn_error_t dsn_app_bridge(int argc, const char** argv) { std::vector< std::string> args; for (int i = 0; i < argc; i++) { std::string ag(*argv++); args.push_back(ag); } new std::thread([=](){ Py_Initialize(); char* PyFileName = (char *)args[0].c_str(); char** PyParameterList = new char* [args.size()]; for (int i = 0;i < args.size(); ++i) { PyParameterList[i] = new char[args[i].size()+1]; strcpy(PyParameterList[i], args[i].c_str()); } PySys_SetArgv((int)args.size(), PyParameterList); PyObject* PyFileObject = PyFile_FromString(PyFileName, "r"); PyRun_SimpleFile(PyFile_AsFile(PyFileObject), PyFileName); Py_Finalize(); for (int i = 0; i < args.size(); ++i) { delete [] PyParameterList[i]; } delete [] PyParameterList; }); dsn_app_loader_wait(); return dsn::ERR_OK; }
/* dummy.decode_command_n(stream, N) -> ((cmd_code, args), .... (cmd_code_N, args_N)) */ static PyObject * dummy_decode_command(PyObject *self, PyObject *args) { int N = 1; PyObject *po = PyTuple_GetItem(args, 0); if (!PyFile_Check(po)) { PyErr_SetString(DummyError, "First argument should be a file object."); return NULL; } if (PyTuple_Size(args) == 2) { PyObject *pn = PyTuple_GetItem(args, 1); N = PyInt_AS_LONG(pn); } hu::FileInStream stream; FILE *handle = PyFile_AsFile(po); stream.open(handle); PyObject* res = PyTuple_New(N); for(int i = 0; i < N ; ++i) { PyObject* cmd = decoder.decode_cmd_from_stream(stream); if (cmd == NULL) { return NULL; } PyTuple_SET_ITEM(res, i, cmd); if (PyInt_AS_LONG(PyTuple_GetItem(cmd, 0)) == CLOSE) { _PyTuple_Resize(&res, i + 1); return res; } } return res; }
Pyramid::Pyramid(const char* script) { freopen("pyramid.log", "w", stdout); freopen("pyramid.log", "a", stderr); Py_SetProgramName(".\\pyramid"); Py_Initialize(); init_pyramid(); PyRun_SimpleString( "import sys\n" "sys.path.append('./')\n" "sys.stderr = open('python_errors.log', 'w', 0)\n" "sys.stdout = open('pyramid.log', 'a', 0)\n" "import pyramid\n"); char* fn_local = new char[strlen(script)+1]; strcpy(fn_local, script); PyObject* fp = PyFile_FromString(fn_local, "r"); if(!fp) { printf("Could not load mapping script '%s' for reading.\n", script); Py_Finalize(); exit(1); } FILE* sfp = PyFile_AsFile(fp); PyRun_AnyFileEx(sfp, script, 1); delete[] fn_local; }
Writes a flow record to the flow log\n\ "); static PyObject * FlowLog_write_flow(FlowLogObject *self, PyObject *args, PyObject *kw_args) { struct store_flow_complete flow; static char *keywords[] = { "flow", "fieldmask", NULL }; char ebuf[512]; FlowObject *flowobj = NULL; u_int32_t mask = STORE_DISPLAY_ALL; if (!PyArg_ParseTupleAndKeywords(args, kw_args, "O!|k:write_flow", keywords, &Flow_Type, (PyObject *)&flowobj, &mask)) return NULL; if (flowobj_normalise(flowobj) == -1) return (NULL); memcpy(&flow, &flowobj->flow, sizeof(flow)); store_swab_flow(&flow, 1); if (store_write_flow(PyFile_AsFile(self->flowlog), &flow, mask, ebuf, sizeof(ebuf)) != STORE_ERR_OK) { PyErr_SetString(PyExc_ValueError, ebuf); return (NULL); } Py_INCREF(Py_None); return Py_None; }
static PyObject *bits_disk_read(PyObject *self, PyObject *args) { PyObject *pyfile, *pystr; grub_file_t file; grub_disk_addr_t sector; unsigned offset, length; if (!PyArg_ParseTuple(args, "O!KII:disk_read", &PyFile_Type, &pyfile, §or, &offset, &length)) return NULL; file = PyFile_AsFile(pyfile); if (!file->device->disk) return PyErr_Format(PyExc_RuntimeError, "Can't get disk device from non-disk-backed file"); pystr = PyString_FromStringAndSize(NULL, length); if (!pystr) return PyErr_NoMemory(); if (grub_disk_read(file->device->disk, sector, offset, length, PyString_AsString(pystr)) != GRUB_ERR_NONE) { Py_DECREF(pystr); return PyErr_SetFromErrno(PyExc_IOError); } return pystr; }
// Execute python source code from file filename. // global and local are the global and local scopes respectively, // used during execution. object BOOST_PYTHON_DECL exec_file(str filename, object global, object local) { // Set suitable default values for global and local dicts. object none; if (global.ptr() == none.ptr()) { if (PyObject *g = PyEval_GetGlobals()) global = object(detail::borrowed_reference(g)); else global = dict(); } if (local.ptr() == none.ptr()) local = global; // should be 'char const *' but older python versions don't use 'const' yet. char *f = python::extract<char *>(filename); // Let python open the file to avoid potential binary incompatibilities. PyObject *pyfile = PyFile_FromString(f, const_cast<char*>("r")); if (!pyfile) throw std::invalid_argument(std::string(f) + " : no such file"); python::handle<> file(pyfile); PyObject* result = PyRun_File(PyFile_AsFile(file.get()), f, Py_file_input, global.ptr(), local.ptr()); if (!result) throw_error_already_set(); return object(detail::new_reference(result)); }
PyObject *ekg_cmd_watch_add(PyObject * self, PyObject * args) { PyObject *callback = NULL; PyObject *module = NULL; PyObject *fileobj = NULL; script_t * scr; int type; FILE * fd; if (!PyArg_ParseTuple(args, "O!iiO", &PyFile_Type, &fileobj, &type, &callback)) { return NULL; } if (!PyCallable_Check(callback)) { print("generic_error", _("Second parameter to watch_add is not callable")); PyErr_SetString(PyExc_TypeError, _("Parameter must be callable")); return NULL; } Py_XINCREF(callback); fd = PyFile_AsFile(fileobj); Py_INCREF(fileobj); module = PyObject_GetAttrString(callback, "__module__"); scr = python_find_script(module); script_watch_add(&python_lang, scr, fileno(fd), type, callback, fileobj); Py_INCREF(Py_None); return Py_None; }
static PyObject * FileScanner_FileScanN(PyObject *self, PyObject *args) { PyFileObject *File; PyArrayObject *Array; npy_intp length; double *Data; int i; //printf("Starting\n"); if (!PyArg_ParseTuple(args, "O!i", &PyFile_Type, &File, &length) ) { return NULL; } Data = calloc(length, sizeof(double) ); if ((i = filescan(PyFile_AsFile( (PyObject*)File ), length, Data)) < length){ PyErr_SetString (PyExc_ValueError, "End of File reached before all numbers found"); free(Data); return NULL; } Array = (PyArrayObject *) PyArray_SimpleNew(1, &length, PyArray_DOUBLE); for (i = 0; i< length ; i++){ *(double *)(Array->data + (i * Array->strides[0] ) ) = Data[i]; } free(Data); return PyArray_Return(Array); }
/* Loads a file into a module; it is not inserted into sys.modules */ static int py_load_module(PyObject *module, const char *path) { PyObject *dict, *ret, *fp; if (PyModule_AddStringConstant(module, "__file__", (char *)path) < 0) return 0; dict = PyModule_GetDict(module); if (PyDict_SetItemString(dict, "__builtins__", PyEval_GetBuiltins()) < 0) return 0; /* Dont use the standard library to avoid incompatabilities with the FILE structure and Python */ fp = PyFile_FromString((char *)path, "r"); if (!fp) return 0; ret = PyRun_File(PyFile_AsFile(fp), path, Py_file_input, dict, dict); Py_DECREF(fp); /* XXX: I assume that the file is closed when refs drop to zero? */ if (!ret) return 0; Py_DECREF(ret); return 1; }
static PyObject *cdrom_leadout(PyObject *self, PyObject *args) { struct CDDB_TOC_ENTRY_STRUCT entry; PyObject *cdrom_fileobj; int cdrom_fd; #if defined(__OpenBSD__) struct cd_toc_entry data; #endif if (!PyArg_ParseTuple(args, "O!", &PyFile_Type, &cdrom_fileobj)) return NULL; cdrom_fd = fileno(PyFile_AsFile(cdrom_fileobj)); entry.CDDB_TRACK_FIELD = CDDB_CDROM_LEADOUT; entry.CDDB_FORMAT_FIELD = CDDB_MSF_FORMAT; #if defined(__OpenBSD__) entry.data = &data; entry.data_len = sizeof(data); #endif if (ioctl(cdrom_fd, CDDB_READ_TOC_ENTRY_FLAG, &entry) < 0) { PyErr_SetFromErrno(cdrom_error); return NULL; } return Py_BuildValue("bbb", entry.CDDB_ADDR_FIELD.msf.minute, entry.CDDB_ADDR_FIELD.msf.second, entry.CDDB_ADDR_FIELD.msf.frame); }
// Execute python source code from file filename. // global and local are the global and local scopes respectively, // used during execution. object BOOST_PYTHON_DECL exec_file(str filename, object global, object local) { // Set suitable default values for global and local dicts. if (global.is_none()) { if (PyObject *g = PyEval_GetGlobals()) global = object(detail::borrowed_reference(g)); else global = dict(); } if (local.is_none()) local = global; // should be 'char const *' but older python versions don't use 'const' yet. char *f = python::extract<char *>(filename); #if PY_VERSION_HEX >= 0x03000000 // TODO(bhy) temporary workaround for Python 3. // should figure out a way to avoid binary incompatibilities as the Python 2 // version did. FILE *fs = fopen(f, "r"); #else // Let python open the file to avoid potential binary incompatibilities. PyObject *pyfile = PyFile_FromString(f, const_cast<char*>("r")); if (!pyfile) throw std::invalid_argument(std::string(f) + " : no such file"); python::handle<> file(pyfile); FILE *fs = PyFile_AsFile(file.get()); #endif PyObject* result = PyRun_File(fs, f, Py_file_input, global.ptr(), local.ptr()); if (!result) throw_error_already_set(); return object(detail::new_reference(result)); }
/* METH_O */ static PyObject * surface_write_to_png (PycairoSurface *o, PyObject *file) { FILE *fp; cairo_status_t status; if (PyObject_TypeCheck (file, &PyBaseString_Type)) { fp = fopen (PyString_AsString(file), "wb"); if (fp == NULL) { PyErr_SetString(PyExc_IOError, "unable to open file for writing"); return NULL; } } else if (PyObject_TypeCheck (file, &PyFile_Type)) { fp = PyFile_AsFile(file); } else { PyErr_SetString(PyExc_TypeError, "Surface.write_to_png takes one argument " "which must be a filename (str) or file object"); return NULL; } status = cairo_surface_write_to_png_stream (o->surface, _write_func, fp); if (PyObject_TypeCheck (file, &PyBaseString_Type)) fclose (fp); if (Pycairo_Check_Status (status)) return NULL; Py_RETURN_NONE; }
static PyObject * python_pfout( PyObject *self, PyObject *args ) { char *usage = "Usage: _stock._pfout( pfname, file )\n"; char *pfname; Pf *pf; FILE *fp; PyObject *fileobj; char errmsg[STRSZ]; long rc; if( ! PyArg_ParseTuple( args, "sO!", &pfname, &PyFile_Type, &fileobj ) ) { USAGE; return NULL; } if( ( pf = getPf( pfname ) ) == (Pf *) NULL ) { sprintf( errmsg, "Failure opening parameter file '%s'\n", pfname ); raise_elog( ELOG_COMPLAIN, errmsg ); return NULL; } fp = PyFile_AsFile( fileobj ); rc = pfout( fp, pf ); return Py_BuildValue( "i", rc ); }
static void mywrite(const char* name, FILE* fp, const char* format, va_list va) noexcept { PyObject* file; PyObject* error_type, *error_value, *error_traceback; PyErr_Fetch(&error_type, &error_value, &error_traceback); file = PySys_GetObject(name); if (file == NULL || PyFile_AsFile(file) == fp) vfprintf(fp, format, va); else { char buffer[1001]; const int written = PyOS_vsnprintf(buffer, sizeof(buffer), format, va); if (PyFile_WriteString(buffer, file) != 0) { PyErr_Clear(); fputs(buffer, fp); } if (written < 0 || (size_t)written >= sizeof(buffer)) { const char* truncated = "... truncated"; if (PyFile_WriteString(truncated, file) != 0) { PyErr_Clear(); fputs(truncated, fp); } } } PyErr_Restore(error_type, error_value, error_traceback); }
static void python_run_simple_file (FILE *file, const char *filename) { #ifndef _WIN32 PyRun_SimpleFile (file, filename); #else /* _WIN32 */ char *full_path; PyObject *python_file; struct cleanup *cleanup; /* Because we have a string for a filename, and are using Python to open the file, we need to expand any tilde in the path first. */ full_path = tilde_expand (filename); cleanup = make_cleanup (xfree, full_path); python_file = PyFile_FromString (full_path, "r"); if (! python_file) { do_cleanups (cleanup); gdbpy_print_stack (); error (_("Error while opening file: %s"), full_path); } make_cleanup_py_decref (python_file); PyRun_SimpleFile (PyFile_AsFile (python_file), filename); do_cleanups (cleanup); #endif /* _WIN32 */ }
//-------------------------------------------------------------------------- void PyW_RunPyFile(const char *fn) { char *v_fn = qstrdup(fn); PyObject *py_fp = PyFile_FromString(v_fn, "r"); FILE *fp = PyFile_AsFile(py_fp); PyRun_SimpleFile(fp, v_fn); qfree(v_fn); }
int PyWeave_Log_tp_init(PyWeave_LogObject* self, PyObject* args, PyObject* kwargs) { PyObject* py_logfile; self->logfile = NULL; if(PyArg_ParseTuple(args, "O!", &PyFile_Type, &py_logfile)) { FILE* logfile = PyFile_AsFile(py_logfile); if(!logfile) return -1; if(fseek(logfile, 0, SEEK_SET)) { PyErr_SetString(PyExc_IOError, "Could not seek to beginning of log file"); return -1; } char ident[sizeof(Weave::Log::ident)]; if(fread(ident, sizeof(ident), 1, logfile) != 1) { PyErr_SetString(PyExc_IOError, "Could not read log file identifier"); return -1; } if(strncmp(ident, Weave::Log::ident, sizeof(Weave::Log::ident))) { PyErr_SetString(PyExc_ValueError, "Invalid log file identifier"); return -1; } uint8_t packed_version[4]; if(fread(packed_version, sizeof(packed_version), 1, logfile) != 1) { PyErr_SetString(PyExc_IOError, "Could not read log file version"); return -1; } uint32_t version = packed_version[0] | (packed_version[1] << 8) | (packed_version[2] << 16) | (packed_version[3] << 24); if(version > Weave::Log::version) { PyErr_SetString(PyExc_ValueError, "Log file version too high. Please upgrade."); return -1; } if(fseek(logfile, sizeof(Weave::Log::Header), SEEK_SET)) { PyErr_SetString(PyExc_IOError, "Could not seek to end of log file header"); return -1; } self->logfile = py_logfile; Py_INCREF(py_logfile); return 0; } return -1; }
static PyObject *PyStorage_new(PyObject *o, PyObject *_args) { try { PWOSequence args(_args); PyStorage *ps = 0; switch (args.len()) { case 0: ps = new PyStorage; break; case 1: if (!PyFile_Check((PyObject*)args[0])) { if (PyString_Check((PyObject*)args[0])) Fail(PyExc_TypeError, "rw parameter missing"); else Fail(PyExc_TypeError, "argument not an open file"); break; } ps = new PyStorage(*new c4_FileStrategy(PyFile_AsFile(args[0])), true); break; case 4: { // Rrrrrr... if (!PyStorage_Check((PyObject*)args[0])) Fail(PyExc_TypeError, "First arg must be a storage object"); c4_Storage &storage = *(PyStorage*)(PyObject*)args[0]; if (!PyView_Check((PyObject*)args[1])) Fail(PyExc_TypeError, "Second arg must be a view object"); c4_View &view = *(PyView*)(PyObject*)args[1]; if (!PyProperty_Check((PyObject*)args[2])) Fail(PyExc_TypeError, "Third arg must be a property object"); c4_BytesProp &prop = *(c4_BytesProp*)(c4_Property*)(PyProperty*) (PyObject*)args[2]; int row = PWONumber(args[3]); ps = new PyStorage(*new SiasStrategy(storage, view, prop, row), true); break; } case 2: { char *fnm; int mode; if (!PyArg_ParseTuple(args, "esi", "utf_8", &fnm, &mode)) Fail(PyExc_TypeError, "bad argument type"); ps = new PyStorage(fnm, mode); PyMem_Free(fnm); if (!ps->Strategy().IsValid()) { delete ps; ps = 0; Fail(PyExc_IOError, "can't open storage file"); } break; } default: Fail(PyExc_ValueError, "storage() takes at most 4 arguments"); } return ps; } catch (...) { return 0; } }
extern "C" FILE* PySys_GetFile(char* name, FILE* def) noexcept { FILE* fp = NULL; PyObject* v = PySys_GetObject(name); if (v != NULL && PyFile_Check(v)) fp = PyFile_AsFile(v); if (fp == NULL) fp = def; return fp; }