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;
}
