static PyObject *
SpiDev_xfer(SpiDevObject *self, PyObject *args)
{
uint16_t ii, len;
int status;
uint16_t delay_usecs = 0;
uint32_t speed_hz = 0;
uint8_t bits_per_word = 0;
PyObject *list;
#ifdef SPIDEV_SINGLE
struct spi_ioc_transfer *xferptr;
memset(&xferptr, 0, sizeof(xferptr));
#else
struct spi_ioc_transfer xfer;
memset(&xfer, 0, sizeof(xfer));
#endif
uint8_t *txbuf, *rxbuf;
if (!PyArg_ParseTuple(args, "O|IHB:xfer", &list, &speed_hz, &delay_usecs, &bits_per_word))
return NULL;
if (!PyList_Check(list)) {
PyErr_SetString(PyExc_TypeError, wrmsg);
return NULL;
}
if ((len = PyList_GET_SIZE(list)) > SPIDEV_MAXPATH) {
PyErr_SetString(PyExc_OverflowError, wrmsg);
return NULL;
}
txbuf = malloc(sizeof(__u8) * len);
rxbuf = malloc(sizeof(__u8) * len);
#ifdef SPIDEV_SINGLE
xferptr = (struct spi_ioc_transfer*) malloc(sizeof(struct spi_ioc_transfer) * len);
for (ii = 0; ii < len; ii++) {
PyObject *val = PyList_GET_ITEM(list, ii);
if (!PyLong_Check(val)) {
PyErr_SetString(PyExc_TypeError, wrmsg);
free(xferptr);
free(txbuf);
free(rxbuf);
return NULL;
}
txbuf[ii] = (__u8)PyLong_AS_LONG(val);
xferptr[ii].tx_buf = (unsigned long)&txbuf[ii];
xferptr[ii].rx_buf = (unsigned long)&rxbuf[ii];
xferptr[ii].len = 1;
xferptr[ii].delay_usecs = delay;
xferptr[ii].speed_hz = speed_hz ? speed_hz : self->max_speed_hz;
xferptr[ii].bits_per_word = bits_per_word ? bits_per_word : self->bits_per_word;
#ifdef SPI_IOC_WR_MODE32
xferptr[ii].tx_nbits = 0;
#endif
#ifdef SPI_IOC_RD_MODE32
xferptr[ii].rx_nbits = 0;
#endif
}
status = ioctl(self->fd, SPI_IOC_MESSAGE(len), xferptr);
if (status < 0) {
PyErr_SetFromErrno(PyExc_IOError);
free(xferptr);
free(txbuf);
free(rxbuf);
return NULL;
}
#else
for (ii = 0; ii < len; ii++) {
PyObject *val = PyList_GET_ITEM(list, ii);
if (!PyLong_Check(val)) {
PyErr_SetString(PyExc_TypeError, wrmsg);
free(txbuf);
free(rxbuf);
return NULL;
}
txbuf[ii] = (__u8)PyLong_AS_LONG(val);
}
xfer.tx_buf = (unsigned long)txbuf;
xfer.rx_buf = (unsigned long)rxbuf;
xfer.len = len;
xfer.delay_usecs = delay_usecs;
xfer.speed_hz = speed_hz ? speed_hz : self->max_speed_hz;
xfer.bits_per_word = bits_per_word ? bits_per_word : self->bits_per_word;
#ifdef SPI_IOC_WR_MODE32
xfer.tx_nbits = 0;
#endif
#ifdef SPI_IOC_RD_MODE32
xfer.rx_nbits = 0;
#endif
status = ioctl(self->fd, SPI_IOC_MESSAGE(1), &xfer);
if (status < 0) {
PyErr_SetFromErrno(PyExc_IOError);
free(txbuf);
free(rxbuf);
return NULL;
}
#endif
list = PyList_New(len);
for (ii = 0; ii < len; ii++) {
PyObject *val = Py_BuildValue("l", (long)rxbuf[ii]);
PyList_SET_ITEM(list, ii, val);
}
// WA:
// in CS_HIGH mode CS isn't pulled to low after transfer, but after read
// reading 0 bytes doesnt matter but brings cs down
// tomdean:
// Stop generating an extra CS except in mode CS_HOGH
if (self->mode & SPI_CS_HIGH) status = read(self->fd, &rxbuf[0], 0);
free(txbuf);
free(rxbuf);
return list;
}
static PyObject *
pickle___getstate__(PyObject *self)
{
PyObject *slotnames=NULL, *slots=NULL, *state=NULL;
PyObject **dictp;
int n=0;
slotnames = pickle_slotnames(self->ob_type);
if (slotnames == NULL)
return NULL;
dictp = _PyObject_GetDictPtr(self);
if (dictp)
state = pickle_copy_dict(*dictp);
else
{
state = Py_None;
Py_INCREF(state);
}
if (slotnames != Py_None)
{
int i;
slots = PyDict_New();
if (slots == NULL)
goto end;
for (i = 0; i < PyList_GET_SIZE(slotnames); i++)
{
PyObject *name, *value;
char *cname;
name = PyList_GET_ITEM(slotnames, i);
if (PyString_Check(name))
{
cname = PyString_AS_STRING(name);
if (*cname == '_' &&
(cname[1] == 'v' || cname[1] == 'p') &&
cname[2] == '_')
/* skip volatile and persistent */
continue;
}
value = PyObject_GetAttr(self, name);
if (value == NULL)
PyErr_Clear();
else
{
int err = PyDict_SetItem(slots, name, value);
Py_DECREF(value);
if (err)
goto end;
n++;
}
}
}
if (n)
state = Py_BuildValue("(NO)", state, slots);
end:
Py_XDECREF(slotnames);
Py_XDECREF(slots);
return state;
}
static PyObject *
eval_frame(PyFrameObject *f)
{
LOG("> eval_frame\n"); {
PyObject **stack_pointer; /* Next free slot in value stack */
register unsigned char *next_instr;
register int opcode=0; /* Current opcode */
register int oparg=0; /* Current opcode argument, if any */
register enum why_code why; /* Reason for block stack unwind */
register int err; /* Error status -- nonzero if error */
register PyObject *x; /* Result object -- NULL if error */
register PyObject *t, *u, *v; /* Temporary objects popped off stack */
register PyObject *w;
register PyObject **fastlocals, **freevars;
PyObject *retval = NULL; /* Return value */
PyThreadState *tstate = PyThreadState_GET();
PyCodeObject *co;
unsigned char *first_instr;
PyObject *names;
PyObject *consts;
/* Tuple access macros */
#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))
/* Code access macros */
#define INSTR_OFFSET() (next_instr - first_instr)
#define NEXTOP() (*next_instr++)
#define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
#define JUMPTO(x) (next_instr = first_instr + (x))
#define JUMPBY(x) (next_instr += (x))
/* OpCode prediction macros
Some opcodes tend to come in pairs thus making it possible to predict
the second code when the first is run. For example, COMPARE_OP is often
followed by JUMP_IF_FALSE or JUMP_IF_TRUE. And, those opcodes are often
followed by a POP_TOP.
Verifying the prediction costs a single high-speed test of register
variable against a constant. If the pairing was good, then the
processor has a high likelihood of making its own successful branch
prediction which results in a nearly zero overhead transition to the
next opcode.
A successful prediction saves a trip through the eval-loop including
its two unpredictable branches, the HASARG test and the switch-case.
*/
#define PREDICT(op) if (*next_instr == op) goto PRED_##op
#define PREDICTED(op) PRED_##op: next_instr++
#define PREDICTED_WITH_ARG(op) PRED_##op: oparg = (next_instr[2]<<8) + \
next_instr[1]; next_instr += 3
/* Stack manipulation macros */
#define STACK_LEVEL() (stack_pointer - f->f_valuestack)
#define EMPTY() (STACK_LEVEL() == 0)
#define TOP() (stack_pointer[-1])
#define SECOND() (stack_pointer[-2])
#define THIRD() (stack_pointer[-3])
#define FOURTH() (stack_pointer[-4])
#define SET_TOP(v) (stack_pointer[-1] = (v))
#define SET_SECOND(v) (stack_pointer[-2] = (v))
#define SET_THIRD(v) (stack_pointer[-3] = (v))
#define SET_FOURTH(v) (stack_pointer[-4] = (v))
#define BASIC_STACKADJ(n) (stack_pointer += n)
#define BASIC_PUSH(v) (*stack_pointer++ = (v))
#define BASIC_POP() (*--stack_pointer)
#define PUSH(v) BASIC_PUSH(v)
#define POP() BASIC_POP()
#define STACKADJ(n) BASIC_STACKADJ(n)
/* Local variable macros */
#define GETLOCAL(i) (fastlocals[i])
/* The SETLOCAL() macro must not DECREF the local variable in-place and
then store the new value; it must copy the old value to a temporary
value, then store the new value, and then DECREF the temporary value.
This is because it is possible that during the DECREF the frame is
accessed by other code (e.g. a __del__ method or gc.collect()) and the
variable would be pointing to already-freed memory. */
#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \
GETLOCAL(i) = value; \
Py_XDECREF(tmp); } while (0)
/* Start of code */
if (f == NULL)
return NULL;
/* push frame */
if (++tstate->recursion_depth > recursion_limit) {
--tstate->recursion_depth;
/* ERROR */
tstate->frame = f->f_back;
return NULL;
}
tstate->frame = f;
/* tracing elided */
co = f->f_code;
names = co->co_names;
consts = co->co_consts;
fastlocals = f->f_localsplus;
freevars = f->f_localsplus + f->f_nlocals;
_PyCode_GETCODEPTR(co, &first_instr);
/* An explanation is in order for the next line.
f->f_lasti now refers to the index of the last instruction
executed. You might think this was obvious from the name, but
this wasn't always true before 2.3! PyFrame_New now sets
f->f_lasti to -1 (i.e. the index *before* the first instruction)
and YIELD_VALUE doesn't fiddle with f_lasti any more. So this
does work. Promise. */
next_instr = first_instr + f->f_lasti + 1;
stack_pointer = f->f_stacktop;
f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */
why = WHY_NOT;
err = 0;
x = Py_None; /* Not a reference, just anything non-NULL */
w = NULL;
for (;;) {
/* Do periodic things. Doing this every time through
the loop would add too much overhead, so we do it
only every Nth instruction. We also do it if
``things_to_do'' is set, i.e. when an asynchronous
event needs attention (e.g. a signal handler or
async I/O handler); see Py_AddPendingCall() and
Py_MakePendingCalls() above. */
if (--_Py_Ticker < 0) {
/* @@@ check for SETUP_FINALLY elided */
_Py_Ticker = _Py_CheckInterval;
tstate->tick_counter++;
if (things_to_do) {
if (Py_MakePendingCalls() < 0) {
why = WHY_EXCEPTION;
goto on_error;
}
}
}
fast_next_opcode:
f->f_lasti = INSTR_OFFSET();
/* Extract opcode and argument */
opcode = NEXTOP();
if (HAS_ARG(opcode))
oparg = NEXTARG();
/* Main switch on opcode */
switch (opcode) {
/* BEWARE!
It is essential that any operation that fails sets either
x to NULL, err to nonzero, or why to anything but WHY_NOT,
and that no operation that succeeds does this! */
/* case STOP_CODE: this is an error! */
case LOAD_FAST:
x = GETLOCAL(oparg);
if (x != NULL) {
Py_INCREF(x);
PUSH(x);
goto fast_next_opcode;
}
/* ERROR? */
break;
case STORE_FAST:
v = POP();
SETLOCAL(oparg, v);
continue;
case LOAD_CONST:
x = GETITEM(consts, oparg);
Py_INCREF(x);
PUSH(x);
goto fast_next_opcode;
PREDICTED(POP_TOP);
case POP_TOP:
v = POP();
Py_DECREF(v);
goto fast_next_opcode;
case UNARY_NOT:
v = TOP();
err = PyObject_IsTrue(v);
Py_DECREF(v);
if (err == 0) {
Py_INCREF(Py_True);
SET_TOP(Py_True);
continue;
}
else if (err > 0) {
Py_INCREF(Py_False);
SET_TOP(Py_False);
err = 0;
continue;
}
STACKADJ(-1);
break;
case BINARY_MODULO:
w = POP();
v = TOP();
x = PyNumber_Remainder(v, w);
Py_DECREF(v);
Py_DECREF(w);
SET_TOP(x);
if (x != NULL) continue;
break;
case BINARY_ADD:
w = POP();
v = TOP();
if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
/* INLINE: int + int */
register long a, b, i;
a = PyInt_AS_LONG(v);
b = PyInt_AS_LONG(w);
i = a + b;
if ((i^a) < 0 && (i^b) < 0)
goto slow_add;
x = PyInt_FromLong(i);
}
else {
slow_add:
Py_FatalError("slow add not supported.");
}
Py_DECREF(v);
Py_DECREF(w);
SET_TOP(x);
if (x != NULL) continue;
break;
case STORE_SLICE+0:
case STORE_SLICE+1:
case STORE_SLICE+2:
case STORE_SLICE+3:
if ((opcode-STORE_SLICE) & 2)
w = POP();
else
w = NULL;
if ((opcode-STORE_SLICE) & 1)
v = POP();
else
v = NULL;
u = POP();
t = POP();
err = assign_slice(u, v, w, t); /* u[v:w] = t */
Py_DECREF(t);
Py_DECREF(u);
Py_XDECREF(v);
Py_XDECREF(w);
if (err == 0) continue;
break;
case STORE_SUBSCR:
w = POP();
v = POP();
u = POP();
/* v[w] = u */
err = PyObject_SetItem(v, w, u);
Py_DECREF(u);
Py_DECREF(v);
Py_DECREF(w);
if (err == 0) continue;
break;
case BINARY_SUBSCR:
w = POP();
v = TOP();
if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
/* INLINE: list[int] */
long i = PyInt_AsLong(w);
if (i < 0)
i += PyList_GET_SIZE(v);
if (i < 0 ||
i >= PyList_GET_SIZE(v)) {
/* ERROR */
printf("list index out of range\n");
x = NULL;
}
else {
x = PyList_GET_ITEM(v, i);
Py_INCREF(x);
}
}
else
x = PyObject_GetItem(v, w);
Py_DECREF(v);
Py_DECREF(w);
SET_TOP(x);
if (x != NULL) continue;
break;
case BINARY_AND:
w = POP();
v = TOP();
x = PyNumber_And(v, w);
Py_DECREF(v);
Py_DECREF(w);
SET_TOP(x);
if (x != NULL) continue;
break;
case PRINT_ITEM:
v = POP();
PyObject_Print(v);
Py_DECREF(v);
break;
case PRINT_NEWLINE:
printf("\n");
break;
case RETURN_VALUE:
retval = POP();
why = WHY_RETURN;
break;
case POP_BLOCK:
{
PyTryBlock *b = PyFrame_BlockPop(f);
while (STACK_LEVEL() > b->b_level) {
v = POP();
Py_DECREF(v);
}
}
break;
case STORE_NAME:
w = GETITEM(names, oparg);
v = POP();
if ((x = f->f_locals) == NULL) {
/* ERROR */
printf("STORE_NAME ERROR\n");
break;
}
err = PyDict_SetItem(x, w, v);
Py_DECREF(v);
break;
case LOAD_NAME:
w = GETITEM(names, oparg);
if ((x = f->f_locals) == NULL) {
/* ERROR */
printf("LOAD_NAME ERROR\n");
break;
}
x = PyDict_GetItem(x, w);
if (x == NULL) {
x = PyDict_GetItem(f->f_globals, w);
if (x == NULL) {
x = PyDict_GetItem(f->f_builtins, w);
if (x == NULL) {
printf("can't find %s\n", ((PyStringObject *)w)->ob_sval);
/* format_exc_check_arg */
break;
}
}
}
Py_INCREF(x);
PUSH(x);
break;
case LOAD_GLOBAL:
w = GETITEM(names, oparg);
if (PyString_CheckExact(w)) {
/* Inline the PyDict_GetItem() calls.
WARNING: this is an extreme speed hack.
Do not try this at home. */
long hash = ((PyStringObject *)w)->ob_shash;
if (hash != -1) {
PyDictObject *d;
d = (PyDictObject *)(f->f_globals);
x = d->ma_lookup(d, w, hash)->me_value;
if (x != NULL) {
Py_INCREF(x);
PUSH(x);
continue;
}
d = (PyDictObject *)(f->f_builtins);
x = d->ma_lookup(d, w, hash)->me_value;
if (x != NULL) {
Py_INCREF(x);
PUSH(x);
continue;
}
goto load_global_error;
}
}
/* This is the un-inlined version of the code above */
x = PyDict_GetItem(f->f_globals, w);
if (x == NULL) {
x = PyDict_GetItem(f->f_builtins, w);
if (x == NULL) {
load_global_error:
printf("LOAD_GLOBAL ERROR %s", ((PyStringObject *)w)->ob_sval);
break;
}
}
Py_INCREF(x);
PUSH(x);
break;
case LOAD_ATTR:
w = GETITEM(names, oparg);
v = TOP();
x = PyObject_GetAttr(v, w);
Py_DECREF(v);
SET_TOP(x);
if (x != NULL) continue;
break;
case IMPORT_NAME:
w = GETITEM(names, oparg);
x = PyDict_GetItemString(f->f_builtins, "__import__");
if (x == NULL) {
printf("__import__ not found");
break;
}
u = TOP();
w = Py_BuildValue("(O)", w);
Py_DECREF(u);
if (w == NULL) {
u = POP();
x = NULL;
break;
}
x = PyEval_CallObject(x, w);
Py_DECREF(w);
SET_TOP(x);
if (x != NULL) continue;
break;
case JUMP_FORWARD:
JUMPBY(oparg);
goto fast_next_opcode;
PREDICTED_WITH_ARG(JUMP_IF_FALSE);
case JUMP_IF_FALSE:
w = TOP();
if (w == Py_True) {
PREDICT(POP_TOP);
goto fast_next_opcode;
}
if (w == Py_False) {
JUMPBY(oparg);
goto fast_next_opcode;
}
err = PyObject_IsTrue(w);
if (err > 0)
err = 0;
else if (err == 0)
JUMPBY(oparg);
else
break;
continue;
case JUMP_ABSOLUTE:
JUMPTO(oparg);
continue;
case SETUP_LOOP:
PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg, STACK_LEVEL());
continue;
case CALL_FUNCTION:
x = call_function(&stack_pointer, oparg);
PUSH(x);
if (x != NULL)
continue;
break;
case MAKE_FUNCTION:
v = POP(); /* code object */
x = PyFunction_New(v, f->f_globals);
Py_DECREF(v);
/* XXX Maybe this should be a separate opcode? */
if (x != NULL && oparg > 0) {
v = PyTuple_New(oparg);
if (v == NULL) {
Py_DECREF(x);
x = NULL;
break;
}
while (--oparg >= 0) {
w = POP();
PyTuple_SET_ITEM(v, oparg, w);
}
err = PyFunction_SetDefaults(x, v);
Py_DECREF(v);
}
PUSH(x);
break;
case SET_LINENO:
break;
default:
printf("opcode: %d\n", opcode);
Py_FatalError("unknown opcode");
} /* switch */
on_error:
if (why == WHY_NOT) {
if (err == 0 && x != NULL) {
continue; /* Normal, fast path */
}
why = WHY_EXCEPTION;
x = Py_None;
err = 0;
}
/* End the loop if we still have an error (or return) */
if (why != WHY_NOT)
break;
} /* main loop */
if (why != WHY_YIELD) {
/* Pop remaining stack entries -- but when yielding */
while (!EMPTY()) {
v = POP();
Py_XDECREF(v);
}
}
if (why != WHY_RETURN && why != WHY_YIELD)
retval = NULL;
/* pop frame */
--tstate->recursion_depth;
tstate->frame = f->f_back;
return retval;
}}
// This dMList function creates a list of the dM values giving the probabilities of mutations
static PyObject *dMList(PyObject *self, PyObject *args) {
// Calling variables are (in order): uts, only_need, n_aa, length, grs, dmlist, residue_to_compute, iwt, brs
PyObject *uts, *only_need, *grs, *r_grs_tuple, *gr_diag, *p, *p_inv, *dmlist, *brs, *brz;
long n_aa, length, n_aa2, n_uts, residue_to_compute, i_ut, x, y, index, only_need_index, only_need_i, only_need_i_n_aa, index2, iwt, n_aa3, z;
double *arr_dmlist, *cp_inv, *cp, *cgr_diag, *cexpd, *cbrz, *cvrz, *cvrz_p_inv;
complex double *complex_cp_inv, *complex_cp, *complex_cgr_diag, *complex_cexpd, *complex_naa2_list, *complex_naa_list, *complex_cvrz, *complex_cvrz_p_inv, *complex_cbrz;
double ut, exp_utdx, exp_utdy, dx, dy;
complex double complex_exp_utdx, complex_exp_utdy, complex_dx, complex_dy;
int array_type;
#ifdef USE_ACCELERATE_CBLAS
complex double complex_one = 1, complex_zero = 0;
#else
complex double complex_dmxy, complex_v_p_inv_xy;
double dmxy, v_p_inv_xy;
long yindex, irowcolumn;
#endif
// Parse the arguments.
if (! PyArg_ParseTuple( args, "O!O!llO!O!llO!", &PyList_Type, &uts, &PyList_Type, &only_need, &n_aa, &length, &PyList_Type, &grs, &PyArray_Type, &dmlist, &residue_to_compute, &iwt, &PyList_Type, &brs)) {
PyErr_SetString(PyExc_TypeError, "Invalid calling arguments to dMList.");
return NULL;
}
// Error checking on arguments
if (length < 1) { // length of the protein
PyErr_SetString(PyExc_ValueError, "length is less than one.");
return NULL;
}
if (n_aa < 1) { // number of amino acids. Normally will be 20.
PyErr_SetString(PyExc_ValueError, "n_aa is less than one.");
return NULL;
}
if (PyList_GET_SIZE(grs) != length) { // make sure grs is of the same size as length
PyErr_SetString(PyExc_ValueError, "grs is not of the same size as length.");
return NULL;
}
n_uts = PyList_GET_SIZE(uts); // number of entries in uts
if (n_uts < 1) { // make sure there are entries in uts
PyErr_SetString(PyExc_ValueError, "uts has no entries.");
return NULL;
}
if (PyList_GET_SIZE(only_need) != n_uts * length) { // make sure only_need is of correct size
PyErr_SetString(PyExc_ValueError, "only_need is of wrong size.");
return NULL;
}
if (! ((residue_to_compute >= 0) && (residue_to_compute < length))) {
PyErr_SetString(PyExc_ValueError, "Invalid value for residue_to_compute.");
return NULL;
}
if (! ((iwt >= 0) && (iwt < n_aa))) {
PyErr_SetString(PyExc_ValueError, "Invalid value for iwt.");
return NULL;
}
if (PyList_GET_SIZE(brs) != n_aa) { // make sure brs has one entry for each amino acid
PyErr_SetString(PyExc_ValueError, "brs is not of length equal to n_aa");
return NULL;
}
n_aa2 = n_aa * n_aa; // square of the number of amino acids
n_aa3 = n_aa2 * n_aa; // cube of the number of amino acids
// The results will be returned in a numpy ndarray 'float_' (C type double) array called dmlist.
// This array will be of size length * n_uts * n_aa3.
arr_dmlist = (double *) PyArray_DATA(dmlist); // this is the data array of dmlist
long const sizeof_cexpd = n_aa2 * sizeof(double);
long const complex_sizeof_cexpd = n_aa2 * sizeof(complex double);
// gr_diag, p, and p_inv are the eigenvalues, left, and right diagonalizing matrices of gr
r_grs_tuple = PyList_GET_ITEM(grs, residue_to_compute);
gr_diag = PyTuple_GET_ITEM(r_grs_tuple, 0);
p = PyTuple_GET_ITEM(r_grs_tuple, 1);
p_inv = PyTuple_GET_ITEM(r_grs_tuple, 2);
// Now begin filling arr_dmlist with the appropriate values
index = 0;
only_need_index = residue_to_compute * n_uts;
// determine if these arrays are complex double or real doubles
array_type = PyArray_TYPE(gr_diag);
if (array_type == NPY_DOUBLE) { // array is of doubles, real not complex
// Note that these next assignments assume that the arrays are C-style contiguous
cp = PyArray_DATA(p);
cp_inv = PyArray_DATA(p_inv);
cgr_diag = PyArray_DATA(gr_diag);
cexpd = (double *) malloc(sizeof_cexpd); // allocate memory
cvrz = (double *) malloc(sizeof_cexpd); // allocate memory
cvrz_p_inv = (double *) malloc(sizeof_cexpd); // allocate memory
for (i_ut = 0; i_ut < n_uts; i_ut++) { // loop over ut values
only_need_i = PyInt_AS_LONG(PyList_GET_ITEM(only_need, only_need_index)); // value of only_need
only_need_index++;
if (only_need_i == -1) { // we don't need to do anything for these entries in dmlist
index += n_aa3;
} else { // we need to compute at least some entries in dmlist
ut = PyFloat_AS_DOUBLE(PyList_GET_ITEM(uts, i_ut)); // ut value
// Entries of cexpd are defined by D_xy = (exp(ut d_x) - exp(ut d_y)) / (d_x - d_y)
// for x != y, and D_yy = ut exp(d_x ut)
index2 = 0;
for (x = 0; x < n_aa; x++) {
dx = cgr_diag[x];
exp_utdx = exp(ut * dx);
for (y = 0; y < n_aa; y++) {
if (y == x) {
cexpd[index2] = ut * exp_utdx;
} else {
dy = cgr_diag[y];
exp_utdy = exp(ut * dy);
cexpd[index2] = (exp_utdx - exp_utdy) / (dx - dy);
}
index2++;
}
}
for (z = 0; z < n_aa; z++) {
// compute derivative with respect to z
if (z == iwt) { // don't compute values with respect to wildtype
index += n_aa2;
continue;
}
brz = PyList_GET_ITEM(brs, z);
cbrz = PyArray_DATA(brz);
// cvrz is the element-by-element product of cbrz and cexpd
for (index2 = 0; index2 < n_aa2; index2++) {
cvrz[index2] = cbrz[index2] * cexpd[index2];
}
#ifdef USE_ACCELERATE_CBLAS
// multiply the matrices using cblas_dgemm
cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n_aa, n_aa, n_aa, (double) 1.0, cvrz, n_aa, cp_inv, n_aa, (double) 0.0, cvrz_p_inv, n_aa); // multiply cvrz and cp_inv into cvrz_p_inv
#else
// multiply the matrices in pure C code
// multiply cvrz and cp_inv into cvrz_p_inv
index2 = 0;
for (x = 0; x < n_aa2; x += n_aa) {
for (y = 0; y < n_aa; y++) {
v_p_inv_xy = 0.0;
yindex = y;
for (irowcolumn = x; irowcolumn < x + n_aa; irowcolumn++) {
v_p_inv_xy += cvrz[irowcolumn] * cp_inv[yindex];
yindex += n_aa;
}
cvrz_p_inv[index2++] = v_p_inv_xy;
}
}
#endif
if (only_need_i == -2) { // we need to compute all of these entries in dmlist
#ifdef USE_ACCELERATE_CBLAS
cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n_aa, n_aa, n_aa, (double) 1.0, cp, n_aa, cvrz_p_inv, n_aa, (double) 0.0, &arr_dmlist[index], n_aa); // multiply cp and cvrz_p_inv into arr_dmlist[index : index + n_aa2]
index += n_aa2;
#else
// multiply the matrices in pure C code, and fill dmlist with the results
// multiply cp and cvrz_p_inv into arr_dmlist[index : index + n_aa2]
for (x = 0; x < n_aa2; x += n_aa) {
for (y = 0; y < n_aa; y++) {
dmxy = 0.0;
yindex = y;
for (irowcolumn = x; irowcolumn < x + n_aa; irowcolumn++) {
dmxy += cp[irowcolumn] * cvrz_p_inv[yindex];
yindex += n_aa;
}
arr_dmlist[index++] = dmxy;
}
}
#endif
} else { // we need to compute entries in dmlist only for x = only_need_i
only_need_i_n_aa = only_need_i * n_aa;
index += only_need_i_n_aa;
#ifdef USE_ACCELERATE_CBLAS
// do the matrix vector multiplication using cblas, and put results in dmlist
cblas_dgemv(CblasRowMajor, CblasTrans, n_aa, n_aa, (double) 1.0, cvrz_p_inv, n_aa, &cp[only_need_i_n_aa], 1, (double) 0.0, &arr_dmlist[index], 1);
index += n_aa2 - only_need_i_n_aa;
#else
// do the matrix vector multiplication in pure C code, and put results in mlist
for (y = 0; y < n_aa; y++) {
dmxy = 0.0;
yindex = y;
for (irowcolumn = only_need_i_n_aa; irowcolumn < only_need_i_n_aa + n_aa; irowcolumn++) {
dmxy += cp[irowcolumn] * cvrz_p_inv[yindex];
yindex += n_aa;
}
arr_dmlist[index++] = dmxy;
}
index += n_aa2 - only_need_i_n_aa - n_aa;
#endif
}
}
}
}
free(cexpd);
free(cvrz);
free(cvrz_p_inv);
} else if (array_type == NPY_CDOUBLE) { // array is of complex doubles
// Note that these next assignments assume that the arrays are C-style contiguous
complex_cp = PyArray_DATA(p);
complex_cp_inv = PyArray_DATA(p_inv);
complex_cgr_diag = PyArray_DATA(gr_diag);
complex_cexpd = (complex double *) malloc(complex_sizeof_cexpd); // allocate memory
complex_cvrz = (complex double *) malloc(complex_sizeof_cexpd); // allocate memory
complex_cvrz_p_inv = (complex double *) malloc(complex_sizeof_cexpd); // allocate memory
complex_naa2_list = (complex double *) malloc(n_aa2 * sizeof(complex double)); // allocate memory
complex_naa_list = (complex double *) malloc(n_aa * sizeof(complex double)); // allocate memory
for (i_ut = 0; i_ut < n_uts; i_ut++) { // loop over ut values
only_need_i = PyInt_AS_LONG(PyList_GET_ITEM(only_need, only_need_index)); // value of only_need
only_need_index++;
if (only_need_i == -1) { // we don't need to do anything for these entries in dmlist
index += n_aa3;
} else { // we need to compute at least some entries in dmlist
ut = PyFloat_AS_DOUBLE(PyList_GET_ITEM(uts, i_ut)); // ut value
// Entries of cexpd are defined by D_xy = (exp(ut d_x) - exp(ut d_y)) / (d_x - d_y)
// for x != y, and D_yy = ut exp(d_x ut)
index2 = 0;
for (x = 0; x < n_aa; x++) {
complex_dx = complex_cgr_diag[x];
complex_exp_utdx = cexp(ut * complex_dx);
for (y = 0; y < n_aa; y++) {
if (y == x) {
complex_cexpd[index2] = ut * complex_exp_utdx;
} else {
complex_dy = complex_cgr_diag[y];
complex_exp_utdy = cexp(ut * complex_dy);
complex_cexpd[index2] = (complex_exp_utdx - complex_exp_utdy) / (complex_dx - complex_dy);
}
index2++;
}
}
for (z = 0; z < n_aa; z++) {
// compute derivative with respect to z
if (z == iwt) { // don't compute values with respect to wildtype
index += n_aa2;
continue;
}
brz = PyList_GET_ITEM(brs, z);
complex_cbrz = PyArray_DATA(brz);
// cvrz is the element-by-element product of cbrz and cexpd
for (index2 = 0; index2 < n_aa2; index2++) {
complex_cvrz[index2] = complex_cbrz[index2] * complex_cexpd[index2];
}
#ifdef USE_ACCELERATE_CBLAS
// multiply the matrices using cblas_zgemm
cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n_aa, n_aa, n_aa, &complex_one, complex_cvrz, n_aa, complex_cp_inv, n_aa, &complex_zero, complex_cvrz_p_inv, n_aa); // multiply cvrz and cp_inv into cvrz_p_inv
#else
// multiply the matrices in pure C code
// multiply cvrz and cp_inv into cvrz_p_inv
index2 = 0;
for (x = 0; x < n_aa2; x += n_aa) {
for (y = 0; y < n_aa; y++) {
complex_v_p_inv_xy = 0.0;
yindex = y;
for (irowcolumn = x; irowcolumn < x + n_aa; irowcolumn++) {
complex_v_p_inv_xy += complex_cvrz[irowcolumn] * complex_cp_inv[yindex];
yindex += n_aa;
}
complex_cvrz_p_inv[index2++] = complex_v_p_inv_xy;
}
}
#endif
if (only_need_i == -2) { // we need to compute all of these entries in dmlist
#ifdef USE_ACCELERATE_CBLAS
cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n_aa, n_aa, n_aa, &complex_one, complex_cp, n_aa, complex_cvrz_p_inv, n_aa, &complex_zero, complex_naa2_list, n_aa); // multiply cp and cvrz_p_inv into arr_dmlist[index : index + n_aa2]
for (index2 = 0; index2 < n_aa2; index2++) {
arr_dmlist[index + index2] = creal(complex_naa2_list[index2]);
}
index += n_aa2;
#else
// multiply the matrices in pure C code, and fill dmlist with the results
// multiply cp and cvrz_p_inv into arr_dmlist[index : index + n_aa2]
for (x = 0; x < n_aa2; x += n_aa) {
for (y = 0; y < n_aa; y++) {
complex_dmxy = 0.0;
yindex = y;
for (irowcolumn = x; irowcolumn < x + n_aa; irowcolumn++) {
complex_dmxy += complex_cp[irowcolumn] * complex_cvrz_p_inv[yindex];
yindex += n_aa;
}
arr_dmlist[index++] = creal(complex_dmxy);
}
}
#endif
} else { // we need to compute entries in dmlist only for x = only_need_i
only_need_i_n_aa = only_need_i * n_aa;
index += only_need_i_n_aa;
#ifdef USE_ACCELERATE_CBLAS
// do the matrix vector multiplication using cblas, and put results in dmlist
cblas_zgemv(CblasRowMajor, CblasTrans, n_aa, n_aa, &complex_one, complex_cvrz_p_inv, n_aa, &complex_cp[only_need_i_n_aa], 1, &complex_zero, complex_naa_list, 1);
for (index2 = 0; index2 < n_aa; index2++) {
arr_dmlist[index + index2] = creal(complex_naa_list[index2]);
}
index += n_aa2 - only_need_i_n_aa;
#else
// do the matrix vector multiplication in pure C code, and put results in mlist
for (y = 0; y < n_aa; y++) {
complex_dmxy = 0.0;
yindex = y;
for (irowcolumn = only_need_i_n_aa; irowcolumn < only_need_i_n_aa + n_aa; irowcolumn++) {
complex_dmxy += complex_cp[irowcolumn] * complex_cvrz_p_inv[yindex];
yindex += n_aa;
}
arr_dmlist[index++] = creal(complex_dmxy);
}
index += n_aa2 - only_need_i_n_aa - n_aa;
#endif
}
}
}
}
free(complex_cexpd);
free(complex_cvrz);
free(complex_cvrz_p_inv);
free(complex_naa2_list);
free(complex_naa_list);
} else { // array is of neither real nor complex doubles
PyErr_SetString(PyExc_ValueError, "matrices are neither double nor complex doubles.");
return NULL;
}
return PyInt_FromLong((long) 1);
}
static int
handle_starttag(tdi_soup_parser *self, tdi_parser_event *event,
tdi_lexer_event *event_)
{
PyObject *name, *normname, *tmp, *data;
int res;
if (self->inempty && close_empty(self) == -1) return -1;
/* sanitize */
if (PyString_GET_SIZE(event_->info.starttag.name) == 0
&& PyList_GET_SIZE(event_->info.starttag.attr) == 0) {
name = (Py_INCREF(self->lastopen), self->lastopen);
}
else {
name = event_->info.starttag.name;
Py_INCREF(name);
Py_CLEAR(self->lastopen);
self->lastopen = (Py_INCREF(name), name);
}
if (!(normname = self->normalize(self->normalize_ctx, name)))
goto error;
/* close unnestables */
while (self->tagstack) {
res = self->nestable(self->nestable_ctx,
self->tagstack->normname, normname);
if (res == -1)
goto error_normname;
if (res) break;
event->type = TDI_PARSER_EVENT_ENDTAG;
if (!(data = PyString_FromString("")))
goto error_normname;
tmp = self->tagstack->name;
event->info.endtag.name = (Py_INCREF(tmp), tmp);
event->info.endtag.data = data;
tagstack_pop(&self->tagstack);
res = !self->cb(event, self->cb_ctx) ? 0 : -1;
Py_DECREF(tmp);
Py_DECREF(data);
if (res == -1)
goto error_normname;
}
/* CDATA */
if (!event_->info.starttag.closed) {
if ((res = self->cdata(self->cdata_ctx, normname)) == -1)
goto error_normname;
if (res) {
res = tdi_soup_lexer_state_cdata(self->lexer, self->normalize,
self->normalize_ctx, normname);
if (res == -1) {
lexer_error(self);
goto error_normname;
}
}
}
/* pass event */
event->type = TDI_PARSER_EVENT_STARTTAG;
event->info.starttag.name = name;
event->info.starttag.attr = event_->info.starttag.attr;
event->info.starttag.closed = event_->info.starttag.closed;
event->info.starttag.data = event_->info.starttag.data;
if (self->cb(event, self->cb_ctx))
goto error_normname;
/* Maintain stack */
if (!event_->info.starttag.closed) {
if (tagstack_push(&self->tagstack, normname, name) == -1)
goto error_normname;
if ((res = self->empty(self->empty_ctx, normname)) == -1)
goto error_normname;
if (res)
self->inempty = 1;
}
/* cleanup & finish */
Py_DECREF(normname);
Py_DECREF(name);
return 0;
error_normname:
Py_DECREF(normname);
error:
Py_DECREF(name);
if (!self->last_error)
self->last_error = TDI_PARSER_ERR_ENV;
return -1;
}
static int
dialect_init(DialectObj * self, PyObject * args, PyObject * kwargs)
{
PyObject *dialect = NULL, *name_obj, *value_obj;
self->quotechar = '"';
self->delimiter = ',';
self->escapechar = '\0';
self->skipinitialspace = 0;
Py_XDECREF(self->lineterminator);
self->lineterminator = PyString_FromString("\r\n");
if (self->lineterminator == NULL)
return -1;
self->quoting = QUOTE_MINIMAL;
self->doublequote = 1;
self->strict = 0;
if (!PyArg_UnpackTuple(args, "", 0, 1, &dialect))
return -1;
Py_XINCREF(dialect);
if (kwargs != NULL) {
PyObject * key = PyString_FromString("dialect");
PyObject * d;
d = PyDict_GetItem(kwargs, key);
if (d) {
Py_INCREF(d);
Py_XDECREF(dialect);
PyDict_DelItem(kwargs, key);
dialect = d;
}
Py_DECREF(key);
}
if (dialect != NULL) {
int i;
PyObject * dir_list;
/* If dialect is a string, look it up in our registry */
if (PyString_Check(dialect)
#ifdef Py_USING_UNICODE
|| PyUnicode_Check(dialect)
#endif
) {
PyObject * new_dia;
new_dia = get_dialect_from_registry(dialect);
Py_DECREF(dialect);
if (new_dia == NULL)
return -1;
dialect = new_dia;
}
/* A class rather than an instance? Instantiate */
if (PyObject_TypeCheck(dialect, &PyClass_Type)) {
PyObject * new_dia;
new_dia = PyObject_CallFunction(dialect, "");
Py_DECREF(dialect);
if (new_dia == NULL)
return -1;
dialect = new_dia;
}
/* Make sure we finally have an instance */
if (!PyInstance_Check(dialect) ||
(dir_list = PyObject_Dir(dialect)) == NULL) {
PyErr_SetString(PyExc_TypeError,
"dialect must be an instance");
Py_DECREF(dialect);
return -1;
}
/* And extract the attributes */
for (i = 0; i < PyList_GET_SIZE(dir_list); ++i) {
char *s;
name_obj = PyList_GET_ITEM(dir_list, i);
s = PyString_AsString(name_obj);
if (s == NULL)
return -1;
if (s[0] == '_')
continue;
value_obj = PyObject_GetAttr(dialect, name_obj);
if (value_obj) {
if (PyObject_SetAttr((PyObject *)self,
name_obj, value_obj)) {
Py_DECREF(value_obj);
Py_DECREF(dir_list);
Py_DECREF(dialect);
return -1;
}
Py_DECREF(value_obj);
}
}
Py_DECREF(dir_list);
Py_DECREF(dialect);
}
if (kwargs != NULL) {
int pos = 0;
while (PyDict_Next(kwargs, &pos, &name_obj, &value_obj)) {
if (PyObject_SetAttr((PyObject *)self,
name_obj, value_obj))
return -1;
}
}
return 0;
}
/**
* Function to call to evaluate model
* @param args: input q or [q,phi]
* @return: function value
*/
static PyObject * run(CFlexCylEllipXModel *self, PyObject *args) {
double q_value, phi_value;
PyObject* pars;
int npars;
// Get parameters
// Reader parameter dictionary
self->model->scale = PyFloat_AsDouble( PyDict_GetItemString(self->params, "scale") );
self->model->sldCyl = PyFloat_AsDouble( PyDict_GetItemString(self->params, "sldCyl") );
self->model->axis_ratio = PyFloat_AsDouble( PyDict_GetItemString(self->params, "axis_ratio") );
self->model->length = PyFloat_AsDouble( PyDict_GetItemString(self->params, "length") );
self->model->radius = PyFloat_AsDouble( PyDict_GetItemString(self->params, "radius") );
self->model->background = PyFloat_AsDouble( PyDict_GetItemString(self->params, "background") );
self->model->sldSolv = PyFloat_AsDouble( PyDict_GetItemString(self->params, "sldSolv") );
self->model->kuhn_length = PyFloat_AsDouble( PyDict_GetItemString(self->params, "kuhn_length") );
// Read in dispersion parameters
PyObject* disp_dict;
DispersionVisitor* visitor = new DispersionVisitor();
disp_dict = PyDict_GetItemString(self->dispersion, "length");
self->model->length.dispersion->accept_as_destination(visitor, self->model->length.dispersion, disp_dict);
disp_dict = PyDict_GetItemString(self->dispersion, "kuhn_length");
self->model->kuhn_length.dispersion->accept_as_destination(visitor, self->model->kuhn_length.dispersion, disp_dict);
disp_dict = PyDict_GetItemString(self->dispersion, "radius");
self->model->radius.dispersion->accept_as_destination(visitor, self->model->radius.dispersion, disp_dict);
disp_dict = PyDict_GetItemString(self->dispersion, "axis_ratio");
self->model->axis_ratio.dispersion->accept_as_destination(visitor, self->model->axis_ratio.dispersion, disp_dict);
// Get input and determine whether we have to supply a 1D or 2D return value.
if ( !PyArg_ParseTuple(args,"O",&pars) ) {
PyErr_SetString(CFlexCylEllipXModelError,
"CFlexCylEllipXModel.run expects a q value.");
return NULL;
}
// Check params
if( PyList_Check(pars)==1) {
// Length of list should be 2 for I(q,phi)
npars = PyList_GET_SIZE(pars);
if(npars!=2) {
PyErr_SetString(CFlexCylEllipXModelError,
"CFlexCylEllipXModel.run expects a double or a list of dimension 2.");
return NULL;
}
// We have a vector q, get the q and phi values at which
// to evaluate I(q,phi)
q_value = CFlexCylEllipXModel_readDouble(PyList_GET_ITEM(pars,0));
phi_value = CFlexCylEllipXModel_readDouble(PyList_GET_ITEM(pars,1));
// Skip zero
if (q_value==0) {
return Py_BuildValue("d",0.0);
}
return Py_BuildValue("d",(*(self->model)).evaluate_rphi(q_value,phi_value));
} else {
// We have a scalar q, we will evaluate I(q)
q_value = CFlexCylEllipXModel_readDouble(pars);
return Py_BuildValue("d",(*(self->model))(q_value));
}
}
static PyObject *
SPI_xfer(SPI *self, PyObject *args)
{
uint8_t ii, len;
int status;
int delay = -1;
//uint8_t ret = 0;
PyObject *list;
struct spi_ioc_transfer *xferptr;
uint8_t *txbuf, *rxbuf;
if (!PyArg_ParseTuple(args, "O|i:msg", &list, &delay))
return NULL;
if (!PyList_Check(list)) {
PyErr_SetString(PyExc_TypeError, wrmsg);
return NULL;
}
if ((len = PyList_GET_SIZE(list)) > MAXMSGLEN) {
PyErr_SetString(PyExc_OverflowError, wrmsg);
return NULL;
}
if (delay == -1) {
delay = 0;
}
xferptr = (struct spi_ioc_transfer*) malloc(sizeof(struct spi_ioc_transfer) * len);
txbuf = malloc(sizeof(__u8) * len);
rxbuf = malloc(sizeof(__u8) * len);
for (ii = 0; ii < len; ii++) {
PyObject *val = PyList_GET_ITEM(list, ii);
if (!PyInt_Check(val)) {
PyErr_SetString(PyExc_TypeError, wrmsg);
return NULL;
}
txbuf[ii] = (__u8)PyInt_AS_LONG(val);
xferptr[ii].tx_buf = (unsigned long)&txbuf[ii];
xferptr[ii].rx_buf = (unsigned long)&rxbuf[ii];
xferptr[ii].len = 1;
xferptr[ii].delay_usecs = delay;
xferptr[ii].speed_hz = 0;
xferptr[ii].bits_per_word = 0;
}
status = ioctl(self->fd, SPI_IOC_MESSAGE(len), xferptr);
if (status < 0) {
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
for (ii = 0; ii < len; ii++) {
PyObject *val = Py_BuildValue("l", (long)rxbuf[ii]);
PyList_SET_ITEM(list, ii, val);
}
// WA:
// in CS_HIGH mode CS isn't pulled to low after transfer, but after read
// reading 0 bytes doesnt matter but brings cs down
status = read(self->fd, &rxbuf[0], 0);
free(txbuf);
free(rxbuf);
free(xferptr);
Py_INCREF(list);
return list;
}
static PyObject *
SPI_xfer2(SPI *self, PyObject *args)
{
static char *msg = "Argument must be a list of at least one, "
"but not more than 1024 integers";
int status;
uint8_t ii, len;
PyObject *list;
struct spi_ioc_transfer xfer;
uint8_t *txbuf, *rxbuf;
if (!PyArg_ParseTuple(args, "O:xfer2", &list))
return NULL;
if (!PyList_Check(list)) {
PyErr_SetString(PyExc_TypeError, wrmsg);
return NULL;
}
if ((len = PyList_GET_SIZE(list)) > MAXMSGLEN) {
PyErr_SetString(PyExc_OverflowError, wrmsg);
return NULL;
}
txbuf = malloc(sizeof(__u8) * len);
rxbuf = malloc(sizeof(__u8) * len);
for (ii = 0; ii < len; ii++) {
PyObject *val = PyList_GET_ITEM(list, ii);
if (!PyInt_Check(val)) {
PyErr_SetString(PyExc_TypeError, msg);
return NULL;
}
txbuf[ii] = (__u8)PyInt_AS_LONG(val);
}
xfer.tx_buf = (unsigned long)txbuf;
xfer.rx_buf = (unsigned long)rxbuf;
xfer.len = len;
xfer.delay_usecs = 0;
xfer.speed_hz = 0;
xfer.bits_per_word = 0;
status = ioctl(self->fd, SPI_IOC_MESSAGE(1), &xfer);
if (status < 0) {
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
for (ii = 0; ii < len; ii++) {
PyObject *val = Py_BuildValue("l", (long)rxbuf[ii]);
PyList_SET_ITEM(list, ii, val);
}
// WA:
// in CS_HIGH mode CS isnt pulled to low after transfer
// reading 0 bytes doesn't really matter but brings CS down
status = read(self->fd, &rxbuf[0], 0);
free(txbuf);
free(rxbuf);
Py_INCREF(list);
return list;
}
static PyObject *
GMPy_Context_Fsum(PyObject *self, PyObject *other)
{
MPFR_Object *temp, *result;
mpfr_ptr *tab;
int errcode;
Py_ssize_t i, seq_length = 0;
CTXT_Object *context = NULL;
if (self && CTXT_Check(self)) {
context = (CTXT_Object*)self;
}
else {
CHECK_CONTEXT(context);
}
if (!(result = GMPy_MPFR_New(0, context))) {
return NULL;
}
if (!(other = PySequence_List(other))) {
Py_DECREF((PyObject*)result);
TYPE_ERROR("argument must be an iterable");
return NULL;
}
/* other contains a new list containing all the values from the
* iterable. Now make sure each item in the list is an mpfr.
*/
seq_length = PyList_GET_SIZE(other);
for (i=0; i < seq_length; i++) {
if (!(temp = GMPy_MPFR_From_Real(PyList_GET_ITEM(other, i), 1, context))) {
Py_DECREF(other);
Py_DECREF((PyObject*)result);
TYPE_ERROR("all items in iterable must be real numbers");
return NULL;
}
errcode = PyList_SetItem(other, i,(PyObject*)temp);
if (errcode < 0) {
Py_DECREF(other);
Py_DECREF((PyObject*)result);
TYPE_ERROR("all items in iterable must be real numbers");
return NULL;
}
}
/* create an array of pointers to the mpfr_t field of a Pympfr object */
if (!(tab = (mpfr_ptr *)GMPY_MALLOC((sizeof(mpfr_srcptr) * seq_length)))) {
Py_DECREF(other);
Py_DECREF((PyObject*)result);
return PyErr_NoMemory();
}
for (i=0; i < seq_length; i++) {
temp = (MPFR_Object*)PyList_GET_ITEM(other, i);
tab[i] = temp->f;
}
mpfr_clear_flags();
result->rc = mpfr_sum(result->f, tab, seq_length, GET_MPFR_ROUND(context));
Py_DECREF(other);
GMPY_FREE(tab);
_GMPy_MPFR_Cleanup(&result, context);
return (PyObject*)result;
}
static int PyBobIpGaborGraph_init(PyBobIpGaborGraphObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist1 = Graph_doc.kwlist(3);
char** kwlist2 = Graph_doc.kwlist(2);
char** kwlist3 = Graph_doc.kwlist(1);
char** kwlist4 = Graph_doc.kwlist(0);
// get the number of command line arguments
Py_ssize_t nargs = (args?PyTuple_Size(args):0) + (kwargs?PyDict_Size(kwargs):0);
switch (nargs){
case 1: {
// two ways to call with one argument
PyObject* k = Py_BuildValue("s", kwlist1[0]);
auto k_ = make_safe(k);
if (
(kwargs && PyDict_Contains(kwargs, k)) ||
(args && PyBobIoHDF5File_Check(PyTuple_GetItem(args, 0)))
){
PyBobIoHDF5FileObject* hdf5;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&", kwlist1, &PyBobIoHDF5File_Converter, &hdf5)) return -1;
auto hdf5_ = make_safe(hdf5);
self->cxx.reset(new bob::ip::gabor::Graph(*hdf5->f));
} else {
PyListObject* list;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist2, &PyList_Type, &list)) return -1;
std::vector<blitz::TinyVector<int,2>> nodes(PyList_GET_SIZE(list));
Py_ssize_t i = 0;
for (auto nit = nodes.begin(); nit != nodes.end(); ++nit, ++i){
// check that the object inside the list is a two-element int tuple
if (!PyArg_ParseTuple(PyList_GET_ITEM(list, i), "ii", &((*nit)[0]), &((*nit)[1]))){
PyErr_Format(PyExc_TypeError, "%s requires only tuples of two integral positions in the nodes list", Py_TYPE(self)->tp_name);
return -1;
}
}
self->cxx.reset(new bob::ip::gabor::Graph(nodes));
}
break;
}
case 3:{
blitz::TinyVector<int,2> first, last, step;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "(ii)(ii)(ii)", kwlist3, &first[0], &first[1], &last[0], &last[1], &step[0], &step[1])) return -1;
self->cxx.reset(new bob::ip::gabor::Graph(first, last, step));
}
break;
case 6:{
blitz::TinyVector<int,2> right, left;
int between, along, above, below;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "(ii)(ii)iiii", kwlist4, &right[0], &right[1], &left[0], &left[1], &between, &along, &above, &below)) return -1;
self->cxx.reset(new bob::ip::gabor::Graph(right, left, between, along, above, below));
}
break;
default:
return -1;
}
return 0;
BOB_CATCH_MEMBER("Graph constructor", -1)
}
//=============================================================================
// List iteration functions
// itemValue is borrowed from object (which is list). No refcounting
//=============================================================================
void List_iterBegin(JSOBJ obj, JSONTypeContext *tc)
{
GET_TC(tc)->index = 0;
GET_TC(tc)->size = PyList_GET_SIZE( (PyObject *) obj);
}
// 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;
}
static PyObject *
SpiDev_xfer2(SpiDevObject *self, PyObject *args)
{
static char *msg = "Argument must be a list of at least one, "
"but not more than 4096 integers";
int status;
uint16_t delay_usecs = 0;
uint32_t speed_hz = 0;
uint8_t bits_per_word = 0;
uint16_t ii, len;
PyObject *list;
struct spi_ioc_transfer xfer;
memset(&xfer, 0, sizeof(xfer));
uint8_t *txbuf, *rxbuf;
if (!PyArg_ParseTuple(args, "O|IHB:xfer2", &list, &speed_hz, &delay_usecs, &bits_per_word))
return NULL;
if (!PyList_Check(list)) {
PyErr_SetString(PyExc_TypeError, wrmsg);
return NULL;
}
if ((len = PyList_GET_SIZE(list)) > SPIDEV_MAXPATH) {
PyErr_SetString(PyExc_OverflowError, wrmsg);
return NULL;
}
txbuf = malloc(sizeof(__u8) * len);
rxbuf = malloc(sizeof(__u8) * len);
for (ii = 0; ii < len; ii++) {
PyObject *val = PyList_GET_ITEM(list, ii);
if (!PyLong_Check(val)) {
PyErr_SetString(PyExc_TypeError, msg);
free(txbuf);
free(rxbuf);
return NULL;
}
txbuf[ii] = (__u8)PyLong_AS_LONG(val);
}
xfer.tx_buf = (unsigned long)txbuf;
xfer.rx_buf = (unsigned long)rxbuf;
xfer.len = len;
xfer.delay_usecs = delay_usecs;
xfer.speed_hz = speed_hz ? speed_hz : self->max_speed_hz;
xfer.bits_per_word = bits_per_word ? bits_per_word : self->bits_per_word;
status = ioctl(self->fd, SPI_IOC_MESSAGE(1), &xfer);
if (status < 0) {
PyErr_SetFromErrno(PyExc_IOError);
free(txbuf);
free(rxbuf);
return NULL;
}
list = PyList_New(len);
for (ii = 0; ii < len; ii++) {
PyObject *val = Py_BuildValue("l", (long)rxbuf[ii]);
PyList_SET_ITEM(list, ii, val);
}
// WA:
// in CS_HIGH mode CS isnt pulled to low after transfer
// reading 0 bytes doesn't really matter but brings CS down
// tomdean:
// Stop generating an extra CS except in mode CS_HOGH
if (self->mode & SPI_CS_HIGH) status = read(self->fd, &rxbuf[0], 0);
free(txbuf);
free(rxbuf);
return list;
}
void qpycore_qmetaobject_connectslotsbyname(QObject *qobj,
PyObject *qobj_wrapper)
{
// Get the class attributes.
PyObject *dir = PyObject_Dir((PyObject *)Py_TYPE(qobj_wrapper));
if (!dir)
return;
PyObject *slot_obj = 0;
for (SIP_SSIZE_T li = 0; li < PyList_GET_SIZE(dir); ++li)
{
PyObject *name_obj = PyList_GET_ITEM(dir, li);
// Get the slot object.
Py_XDECREF(slot_obj);
slot_obj = PyObject_GetAttr(qobj_wrapper, name_obj);
if (!slot_obj)
continue;
// Ignore it if it is not a callable.
if (!PyCallable_Check(slot_obj))
continue;
// Use the signature attribute instead of the name if there is one.
PyObject *sigattr = PyObject_GetAttr(slot_obj,
qpycore_signature_attr_name);
if (sigattr)
{
for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sigattr); ++i)
{
PyObject *decoration = PyList_GET_ITEM(sigattr, i);
Chimera::Signature *sig = Chimera::Signature::fromPyObject(decoration);
QByteArray args = sig->arguments();
if (!args.isEmpty())
connect(qobj, slot_obj, sig->name(), args);
}
Py_DECREF(sigattr);
}
else
{
const char *ascii_name = sipString_AsASCIIString(&name_obj);
if (!ascii_name)
continue;
PyErr_Clear();
connect(qobj, slot_obj, QByteArray(ascii_name), QByteArray());
Py_DECREF(name_obj);
}
}
Py_XDECREF(slot_obj);
Py_DECREF(dir);
}
PyObject *
PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
PyObject *lineno_obj)
{
Py_ssize_t i, j, codelen;
int nops, h, adj;
int tgt, tgttgt, opcode;
unsigned char *codestr = NULL;
unsigned char *lineno;
int *addrmap = NULL;
int new_line, cum_orig_line, last_line, tabsiz;
int cumlc=0, lastlc=0; /* Count runs of consecutive LOAD_CONSTs */
unsigned int *blocks = NULL;
char *name;
/* Bail out if an exception is set */
if (PyErr_Occurred())
goto exitError;
/* Bypass optimization when the lineno table is too complex */
assert(PyString_Check(lineno_obj));
lineno = (unsigned char*)PyString_AS_STRING(lineno_obj);
tabsiz = PyString_GET_SIZE(lineno_obj);
if (memchr(lineno, 255, tabsiz) != NULL)
goto exitUnchanged;
/* Avoid situations where jump retargeting could overflow */
assert(PyString_Check(code));
codelen = PyString_GET_SIZE(code);
if (codelen > 32700)
goto exitUnchanged;
/* Make a modifiable copy of the code string */
codestr = (unsigned char *)PyMem_Malloc(codelen);
if (codestr == NULL)
goto exitError;
codestr = (unsigned char *)memcpy(codestr,
PyString_AS_STRING(code), codelen);
/* Verify that RETURN_VALUE terminates the codestring. This allows
the various transformation patterns to look ahead several
instructions without additional checks to make sure they are not
looking beyond the end of the code string.
*/
if (codestr[codelen-1] != RETURN_VALUE)
goto exitUnchanged;
/* Mapping to new jump targets after NOPs are removed */
addrmap = (int *)PyMem_Malloc(codelen * sizeof(int));
if (addrmap == NULL)
goto exitError;
blocks = markblocks(codestr, codelen);
if (blocks == NULL)
goto exitError;
assert(PyList_Check(consts));
for (i=0 ; i<codelen ; i += CODESIZE(codestr[i])) {
opcode = codestr[i];
lastlc = cumlc;
cumlc = 0;
switch (opcode) {
/* Replace UNARY_NOT JUMP_IF_FALSE POP_TOP with
with JUMP_IF_TRUE POP_TOP */
case UNARY_NOT:
if (codestr[i+1] != JUMP_IF_FALSE ||
codestr[i+4] != POP_TOP ||
!ISBASICBLOCK(blocks,i,5))
continue;
tgt = GETJUMPTGT(codestr, (i+1));
if (codestr[tgt] != POP_TOP)
continue;
j = GETARG(codestr, i+1) + 1;
codestr[i] = JUMP_IF_TRUE;
SETARG(codestr, i, j);
codestr[i+3] = POP_TOP;
codestr[i+4] = NOP;
break;
/* not a is b --> a is not b
not a in b --> a not in b
not a is not b --> a is b
not a not in b --> a in b
*/
case COMPARE_OP:
j = GETARG(codestr, i);
if (j < 6 || j > 9 ||
codestr[i+3] != UNARY_NOT ||
!ISBASICBLOCK(blocks,i,4))
continue;
SETARG(codestr, i, (j^1));
codestr[i+3] = NOP;
break;
/* Replace LOAD_GLOBAL/LOAD_NAME None
with LOAD_CONST None */
case LOAD_NAME:
case LOAD_GLOBAL:
j = GETARG(codestr, i);
name = PyString_AsString(PyTuple_GET_ITEM(names, j));
if (name == NULL || strcmp(name, "None") != 0)
continue;
for (j=0 ; j < PyList_GET_SIZE(consts) ; j++) {
if (PyList_GET_ITEM(consts, j) == Py_None)
break;
}
if (j == PyList_GET_SIZE(consts)) {
if (PyList_Append(consts, Py_None) == -1)
goto exitError;
}
assert(PyList_GET_ITEM(consts, j) == Py_None);
codestr[i] = LOAD_CONST;
SETARG(codestr, i, j);
cumlc = lastlc + 1;
break;
/* Skip over LOAD_CONST trueconst
JUMP_IF_FALSE xx POP_TOP */
case LOAD_CONST:
cumlc = lastlc + 1;
j = GETARG(codestr, i);
if (codestr[i+3] != JUMP_IF_FALSE ||
codestr[i+6] != POP_TOP ||
!ISBASICBLOCK(blocks,i,7) ||
!PyObject_IsTrue(PyList_GET_ITEM(consts, j)))
continue;
memset(codestr+i, NOP, 7);
cumlc = 0;
break;
/* Try to fold tuples of constants (includes a case for lists
which are only used for "in" and "not in" tests).
Skip over BUILD_SEQN 1 UNPACK_SEQN 1.
Replace BUILD_SEQN 2 UNPACK_SEQN 2 with ROT2.
Replace BUILD_SEQN 3 UNPACK_SEQN 3 with ROT3 ROT2. */
case BUILD_TUPLE:
case BUILD_LIST:
j = GETARG(codestr, i);
h = i - 3 * j;
if (h >= 0 &&
j <= lastlc &&
((opcode == BUILD_TUPLE &&
ISBASICBLOCK(blocks, h, 3*(j+1))) ||
(opcode == BUILD_LIST &&
codestr[i+3]==COMPARE_OP &&
ISBASICBLOCK(blocks, h, 3*(j+2)) &&
(GETARG(codestr,i+3)==6 ||
GETARG(codestr,i+3)==7))) &&
tuple_of_constants(&codestr[h], j, consts)) {
assert(codestr[i] == LOAD_CONST);
cumlc = 1;
break;
}
if (codestr[i+3] != UNPACK_SEQUENCE ||
!ISBASICBLOCK(blocks,i,6) ||
j != GETARG(codestr, i+3))
continue;
if (j == 1) {
memset(codestr+i, NOP, 6);
} else if (j == 2) {
codestr[i] = ROT_TWO;
memset(codestr+i+1, NOP, 5);
} else if (j == 3) {
codestr[i] = ROT_THREE;
codestr[i+1] = ROT_TWO;
memset(codestr+i+2, NOP, 4);
}
break;
/* Fold binary ops on constants.
LOAD_CONST c1 LOAD_CONST c2 BINOP --> LOAD_CONST binop(c1,c2) */
case BINARY_POWER:
case BINARY_MULTIPLY:
case BINARY_TRUE_DIVIDE:
case BINARY_FLOOR_DIVIDE:
case BINARY_MODULO:
case BINARY_ADD:
case BINARY_SUBTRACT:
case BINARY_SUBSCR:
case BINARY_LSHIFT:
case BINARY_RSHIFT:
case BINARY_AND:
case BINARY_XOR:
case BINARY_OR:
if (lastlc >= 2 &&
ISBASICBLOCK(blocks, i-6, 7) &&
fold_binops_on_constants(&codestr[i-6], consts)) {
i -= 2;
assert(codestr[i] == LOAD_CONST);
cumlc = 1;
}
break;
/* Fold unary ops on constants.
LOAD_CONST c1 UNARY_OP --> LOAD_CONST unary_op(c) */
case UNARY_NEGATIVE:
case UNARY_CONVERT:
case UNARY_INVERT:
if (lastlc >= 1 &&
ISBASICBLOCK(blocks, i-3, 4) &&
fold_unaryops_on_constants(&codestr[i-3], consts)) {
i -= 2;
assert(codestr[i] == LOAD_CONST);
cumlc = 1;
}
break;
/* Simplify conditional jump to conditional jump where the
result of the first test implies the success of a similar
test or the failure of the opposite test.
Arises in code like:
"if a and b:"
"if a or b:"
"a and b or c"
"(a and b) and c"
x:JUMP_IF_FALSE y y:JUMP_IF_FALSE z --> x:JUMP_IF_FALSE z
x:JUMP_IF_FALSE y y:JUMP_IF_TRUE z --> x:JUMP_IF_FALSE y+3
where y+3 is the instruction following the second test.
*/
case JUMP_IF_FALSE:
case JUMP_IF_TRUE:
tgt = GETJUMPTGT(codestr, i);
j = codestr[tgt];
if (j == JUMP_IF_FALSE || j == JUMP_IF_TRUE) {
if (j == opcode) {
tgttgt = GETJUMPTGT(codestr, tgt) - i - 3;
SETARG(codestr, i, tgttgt);
} else {
tgt -= i;
SETARG(codestr, i, tgt);
}
break;
}
/* Intentional fallthrough */
/* Replace jumps to unconditional jumps */
case FOR_ITER:
case JUMP_FORWARD:
case JUMP_ABSOLUTE:
case CONTINUE_LOOP:
case SETUP_LOOP:
case SETUP_EXCEPT:
case SETUP_FINALLY:
tgt = GETJUMPTGT(codestr, i);
/* Replace JUMP_* to a RETURN into just a RETURN */
if (UNCONDITIONAL_JUMP(opcode) &&
codestr[tgt] == RETURN_VALUE) {
codestr[i] = RETURN_VALUE;
memset(codestr+i+1, NOP, 2);
continue;
}
if (!UNCONDITIONAL_JUMP(codestr[tgt]))
continue;
tgttgt = GETJUMPTGT(codestr, tgt);
if (opcode == JUMP_FORWARD) /* JMP_ABS can go backwards */
opcode = JUMP_ABSOLUTE;
if (!ABSOLUTE_JUMP(opcode))
tgttgt -= i + 3; /* Calc relative jump addr */
if (tgttgt < 0) /* No backward relative jumps */
continue;
codestr[i] = opcode;
SETARG(codestr, i, tgttgt);
break;
case EXTENDED_ARG:
goto exitUnchanged;
/* Replace RETURN LOAD_CONST None RETURN with just RETURN */
/* Remove unreachable JUMPs after RETURN */
case RETURN_VALUE:
if (i+4 >= codelen)
continue;
if (codestr[i+4] == RETURN_VALUE &&
ISBASICBLOCK(blocks,i,5))
memset(codestr+i+1, NOP, 4);
else if (UNCONDITIONAL_JUMP(codestr[i+1]) &&
ISBASICBLOCK(blocks,i,4))
memset(codestr+i+1, NOP, 3);
break;
}
}
/* Fixup linenotab */
for (i=0, nops=0 ; i<codelen ; i += CODESIZE(codestr[i])) {
addrmap[i] = i - nops;
if (codestr[i] == NOP)
nops++;
}
cum_orig_line = 0;
last_line = 0;
for (i=0 ; i < tabsiz ; i+=2) {
cum_orig_line += lineno[i];
new_line = addrmap[cum_orig_line];
assert (new_line - last_line < 255);
lineno[i] =((unsigned char)(new_line - last_line));
last_line = new_line;
}
/* Remove NOPs and fixup jump targets */
for (i=0, h=0 ; i<codelen ; ) {
opcode = codestr[i];
switch (opcode) {
case NOP:
i++;
continue;
case JUMP_ABSOLUTE:
case CONTINUE_LOOP:
j = addrmap[GETARG(codestr, i)];
SETARG(codestr, i, j);
break;
case FOR_ITER:
case JUMP_FORWARD:
case JUMP_IF_FALSE:
case JUMP_IF_TRUE:
case SETUP_LOOP:
case SETUP_EXCEPT:
case SETUP_FINALLY:
j = addrmap[GETARG(codestr, i) + i + 3] - addrmap[i] - 3;
SETARG(codestr, i, j);
break;
}
adj = CODESIZE(opcode);
while (adj--)
codestr[h++] = codestr[i++];
}
assert(h + nops == codelen);
code = PyString_FromStringAndSize((char *)codestr, h);
PyMem_Free(addrmap);
PyMem_Free(codestr);
PyMem_Free(blocks);
return code;
exitError:
code = NULL;
exitUnchanged:
if (blocks != NULL)
PyMem_Free(blocks);
if (addrmap != NULL)
PyMem_Free(addrmap);
if (codestr != NULL)
PyMem_Free(codestr);
Py_XINCREF(code);
return code;
}
static PyObject* fcicreate(PyObject* obj, PyObject* args)
{
char *cabname, *p;
PyObject *files;
CCAB ccab;
HFCI hfci;
ERF erf;
Py_ssize_t i;
if (!PyArg_ParseTuple(args, "sO:FCICreate", &cabname, &files))
return NULL;
if (!PyList_Check(files)) {
PyErr_SetString(PyExc_TypeError, "FCICreate expects a list");
return NULL;
}
ccab.cb = INT_MAX; /* no need to split CAB into multiple media */
ccab.cbFolderThresh = 1000000; /* flush directory after this many bytes */
ccab.cbReserveCFData = 0;
ccab.cbReserveCFFolder = 0;
ccab.cbReserveCFHeader = 0;
ccab.iCab = 1;
ccab.iDisk = 1;
ccab.setID = 0;
ccab.szDisk[0] = '\0';
for (i = 0, p = cabname; *p; p = CharNext(p))
if (*p == '\\' || *p == '/')
i = p - cabname + 1;
if (i >= sizeof(ccab.szCabPath) ||
strlen(cabname+i) >= sizeof(ccab.szCab)) {
PyErr_SetString(PyExc_ValueError, "path name too long");
return 0;
}
if (i > 0) {
memcpy(ccab.szCabPath, cabname, i);
ccab.szCabPath[i] = '\0';
strcpy(ccab.szCab, cabname+i);
} else {
strcpy(ccab.szCabPath, ".\\");
strcpy(ccab.szCab, cabname);
}
hfci = FCICreate(&erf, cb_fileplaced, cb_alloc, cb_free,
cb_open, cb_read, cb_write, cb_close, cb_seek, cb_delete,
cb_gettempfile, &ccab, NULL);
if (hfci == NULL) {
PyErr_Format(PyExc_ValueError, "FCI error %d", erf.erfOper);
return NULL;
}
for (i=0; i < PyList_GET_SIZE(files); i++) {
PyObject *item = PyList_GET_ITEM(files, i);
char *filename, *cabname;
if (!PyArg_ParseTuple(item, "ss", &filename, &cabname))
goto err;
if (!FCIAddFile(hfci, filename, cabname, FALSE,
cb_getnextcabinet, cb_status, cb_getopeninfo,
tcompTYPE_MSZIP))
goto err;
}
if (!FCIFlushCabinet(hfci, FALSE, cb_getnextcabinet, cb_status))
goto err;
if (!FCIDestroy(hfci))
goto err;
Py_INCREF(Py_None);
return Py_None;
err:
PyErr_Format(PyExc_ValueError, "FCI error %d", erf.erfOper); /* XXX better error type */
FCIDestroy(hfci);
return NULL;
}
extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *cam_frame, int always_use_expand_framing)
{
/* context values */
struct wmWindowManager *wm= CTX_wm_manager(C);
struct wmWindow *win= CTX_wm_window(C);
struct Scene *startscene= CTX_data_scene(C);
struct Main* maggie1= CTX_data_main(C);
RAS_Rect area_rect;
area_rect.SetLeft(cam_frame->xmin);
area_rect.SetBottom(cam_frame->ymin);
area_rect.SetRight(cam_frame->xmax);
area_rect.SetTop(cam_frame->ymax);
int exitrequested = KX_EXIT_REQUEST_NO_REQUEST;
Main* blenderdata = maggie1;
char* startscenename = startscene->id.name+2;
char pathname[FILE_MAXDIR+FILE_MAXFILE], oldsce[FILE_MAXDIR+FILE_MAXFILE];
STR_String exitstring = "";
BlendFileData *bfd= NULL;
BLI_strncpy(pathname, blenderdata->name, sizeof(pathname));
BLI_strncpy(oldsce, G.main->name, sizeof(oldsce));
#ifdef WITH_PYTHON
resetGamePythonPath(); // need this so running a second time wont use an old blendfiles path
setGamePythonPath(G.main->name);
// Acquire Python's GIL (global interpreter lock)
// so we can safely run Python code and API calls
PyGILState_STATE gilstate = PyGILState_Ensure();
PyObject *pyGlobalDict = PyDict_New(); /* python utility storage, spans blend file loading */
#endif
bgl::InitExtensions(true);
// VBO code for derived mesh is not compatible with BGE (couldn't find why), so disable
int disableVBO = (U.gameflags & USER_DISABLE_VBO);
U.gameflags |= USER_DISABLE_VBO;
// Globals to be carried on over blender files
GlobalSettings gs;
gs.matmode= startscene->gm.matmode;
gs.glslflag= startscene->gm.flag;
do
{
View3D *v3d= CTX_wm_view3d(C);
RegionView3D *rv3d= CTX_wm_region_view3d(C);
// get some preferences
SYS_SystemHandle syshandle = SYS_GetSystem();
bool properties = (SYS_GetCommandLineInt(syshandle, "show_properties", 0) != 0);
bool usefixed = (SYS_GetCommandLineInt(syshandle, "fixedtime", 0) != 0);
bool profile = (SYS_GetCommandLineInt(syshandle, "show_profile", 0) != 0);
bool frameRate = (SYS_GetCommandLineInt(syshandle, "show_framerate", 0) != 0);
bool animation_record = (SYS_GetCommandLineInt(syshandle, "animation_record", 0) != 0);
bool displaylists = (SYS_GetCommandLineInt(syshandle, "displaylists", 0) != 0) && GPU_display_list_support();
#ifdef WITH_PYTHON
bool nodepwarnings = (SYS_GetCommandLineInt(syshandle, "ignore_deprecation_warnings", 0) != 0);
#endif
// bool novertexarrays = (SYS_GetCommandLineInt(syshandle, "novertexarrays", 0) != 0);
bool mouse_state = startscene->gm.flag & GAME_SHOW_MOUSE;
bool restrictAnimFPS = startscene->gm.flag & GAME_RESTRICT_ANIM_UPDATES;
if (animation_record) usefixed= false; /* override since you don't want to run full-speed for sim recording */
// create the canvas and rasterizer
RAS_ICanvas* canvas = new KX_BlenderCanvas(wm, win, area_rect, ar);
// default mouse state set on render panel
if (mouse_state)
canvas->SetMouseState(RAS_ICanvas::MOUSE_NORMAL);
else
canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE);
// Setup vsync
int previous_vsync = canvas->GetSwapInterval();
if (startscene->gm.vsync == VSYNC_ADAPTIVE)
canvas->SetSwapInterval(-1);
else
canvas->SetSwapInterval((startscene->gm.vsync == VSYNC_ON) ? 1 : 0);
RAS_IRasterizer* rasterizer = NULL;
//Don't use displaylists with VBOs
//If auto starts using VBOs, make sure to check for that here
if (displaylists && startscene->gm.raster_storage != RAS_STORE_VBO)
rasterizer = new RAS_ListRasterizer(canvas, true, startscene->gm.raster_storage);
else
rasterizer = new RAS_OpenGLRasterizer(canvas, startscene->gm.raster_storage);
RAS_IRasterizer::MipmapOption mipmapval = rasterizer->GetMipmapping();
// create the inputdevices
KX_BlenderKeyboardDevice* keyboarddevice = new KX_BlenderKeyboardDevice();
KX_BlenderMouseDevice* mousedevice = new KX_BlenderMouseDevice();
// create a networkdevice
NG_NetworkDeviceInterface* networkdevice = new
NG_LoopBackNetworkDeviceInterface();
//
// create a ketsji/blendersystem (only needed for timing and stuff)
KX_BlenderSystem* kxsystem = new KX_BlenderSystem();
// create the ketsjiengine
KX_KetsjiEngine* ketsjiengine = new KX_KetsjiEngine(kxsystem);
// set the devices
ketsjiengine->SetKeyboardDevice(keyboarddevice);
ketsjiengine->SetMouseDevice(mousedevice);
ketsjiengine->SetNetworkDevice(networkdevice);
ketsjiengine->SetCanvas(canvas);
ketsjiengine->SetRasterizer(rasterizer);
ketsjiengine->SetUseFixedTime(usefixed);
ketsjiengine->SetTimingDisplay(frameRate, profile, properties);
ketsjiengine->SetRestrictAnimationFPS(restrictAnimFPS);
KX_KetsjiEngine::SetExitKey(ConvertKeyCode(startscene->gm.exitkey));
//set the global settings (carried over if restart/load new files)
ketsjiengine->SetGlobalSettings(&gs);
#ifdef WITH_PYTHON
CValue::SetDeprecationWarnings(nodepwarnings);
#endif
//lock frame and camera enabled - storing global values
int tmp_lay= startscene->lay;
Object *tmp_camera = startscene->camera;
if (v3d->scenelock==0) {
startscene->lay= v3d->lay;
startscene->camera= v3d->camera;
}
// some blender stuff
float camzoom;
int draw_letterbox = 0;
if (rv3d->persp==RV3D_CAMOB) {
if (startscene->gm.framing.type == SCE_GAMEFRAMING_BARS) { /* Letterbox */
camzoom = 1.0f;
draw_letterbox = 1;
}
else {
camzoom = 1.0f / BKE_screen_view3d_zoom_to_fac(rv3d->camzoom);
}
}
else {
camzoom = 2.0;
}
ketsjiengine->SetDrawType(v3d->drawtype);
ketsjiengine->SetCameraZoom(camzoom);
// if we got an exitcode 3 (KX_EXIT_REQUEST_START_OTHER_GAME) load a different file
if (exitrequested == KX_EXIT_REQUEST_START_OTHER_GAME || exitrequested == KX_EXIT_REQUEST_RESTART_GAME)
{
exitrequested = KX_EXIT_REQUEST_NO_REQUEST;
if (bfd) BLO_blendfiledata_free(bfd);
char basedpath[FILE_MAX];
// base the actuator filename with respect
// to the original file working directory
if (exitstring != "")
BLI_strncpy(basedpath, exitstring.ReadPtr(), sizeof(basedpath));
// load relative to the last loaded file, this used to be relative
// to the first file but that makes no sense, relative paths in
// blend files should be relative to that file, not some other file
// that happened to be loaded first
BLI_path_abs(basedpath, pathname);
bfd = load_game_data(basedpath);
// if it wasn't loaded, try it forced relative
if (!bfd)
{
// just add "//" in front of it
char temppath[FILE_MAX] = "//";
BLI_strncpy(temppath + 2, basedpath, FILE_MAX - 2);
BLI_path_abs(temppath, pathname);
bfd = load_game_data(temppath);
}
// if we got a loaded blendfile, proceed
if (bfd)
{
blenderdata = bfd->main;
startscenename = bfd->curscene->id.name + 2;
if (blenderdata) {
BLI_strncpy(G.main->name, blenderdata->name, sizeof(G.main->name));
BLI_strncpy(pathname, blenderdata->name, sizeof(pathname));
#ifdef WITH_PYTHON
setGamePythonPath(G.main->name);
#endif
}
}
// else forget it, we can't find it
else
{
exitrequested = KX_EXIT_REQUEST_QUIT_GAME;
}
}
Scene *scene= bfd ? bfd->curscene : (Scene *)BLI_findstring(&blenderdata->scene, startscenename, offsetof(ID, name) + 2);
if (scene)
{
int startFrame = scene->r.cfra;
ketsjiengine->SetAnimRecordMode(animation_record, startFrame);
// Quad buffered needs a special window.
if (scene->gm.stereoflag == STEREO_ENABLED) {
if (scene->gm.stereomode != RAS_IRasterizer::RAS_STEREO_QUADBUFFERED)
rasterizer->SetStereoMode((RAS_IRasterizer::StereoMode) scene->gm.stereomode);
rasterizer->SetEyeSeparation(scene->gm.eyeseparation);
}
rasterizer->SetBackColor(scene->gm.framing.col[0], scene->gm.framing.col[1], scene->gm.framing.col[2], 0.0f);
}
if (exitrequested != KX_EXIT_REQUEST_QUIT_GAME)
{
if (rv3d->persp != RV3D_CAMOB)
{
ketsjiengine->EnableCameraOverride(startscenename);
ketsjiengine->SetCameraOverrideUseOrtho((rv3d->persp == RV3D_ORTHO));
ketsjiengine->SetCameraOverrideProjectionMatrix(MT_CmMatrix4x4(rv3d->winmat));
ketsjiengine->SetCameraOverrideViewMatrix(MT_CmMatrix4x4(rv3d->viewmat));
if (rv3d->persp == RV3D_ORTHO)
{
ketsjiengine->SetCameraOverrideClipping(v3d->near, v3d->far);
}
else
{
ketsjiengine->SetCameraOverrideClipping(v3d->near, v3d->far);
}
ketsjiengine->SetCameraOverrideLens(v3d->lens);
}
// create a scene converter, create and convert the startingscene
KX_ISceneConverter* sceneconverter = new KX_BlenderSceneConverter(blenderdata, ketsjiengine);
ketsjiengine->SetSceneConverter(sceneconverter);
sceneconverter->addInitFromFrame=false;
if (always_use_expand_framing)
sceneconverter->SetAlwaysUseExpandFraming(true);
bool usemat = false, useglslmat = false;
if (GLEW_ARB_multitexture && GLEW_VERSION_1_1)
usemat = true;
if (GPU_glsl_support())
useglslmat = true;
else if (gs.matmode == GAME_MAT_GLSL)
usemat = false;
if (usemat)
sceneconverter->SetMaterials(true);
if (useglslmat && (gs.matmode == GAME_MAT_GLSL))
sceneconverter->SetGLSLMaterials(true);
if (scene->gm.flag & GAME_NO_MATERIAL_CACHING)
sceneconverter->SetCacheMaterials(false);
KX_Scene* startscene = new KX_Scene(keyboarddevice,
mousedevice,
networkdevice,
startscenename,
scene,
canvas);
#ifdef WITH_PYTHON
// some python things
PyObject *gameLogic, *gameLogic_keys;
setupGamePython(ketsjiengine, startscene, blenderdata, pyGlobalDict, &gameLogic, &gameLogic_keys, 0, NULL);
#endif // WITH_PYTHON
//initialize Dome Settings
if (scene->gm.stereoflag == STEREO_DOME)
ketsjiengine->InitDome(scene->gm.dome.res, scene->gm.dome.mode, scene->gm.dome.angle, scene->gm.dome.resbuf, scene->gm.dome.tilt, scene->gm.dome.warptext);
// initialize 3D Audio Settings
AUD_I3DDevice* dev = AUD_get3DDevice();
if (dev)
{
dev->setSpeedOfSound(scene->audio.speed_of_sound);
dev->setDopplerFactor(scene->audio.doppler_factor);
dev->setDistanceModel(AUD_DistanceModel(scene->audio.distance_model));
}
// from see blender.c:
// FIXME: this version patching should really be part of the file-reading code,
// but we still get too many unrelated data-corruption crashes otherwise...
if (blenderdata->versionfile < 250)
do_versions_ipos_to_animato(blenderdata);
if (sceneconverter)
{
// convert and add scene
sceneconverter->ConvertScene(
startscene,
rasterizer,
canvas);
ketsjiengine->AddScene(startscene);
// init the rasterizer
rasterizer->Init();
// start the engine
ketsjiengine->StartEngine(true);
// Set the animation playback rate for ipo's and actions
// the framerate below should patch with FPS macro defined in blendef.h
// Could be in StartEngine set the framerate, we need the scene to do this
ketsjiengine->SetAnimFrameRate(FPS);
#ifdef WITH_PYTHON
char *python_main = NULL;
pynextframestate.state = NULL;
pynextframestate.func = NULL;
python_main = KX_GetPythonMain(scene);
// the mainloop
printf("\nBlender Game Engine Started\n");
if (python_main) {
char *python_code = KX_GetPythonCode(blenderdata, python_main);
if (python_code) {
ketsjinextframestate.ketsjiengine = ketsjiengine;
ketsjinextframestate.C = C;
ketsjinextframestate.win = win;
ketsjinextframestate.scene = scene;
ketsjinextframestate.ar = ar;
ketsjinextframestate.keyboarddevice = keyboarddevice;
ketsjinextframestate.mousedevice = mousedevice;
ketsjinextframestate.draw_letterbox = draw_letterbox;
pynextframestate.state = &ketsjinextframestate;
pynextframestate.func = &BL_KetsjiPyNextFrame;
printf("Yielding control to Python script '%s'...\n", python_main);
PyRun_SimpleString(python_code);
printf("Exit Python script '%s'\n", python_main);
MEM_freeN(python_code);
}
}
else
#endif /* WITH_PYTHON */
{
while (!exitrequested)
{
exitrequested = BL_KetsjiNextFrame(ketsjiengine, C, win, scene, ar, keyboarddevice, mousedevice, draw_letterbox);
}
}
printf("Blender Game Engine Finished\n");
exitstring = ketsjiengine->GetExitString();
#ifdef WITH_PYTHON
if (python_main) MEM_freeN(python_main);
#endif /* WITH_PYTHON */
gs = *(ketsjiengine->GetGlobalSettings());
// when exiting the mainloop
#ifdef WITH_PYTHON
// Clears the dictionary by hand:
// This prevents, extra references to global variables
// inside the GameLogic dictionary when the python interpreter is finalized.
// which allows the scene to safely delete them :)
// see: (space.c)->start_game
//PyDict_Clear(PyModule_GetDict(gameLogic));
// Keep original items, means python plugins will autocomplete members
PyObject *gameLogic_keys_new = PyDict_Keys(PyModule_GetDict(gameLogic));
const Py_ssize_t numitems= PyList_GET_SIZE(gameLogic_keys_new);
Py_ssize_t listIndex;
for (listIndex=0; listIndex < numitems; listIndex++) {
PyObject *item = PyList_GET_ITEM(gameLogic_keys_new, listIndex);
if (!PySequence_Contains(gameLogic_keys, item)) {
PyDict_DelItem( PyModule_GetDict(gameLogic), item);
}
}
Py_DECREF(gameLogic_keys_new);
gameLogic_keys_new = NULL;
#endif
ketsjiengine->StopEngine();
#ifdef WITH_PYTHON
exitGamePythonScripting();
#endif
networkdevice->Disconnect();
}
if (sceneconverter)
{
delete sceneconverter;
sceneconverter = NULL;
}
#ifdef WITH_PYTHON
Py_DECREF(gameLogic_keys);
gameLogic_keys = NULL;
#endif
}
//lock frame and camera enabled - restoring global values
if (v3d->scenelock==0) {
startscene->lay= tmp_lay;
startscene->camera= tmp_camera;
}
if (exitrequested != KX_EXIT_REQUEST_OUTSIDE)
{
// set the cursor back to normal
canvas->SetMouseState(RAS_ICanvas::MOUSE_NORMAL);
// set mipmap setting back to its original value
rasterizer->SetMipmapping(mipmapval);
}
// clean up some stuff
if (ketsjiengine)
{
delete ketsjiengine;
ketsjiengine = NULL;
}
if (kxsystem)
{
delete kxsystem;
kxsystem = NULL;
}
if (networkdevice)
{
delete networkdevice;
networkdevice = NULL;
}
if (keyboarddevice)
{
delete keyboarddevice;
keyboarddevice = NULL;
}
if (mousedevice)
{
delete mousedevice;
mousedevice = NULL;
}
if (rasterizer)
{
delete rasterizer;
rasterizer = NULL;
}
if (canvas)
{
canvas->SetSwapInterval(previous_vsync); // Set the swap interval back
delete canvas;
canvas = NULL;
}
// stop all remaining playing sounds
AUD_getDevice()->stopAll();
} while (exitrequested == KX_EXIT_REQUEST_RESTART_GAME || exitrequested == KX_EXIT_REQUEST_START_OTHER_GAME);
if (!disableVBO)
U.gameflags &= ~USER_DISABLE_VBO;
if (bfd) BLO_blendfiledata_free(bfd);
BLI_strncpy(G.main->name, oldsce, sizeof(G.main->name));
#ifdef WITH_PYTHON
Py_DECREF(pyGlobalDict);
// Release Python's GIL
PyGILState_Release(gilstate);
#endif
}
/**
* evalDistribution function evaluate a model function with input vector
* @param args: input q as vector or [qx, qy] where qx, qy are vectors
*
*/
static PyObject * evalDistribution(CFlexCylEllipXModel *self, PyObject *args){
PyObject *qx, *qy;
PyArrayObject * pars;
int npars ,mpars;
// Get parameters
// Reader parameter dictionary
self->model->scale = PyFloat_AsDouble( PyDict_GetItemString(self->params, "scale") );
self->model->sldCyl = PyFloat_AsDouble( PyDict_GetItemString(self->params, "sldCyl") );
self->model->axis_ratio = PyFloat_AsDouble( PyDict_GetItemString(self->params, "axis_ratio") );
self->model->length = PyFloat_AsDouble( PyDict_GetItemString(self->params, "length") );
self->model->radius = PyFloat_AsDouble( PyDict_GetItemString(self->params, "radius") );
self->model->background = PyFloat_AsDouble( PyDict_GetItemString(self->params, "background") );
self->model->sldSolv = PyFloat_AsDouble( PyDict_GetItemString(self->params, "sldSolv") );
self->model->kuhn_length = PyFloat_AsDouble( PyDict_GetItemString(self->params, "kuhn_length") );
// Read in dispersion parameters
PyObject* disp_dict;
DispersionVisitor* visitor = new DispersionVisitor();
disp_dict = PyDict_GetItemString(self->dispersion, "length");
self->model->length.dispersion->accept_as_destination(visitor, self->model->length.dispersion, disp_dict);
disp_dict = PyDict_GetItemString(self->dispersion, "kuhn_length");
self->model->kuhn_length.dispersion->accept_as_destination(visitor, self->model->kuhn_length.dispersion, disp_dict);
disp_dict = PyDict_GetItemString(self->dispersion, "radius");
self->model->radius.dispersion->accept_as_destination(visitor, self->model->radius.dispersion, disp_dict);
disp_dict = PyDict_GetItemString(self->dispersion, "axis_ratio");
self->model->axis_ratio.dispersion->accept_as_destination(visitor, self->model->axis_ratio.dispersion, disp_dict);
// Get input and determine whether we have to supply a 1D or 2D return value.
if ( !PyArg_ParseTuple(args,"O",&pars) ) {
PyErr_SetString(CFlexCylEllipXModelError,
"CFlexCylEllipXModel.evalDistribution expects a q value.");
return NULL;
}
// Check params
if(PyArray_Check(pars)==1) {
// Length of list should 1 or 2
npars = pars->nd;
if(npars==1) {
// input is a numpy array
if (PyArray_Check(pars)) {
return evaluateOneDim(self->model, (PyArrayObject*)pars);
}
}else{
PyErr_SetString(CFlexCylEllipXModelError,
"CFlexCylEllipXModel.evalDistribution expect numpy array of one dimension.");
return NULL;
}
}else if( PyList_Check(pars)==1) {
// Length of list should be 2 for I(qx,qy)
mpars = PyList_GET_SIZE(pars);
if(mpars!=2) {
PyErr_SetString(CFlexCylEllipXModelError,
"CFlexCylEllipXModel.evalDistribution expects a list of dimension 2.");
return NULL;
}
qx = PyList_GET_ITEM(pars,0);
qy = PyList_GET_ITEM(pars,1);
if (PyArray_Check(qx) && PyArray_Check(qy)) {
return evaluateTwoDimXY(self->model, (PyArrayObject*)qx,
(PyArrayObject*)qy);
}else{
PyErr_SetString(CFlexCylEllipXModelError,
"CFlexCylEllipXModel.evalDistribution expect 2 numpy arrays in list.");
return NULL;
}
}
PyErr_SetString(CFlexCylEllipXModelError,
"CFlexCylEllipXModel.evalDistribution couln't be run.");
return NULL;
}
/*
def __adapt__(self, obj):
"""Adapt an object to the reciever
"""
if self.providedBy(obj):
return obj
for hook in adapter_hooks:
adapter = hook(self, obj)
if adapter is not None:
return adapter
*/
static PyObject *
__adapt__(PyObject *self, PyObject *obj)
{
PyObject *decl, *args, *adapter;
int implements, i, l;
decl = providedBy(NULL, obj);
if (decl == NULL)
return NULL;
if (PyObject_TypeCheck(decl, &SpecType))
{
PyObject *implied;
implied = inst_attr(decl, str_implied);
if (implied == NULL)
{
Py_DECREF(decl);
return NULL;
}
implements = PyDict_GetItem(implied, self) != NULL;
Py_DECREF(decl);
}
else
{
/* decl is probably a security proxy. We have to go the long way
around.
*/
PyObject *r;
r = PyObject_CallFunctionObjArgs(decl, self, NULL);
Py_DECREF(decl);
if (r == NULL)
return NULL;
implements = PyObject_IsTrue(r);
Py_DECREF(r);
}
if (implements)
{
Py_INCREF(obj);
return obj;
}
l = PyList_GET_SIZE(adapter_hooks);
args = PyTuple_New(2);
if (args == NULL)
return NULL;
Py_INCREF(self);
PyTuple_SET_ITEM(args, 0, self);
Py_INCREF(obj);
PyTuple_SET_ITEM(args, 1, obj);
for (i = 0; i < l; i++)
{
adapter = PyObject_CallObject(PyList_GET_ITEM(adapter_hooks, i), args);
if (adapter == NULL || adapter != Py_None)
{
Py_DECREF(args);
return adapter;
}
Py_DECREF(adapter);
}
Py_DECREF(args);
Py_INCREF(Py_None);
return Py_None;
}
// This MList function creates a list of the M values giving the probabilities of mutations
static PyObject *MList(PyObject *self, PyObject *args) {
// Calling variables are (in order): uts, only_need, n_aa, length, grs, mlist, residue_to_compute
PyObject *uts, *only_need, *grs, *r_grs_tuple, *gr_diag, *p, *p_inv, *mlist;
long n_aa, length, n_aa2, n_uts, residue_to_compute, i_ut, y, index, irowcolumn, only_need_index, only_need_i, only_need_i_n_aa;
double *arr_mlist, *cp_inv, *cp, *cgr_diag, *cp_inv_exp;
complex double *complex_cp_inv, *complex_cp, *complex_cgr_diag, *complex_cp_inv_exp, *complex_naa2_list, *complex_naa_list;
double ut, exp_ut;
complex double complex_exp_ut;
int array_type;
#ifdef USE_ACCELERATE_CBLAS
complex double complex_one = 1, complex_zero = 0;
long index2;
#else
complex double complex_mxy;
double mxy;
long x, yindex;
#endif
// Parse the arguments.
if (! PyArg_ParseTuple( args, "O!O!llO!O!l", &PyList_Type, &uts, &PyList_Type, &only_need, &n_aa, &length, &PyList_Type, &grs, &PyArray_Type, &mlist, &residue_to_compute)) {
PyErr_SetString(PyExc_TypeError, "Invalid calling arguments to MList.");
return NULL;
}
// Error checking on arguments
if (length < 1) { // length of the protein
PyErr_SetString(PyExc_ValueError, "length is less than one.");
return NULL;
}
if (n_aa < 1) { // number of amino acids. Normally will be 20.
PyErr_SetString(PyExc_ValueError, "n_aa is less than one.");
return NULL;
}
if (PyList_GET_SIZE(grs) != length) { // make sure grs is of the same size as length
// PyErr_SetString(PyExc_ValueError, "grs is not of the same size as length.");
char errstring[200];
sprintf(errstring, "grs is not of the same size as length: %ld, %ld", PyList_GET_SIZE(grs), length);
PyErr_SetString(PyExc_ValueError, errstring);
return NULL;
}
n_uts = PyList_GET_SIZE(uts); // number of entries in uts
if (n_uts < 1) { // make sure there are entries in uts
PyErr_SetString(PyExc_ValueError, "uts has no entries.");
return NULL;
}
if (PyList_GET_SIZE(only_need) != n_uts * length) { // make sure only_need is of correct size
PyErr_SetString(PyExc_ValueError, "only_need is of wrong size.");
return NULL;
}
if (! ((residue_to_compute >= 0) && (residue_to_compute < length))) {
char errstring[200];
sprintf(errstring, "Invalid value for residue_to_compute: %ld, %ld", residue_to_compute, length);
PyErr_SetString(PyExc_ValueError, errstring);
return NULL;
}
n_aa2 = n_aa * n_aa; // square of the number of amino acids
// The results will be returned in a numpy ndarray 'float_' (C type double) array called mlist.
// This array will be of size length * n_uts * n_aa2.
arr_mlist = (double *) PyArray_DATA(mlist); // this is the data array of mlist
long const sizeof_cp_inv = n_aa2 * sizeof(double);
long const complex_sizeof_cp_inv = n_aa2 * sizeof(complex double);
// Now begin filling arr_mlist with the appropriate values
index = 0;
only_need_index = residue_to_compute * n_uts;
r_grs_tuple = PyList_GET_ITEM(grs, residue_to_compute);
// gr_diag, p, and p_inv are the eigenvalues, left, and right diagonalizing matrices of gr
gr_diag = PyTuple_GET_ITEM(r_grs_tuple, 0);
p = PyTuple_GET_ITEM(r_grs_tuple, 1);
p_inv = PyTuple_GET_ITEM(r_grs_tuple, 2);
// determine if these arrays are complex double or real doubles
array_type = PyArray_TYPE(gr_diag);
if (array_type == NPY_DOUBLE) { // array is of doubles, real not complex
cp_inv_exp = (double *) malloc(sizeof_cp_inv); // allocate memory
// Note that these next assignments assume that the arrays are C-style contiguous
cp = PyArray_DATA(p);
cp_inv = PyArray_DATA(p_inv);
cgr_diag = PyArray_DATA(gr_diag);
for (i_ut = 0; i_ut < n_uts; i_ut++) { // loop over ut values
only_need_i = PyInt_AS_LONG(PyList_GET_ITEM(only_need, only_need_index)); // value of only_need
only_need_index++;
if (only_need_i == -1) { // we don't need to do anything for these entries in mlist
index += n_aa2;
} else { // we need to compute at least some entries in mlist
ut = PyFloat_AS_DOUBLE(PyList_GET_ITEM(uts, i_ut)); // ut value
for (irowcolumn = 0; irowcolumn < n_aa; irowcolumn++) {
exp_ut = exp(ut * cgr_diag[irowcolumn]);
for (y = irowcolumn * n_aa; y < (irowcolumn + 1) * n_aa; y++) {
cp_inv_exp[y] = cp_inv[y] * exp_ut;
}
}
if (only_need_i == -2) { // we need to compute all of these entries in mlist
#ifdef USE_ACCELERATE_CBLAS
// multiply the matrices using cblas_dgemm, and fill mlist with the results
cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n_aa, n_aa, n_aa, (double) 1.0, cp, n_aa, cp_inv_exp, n_aa, (double) 0.0, &arr_mlist[index], n_aa);
for (index2 = index; index2 < index + n_aa2; index2++) {
arr_mlist[index2] = fabs(arr_mlist[index2]);
}
index += n_aa2;
#else
// multiply the matrices in pure C code, and fill mlist with the results
for (x = 0; x < n_aa2; x += n_aa) {
for (y = 0; y < n_aa; y++) {
mxy = 0.0;
yindex = y;
for (irowcolumn = x; irowcolumn < x + n_aa; irowcolumn++) {
mxy += cp[irowcolumn] * cp_inv_exp[yindex];
yindex += n_aa;
}
arr_mlist[index++] = fabs(mxy);
}
}
#endif
} else { // we need to compute entries in mlist only for x = only_need_i
only_need_i_n_aa = only_need_i * n_aa;
index += only_need_i_n_aa;
#ifdef USE_ACCELERATE_CBLAS
// do the matrix vector multiplication using cblas, and put results in mlist
cblas_dgemv(CblasRowMajor, CblasTrans, n_aa, n_aa, (double) 1.0, cp_inv_exp, n_aa, &cp[only_need_i_n_aa], 1, (double) 0.0, &arr_mlist[index], 1);
for (index2 = index; index2 < index + n_aa2 - only_need_i_n_aa; index2++) {
arr_mlist[index2] = fabs(arr_mlist[index2]);
}
index += n_aa2 - only_need_i_n_aa;
#else
// do the matrix vector multiplication in pure C code, and put results in mlist
for (y = 0; y < n_aa; y++) {
mxy = 0.0;
yindex = y;
for (irowcolumn = only_need_i_n_aa; irowcolumn < only_need_i_n_aa + n_aa; irowcolumn++) {
mxy += cp[irowcolumn] * cp_inv_exp[yindex];
yindex += n_aa;
}
arr_mlist[index++] = fabs(mxy);
}
index += n_aa2 - only_need_i_n_aa - n_aa;
#endif
}
}
}
free(cp_inv_exp);
} else if (array_type == NPY_CDOUBLE) { // array is complex doubles
complex_cp_inv_exp = (complex double *) malloc(complex_sizeof_cp_inv); // allocate memory
complex_naa2_list = (complex double *) malloc(n_aa2 * sizeof(complex double)); // allocate memory
complex_naa_list = (complex double *) malloc(n_aa * sizeof(complex double)); // allocate memory
// Note that these next assignments assume that the arrays are C-style contiguous
complex_cp = PyArray_DATA(p);
complex_cp_inv = PyArray_DATA(p_inv);
complex_cgr_diag = PyArray_DATA(gr_diag);
for (i_ut = 0; i_ut < n_uts; i_ut++) { // loop over ut values
only_need_i = PyInt_AS_LONG(PyList_GET_ITEM(only_need, only_need_index)); // value of only_need
only_need_index++;
if (only_need_i == -1) { // we don't need to do anything for these entries in mlist
index += n_aa2;
} else { // we need to compute at least some entries in mlist
ut = PyFloat_AS_DOUBLE(PyList_GET_ITEM(uts, i_ut)); // ut value
for (irowcolumn = 0; irowcolumn < n_aa; irowcolumn++) {
complex_exp_ut = cexp(ut * complex_cgr_diag[irowcolumn]);
for (y = irowcolumn * n_aa; y < (irowcolumn + 1) * n_aa; y++) {
complex_cp_inv_exp[y] = complex_cp_inv[y] * complex_exp_ut;
}
}
if (only_need_i == -2) { // we need to compute all of these entries in mlist
#ifdef USE_ACCELERATE_CBLAS
// multiply the matrices using cblas_zgemm, and fill mlist with the results
cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n_aa, n_aa, n_aa, &complex_one, complex_cp, n_aa, complex_cp_inv_exp, n_aa, &complex_zero, complex_naa2_list, n_aa);
for (index2 = 0; index2 < n_aa2; index2++) {
arr_mlist[index + index2] = cabs(complex_naa2_list[index2]);
}
index += n_aa2;
#else
// multiply the matrices in pure C code, and fill mlist with the results
for (x = 0; x < n_aa2; x += n_aa) {
for (y = 0; y < n_aa; y++) {
complex_mxy = (complex double) 0.0;
yindex = y;
for (irowcolumn = x; irowcolumn < x + n_aa; irowcolumn++) {
complex_mxy += complex_cp[irowcolumn] * complex_cp_inv_exp[yindex];
yindex += n_aa;
}
arr_mlist[index++] = cabs(complex_mxy);
}
}
#endif
} else { // we need to compute entries in mlist only for x = only_need_i
only_need_i_n_aa = only_need_i * n_aa;
index += only_need_i_n_aa;
#ifdef USE_ACCELERATE_CBLAS
// do the matrix vector multiplication using cblas, and put results in mlist
cblas_zgemv(CblasRowMajor, CblasTrans, n_aa, n_aa, &complex_one, complex_cp_inv_exp, n_aa, &complex_cp[only_need_i_n_aa], 1, &complex_zero, complex_naa_list, 1);
for (index2 = 0; index2 < n_aa; index2++) {
arr_mlist[index + index2] = cabs(complex_naa_list[index2]);
}
index += n_aa2 - only_need_i_n_aa;
#else
// do the matrix vector multiplication in pure C code, and put results in mlist
for (y = 0; y < n_aa; y++) {
complex_mxy = (complex double) 0.0;
yindex = y;
for (irowcolumn = only_need_i_n_aa; irowcolumn < only_need_i_n_aa + n_aa; irowcolumn++) {
complex_mxy += complex_cp[irowcolumn] * complex_cp_inv_exp[yindex];
yindex += n_aa;
}
arr_mlist[index++] = cabs(complex_mxy);
}
index += n_aa2 - only_need_i_n_aa - n_aa;
#endif
}
}
}
free(complex_cp_inv_exp);
free(complex_naa2_list);
free(complex_naa_list);
} else { // array is of neither real nor complex doubles
PyErr_SetString(PyExc_ValueError, "gr entries are neither double nor complex doubles.");
return NULL;
}
return PyInt_FromLong((long) 1);
}
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":20
* def __init__(self, path):
* self.path = path
* self._collections = None # <<<<<<<<<<<<<<
*
* def _read_collections(self):
*/
Py_INCREF(Py_None);
Py_DECREF(((struct __pyx_obj_4mill_9workspace_Workspace *)__pyx_v_self)->_collections);
((struct __pyx_obj_4mill_9workspace_Workspace *)__pyx_v_self)->_collections = Py_None;
__pyx_r = 0;
Py_DECREF(__pyx_v_self);
Py_DECREF(__pyx_v_path);
return __pyx_r;
}
static PyObject *__pyx_n_range;
static PyObject *__pyx_builtin_range;
static PyObject *__pyx_pf_4mill_9workspace_9Workspace__read_collections(PyObject *__pyx_v_self, PyObject *unused); /*proto*/
static PyObject *__pyx_pf_4mill_9workspace_9Workspace__read_collections(PyObject *__pyx_v_self, PyObject *unused) {
void *__pyx_v_cogr_ds;
void *__pyx_v_cogr_layer;
void *__pyx_v_cogr_layerdefn;
PyObject *__pyx_v_collections;
PyObject *__pyx_v_n;
PyObject *__pyx_v_i;
PyObject *__pyx_v_layer_name;
PyObject *__pyx_v_collection;
PyObject *__pyx_r;
PyObject *__pyx_1 = 0;
char *__pyx_2;
Py_ssize_t __pyx_3;
PyObject *__pyx_4 = 0;
int __pyx_5;
PyObject *__pyx_6 = 0;
PyObject *__pyx_7 = 0;
Py_INCREF(__pyx_v_self);
__pyx_v_collections = Py_None; Py_INCREF(Py_None);
__pyx_v_n = Py_None; Py_INCREF(Py_None);
__pyx_v_i = Py_None; Py_INCREF(Py_None);
__pyx_v_layer_name = Py_None; Py_INCREF(Py_None);
__pyx_v_collection = Py_None; Py_INCREF(Py_None);
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":26
* cdef void * cogr_layer
* cdef void * cogr_layerdefn
* collections = {} # <<<<<<<<<<<<<<
*
* # start session
*/
__pyx_1 = PyDict_New(); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 26; goto __pyx_L1;}
Py_DECREF(__pyx_v_collections);
__pyx_v_collections = __pyx_1;
__pyx_1 = 0;
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":29
*
* # start session
* cogr_ds = ograpi.OGROpen(self.path, 0, NULL) # <<<<<<<<<<<<<<
*
* n = ograpi.OGR_DS_GetLayerCount(cogr_ds)
*/
__pyx_2 = PyString_AsString(((struct __pyx_obj_4mill_9workspace_Workspace *)__pyx_v_self)->path); if (unlikely((!__pyx_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 29; goto __pyx_L1;}
__pyx_v_cogr_ds = OGROpen(__pyx_2,0,NULL);
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":31
* cogr_ds = ograpi.OGROpen(self.path, 0, NULL)
*
* n = ograpi.OGR_DS_GetLayerCount(cogr_ds) # <<<<<<<<<<<<<<
* for i in range(n):
* cogr_layer = ograpi.OGR_DS_GetLayer(cogr_ds, i)
*/
__pyx_1 = PyInt_FromLong(OGR_DS_GetLayerCount(__pyx_v_cogr_ds)); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 31; goto __pyx_L1;}
Py_DECREF(__pyx_v_n);
__pyx_v_n = __pyx_1;
__pyx_1 = 0;
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":32
*
* n = ograpi.OGR_DS_GetLayerCount(cogr_ds)
* for i in range(n): # <<<<<<<<<<<<<<
* cogr_layer = ograpi.OGR_DS_GetLayer(cogr_ds, i)
* cogr_layerdefn = ograpi.OGR_L_GetLayerDefn(cogr_layer)
*/
__pyx_1 = PyTuple_New(1); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; goto __pyx_L1;}
Py_INCREF(__pyx_v_n);
PyTuple_SET_ITEM(__pyx_1, 0, __pyx_v_n);
__pyx_4 = PyObject_CallObject(__pyx_builtin_range, __pyx_1); if (unlikely(!__pyx_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; goto __pyx_L1;}
Py_DECREF(__pyx_1); __pyx_1 = 0;
if (PyList_CheckExact(__pyx_4)) { __pyx_3 = 0; __pyx_1 = __pyx_4; Py_INCREF(__pyx_1); }
else { __pyx_1 = PyObject_GetIter(__pyx_4); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; goto __pyx_L1;} }
Py_DECREF(__pyx_4); __pyx_4 = 0;
for (;;) {
if (PyList_CheckExact(__pyx_1)) { if (__pyx_3 >= PyList_GET_SIZE(__pyx_1)) break; __pyx_4 = PyList_GET_ITEM(__pyx_1, __pyx_3++); Py_INCREF(__pyx_4); }
else {
__pyx_4 = PyIter_Next(__pyx_1);
if (!__pyx_4) {
break;
}
}
Py_DECREF(__pyx_v_i);
__pyx_v_i = __pyx_4;
__pyx_4 = 0;
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":33
* n = ograpi.OGR_DS_GetLayerCount(cogr_ds)
* for i in range(n):
* cogr_layer = ograpi.OGR_DS_GetLayer(cogr_ds, i) # <<<<<<<<<<<<<<
* cogr_layerdefn = ograpi.OGR_L_GetLayerDefn(cogr_layer)
* layer_name = ograpi.OGR_FD_GetName(cogr_layerdefn)
*/
__pyx_5 = PyInt_AsLong(__pyx_v_i); if (unlikely((__pyx_5 == -1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 33; goto __pyx_L1;}
__pyx_v_cogr_layer = OGR_DS_GetLayer(__pyx_v_cogr_ds,__pyx_5);
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":34
* for i in range(n):
* cogr_layer = ograpi.OGR_DS_GetLayer(cogr_ds, i)
* cogr_layerdefn = ograpi.OGR_L_GetLayerDefn(cogr_layer) # <<<<<<<<<<<<<<
* layer_name = ograpi.OGR_FD_GetName(cogr_layerdefn)
* collection = Collection(layer_name, self)
*/
__pyx_v_cogr_layerdefn = OGR_L_GetLayerDefn(__pyx_v_cogr_layer);
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":35
* cogr_layer = ograpi.OGR_DS_GetLayer(cogr_ds, i)
* cogr_layerdefn = ograpi.OGR_L_GetLayerDefn(cogr_layer)
* layer_name = ograpi.OGR_FD_GetName(cogr_layerdefn) # <<<<<<<<<<<<<<
* collection = Collection(layer_name, self)
* collections[layer_name] = collection
*/
__pyx_4 = PyString_FromString(OGR_FD_GetName(__pyx_v_cogr_layerdefn)); if (unlikely(!__pyx_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 35; goto __pyx_L1;}
Py_DECREF(__pyx_v_layer_name);
__pyx_v_layer_name = __pyx_4;
__pyx_4 = 0;
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":36
* cogr_layerdefn = ograpi.OGR_L_GetLayerDefn(cogr_layer)
* layer_name = ograpi.OGR_FD_GetName(cogr_layerdefn)
* collection = Collection(layer_name, self) # <<<<<<<<<<<<<<
* collections[layer_name] = collection
*
*/
__pyx_4 = __Pyx_GetName(__pyx_m, __pyx_n_Collection); if (unlikely(!__pyx_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 36; goto __pyx_L1;}
__pyx_6 = PyTuple_New(2); if (unlikely(!__pyx_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 36; goto __pyx_L1;}
Py_INCREF(__pyx_v_layer_name);
PyTuple_SET_ITEM(__pyx_6, 0, __pyx_v_layer_name);
Py_INCREF(__pyx_v_self);
PyTuple_SET_ITEM(__pyx_6, 1, __pyx_v_self);
__pyx_7 = PyObject_CallObject(__pyx_4, __pyx_6); if (unlikely(!__pyx_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 36; goto __pyx_L1;}
Py_DECREF(__pyx_4); __pyx_4 = 0;
Py_DECREF(__pyx_6); __pyx_6 = 0;
Py_DECREF(__pyx_v_collection);
__pyx_v_collection = __pyx_7;
__pyx_7 = 0;
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":37
* layer_name = ograpi.OGR_FD_GetName(cogr_layerdefn)
* collection = Collection(layer_name, self)
* collections[layer_name] = collection # <<<<<<<<<<<<<<
*
* # end session
*/
if (PyObject_SetItem(__pyx_v_collections, __pyx_v_layer_name, __pyx_v_collection) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; goto __pyx_L1;}
}
Py_DECREF(__pyx_1); __pyx_1 = 0;
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":40
*
* # end session
* ograpi.OGR_DS_Destroy(cogr_ds) # <<<<<<<<<<<<<<
*
* return collections
*/
OGR_DS_Destroy(__pyx_v_cogr_ds);
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":42
* ograpi.OGR_DS_Destroy(cogr_ds)
*
* return collections # <<<<<<<<<<<<<<
*
* property collections:
*/
Py_INCREF(__pyx_v_collections);
__pyx_r = __pyx_v_collections;
goto __pyx_L0;
__pyx_r = Py_None; Py_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1:;
Py_XDECREF(__pyx_1);
Py_XDECREF(__pyx_4);
Py_XDECREF(__pyx_6);
Py_XDECREF(__pyx_7);
__Pyx_AddTraceback("mill.workspace.Workspace._read_collections");
__pyx_r = NULL;
__pyx_L0:;
Py_DECREF(__pyx_v_collections);
Py_DECREF(__pyx_v_n);
Py_DECREF(__pyx_v_i);
Py_DECREF(__pyx_v_layer_name);
Py_DECREF(__pyx_v_collection);
Py_DECREF(__pyx_v_self);
return __pyx_r;
}
/* Replace LOAD_CONST c1. LOAD_CONST c2 BINOP
with LOAD_CONST binop(c1,c2)
The consts table must still be in list form so that the
new constant can be appended.
Called with codestr pointing to the first LOAD_CONST.
Abandons the transformation if the folding fails (i.e. 1+'a').
If the new constant is a sequence, only folds when the size
is below a threshold value. That keeps pyc files from
becoming large in the presence of code like: (None,)*1000.
*/
static int
fold_binops_on_constants(unsigned char *codestr, PyObject *consts)
{
PyObject *newconst, *v, *w;
Py_ssize_t len_consts, size;
int opcode;
/* Pre-conditions */
assert(PyList_CheckExact(consts));
assert(codestr[0] == LOAD_CONST);
assert(codestr[3] == LOAD_CONST);
/* Create new constant */
v = PyList_GET_ITEM(consts, GETARG(codestr, 0));
w = PyList_GET_ITEM(consts, GETARG(codestr, 3));
opcode = codestr[6];
switch (opcode) {
case BINARY_POWER:
newconst = PyNumber_Power(v, w, Py_None);
break;
case BINARY_MULTIPLY:
newconst = PyNumber_Multiply(v, w);
break;
case BINARY_TRUE_DIVIDE:
newconst = PyNumber_TrueDivide(v, w);
break;
case BINARY_FLOOR_DIVIDE:
newconst = PyNumber_FloorDivide(v, w);
break;
case BINARY_MODULO:
newconst = PyNumber_Remainder(v, w);
break;
case BINARY_ADD:
newconst = PyNumber_Add(v, w);
break;
case BINARY_SUBTRACT:
newconst = PyNumber_Subtract(v, w);
break;
case BINARY_SUBSCR:
newconst = PyObject_GetItem(v, w);
/* #5057: if v is unicode, there might be differences between
wide and narrow builds in cases like '\U00012345'[0].
Wide builds will return a non-BMP char, whereas narrow builds
will return a surrogate. In both the cases skip the
optimization in order to produce compatible pycs.
*/
if (newconst != NULL &&
PyUnicode_Check(v) && PyUnicode_Check(newconst)) {
Py_UNICODE ch = PyUnicode_AS_UNICODE(newconst)[0];
#ifdef Py_UNICODE_WIDE
if (ch > 0xFFFF) {
#else
if (ch >= 0xD800 && ch <= 0xDFFF) {
#endif
Py_DECREF(newconst);
return 0;
}
}
break;
case BINARY_LSHIFT:
newconst = PyNumber_Lshift(v, w);
break;
case BINARY_RSHIFT:
newconst = PyNumber_Rshift(v, w);
break;
case BINARY_AND:
newconst = PyNumber_And(v, w);
break;
case BINARY_XOR:
newconst = PyNumber_Xor(v, w);
break;
case BINARY_OR:
newconst = PyNumber_Or(v, w);
break;
default:
/* Called with an unknown opcode */
PyErr_Format(PyExc_SystemError,
"unexpected binary operation %d on a constant",
opcode);
return 0;
}
if (newconst == NULL) {
if(!PyErr_ExceptionMatches(PyExc_KeyboardInterrupt))
PyErr_Clear();
return 0;
}
size = PyObject_Size(newconst);
if (size == -1) {
if (PyErr_ExceptionMatches(PyExc_KeyboardInterrupt))
return 0;
PyErr_Clear();
} else if (size > 20) {
Py_DECREF(newconst);
return 0;
}
/* Append folded constant into consts table */
len_consts = PyList_GET_SIZE(consts);
if (PyList_Append(consts, newconst)) {
Py_DECREF(newconst);
return 0;
}
Py_DECREF(newconst);
/* Write NOP NOP NOP NOP LOAD_CONST newconst */
memset(codestr, NOP, 4);
codestr[4] = LOAD_CONST;
SETARG(codestr, 4, len_consts);
return 1;
}
static int
fold_unaryops_on_constants(unsigned char *codestr, PyObject *consts)
{
PyObject *newconst=NULL, *v;
Py_ssize_t len_consts;
int opcode;
/* Pre-conditions */
assert(PyList_CheckExact(consts));
assert(codestr[0] == LOAD_CONST);
/* Create new constant */
v = PyList_GET_ITEM(consts, GETARG(codestr, 0));
opcode = codestr[3];
switch (opcode) {
case UNARY_NEGATIVE:
/* Preserve the sign of -0.0 */
if (PyObject_IsTrue(v) == 1)
newconst = PyNumber_Negative(v);
break;
case UNARY_INVERT:
newconst = PyNumber_Invert(v);
break;
case UNARY_POSITIVE:
newconst = PyNumber_Positive(v);
break;
default:
/* Called with an unknown opcode */
PyErr_Format(PyExc_SystemError,
"unexpected unary operation %d on a constant",
opcode);
return 0;
}
if (newconst == NULL) {
if(!PyErr_ExceptionMatches(PyExc_KeyboardInterrupt))
PyErr_Clear();
return 0;
}
/* Append folded constant into consts table */
len_consts = PyList_GET_SIZE(consts);
if (PyList_Append(consts, newconst)) {
Py_DECREF(newconst);
return 0;
}
Py_DECREF(newconst);
/* Write NOP LOAD_CONST newconst */
codestr[0] = NOP;
codestr[1] = LOAD_CONST;
SETARG(codestr, 1, len_consts);
return 1;
}
PyObject *tcaxlib_tcas_list_parse(PyObject *self, PyObject *args) {
PyObject *pyArg1, *pyArg2, *pyArg3, *pyArg4, *pyArg5;
tcas_u16 width, height;
double fps;
int layer;
tcas_u32 fpsNumerator, fpsDenominator;
tcas_unit *tcasBuf;
tcas_unit *compTcasBuf;
tcas_u32 count, chunks, units;
TCAS_StreamParser parser;
VectorPtr chunksVector;
PyObject *retTcasBuf;
if (PyTuple_GET_SIZE(args) < 5) {
PyErr_SetString(PyExc_RuntimeError, "tcas_parse error, too less parameters - `(TCAS_BUF, width, height, fps, layer)'\n");
return NULL;
}
pyArg1 = PyTuple_GET_ITEM(args, 0);
if (!PyList_Check(pyArg1)) {
PyErr_SetString(PyExc_RuntimeError, "tcas_parse error, the 1st param should be a list - `TCAS_BUF'\n");
return NULL;
}
if (PyList_GET_SIZE(pyArg1) == 0) {
PyErr_SetString(PyExc_RuntimeWarning, "tcas_parse warning, empty list `TCAS_BUF'\n");
return PyLong_FromLong(-1);
}
pyArg2 = PyTuple_GET_ITEM(args, 1);
if (!PyLong_Check(pyArg2) && !PyFloat_Check(pyArg2)) {
PyErr_SetString(PyExc_RuntimeError, "tcas_parse error, the 2nd param should be an integer - `width'\n");
return NULL;
}
pyArg3 = PyTuple_GET_ITEM(args, 2);
if (!PyLong_Check(pyArg3) && !PyFloat_Check(pyArg3)) {
PyErr_SetString(PyExc_RuntimeError, "tcas_parse error, the 3rd param should be an integer - `height'\n");
return NULL;
}
pyArg4 = PyTuple_GET_ITEM(args, 3);
if (!PyLong_Check(pyArg4) && !PyFloat_Check(pyArg4)) {
PyErr_SetString(PyExc_RuntimeError, "tcas_parse error, the 4th param should be a float - `fps'\n");
return NULL;
}
pyArg5 = PyTuple_GET_ITEM(args, 4);
if (!PyLong_Check(pyArg5) && !PyFloat_Check(pyArg5)) {
PyErr_SetString(PyExc_RuntimeError, "tcas_parse error, the 5th param should be an integer - `layer'\n");
return NULL;
}
tcaxlib_convert_tcas_list_to_buf(pyArg1, &tcasBuf, &count);
libtcas_compress_raw_chunks((const TCAS_pRawChunk)tcasBuf, count, TCAS_FALSE, &compTcasBuf, &chunks, &units);
free(tcasBuf);
width = (tcas_u16)PyLong_AsLong(pyArg2);
height = (tcas_u16)PyLong_AsLong(pyArg3);
fps = PyFloat_AsDouble(pyArg4);
layer = (int)PyLong_AsLong(pyArg5);
_tcaxlib_get_fps_n_d(fps, &fpsNumerator, &fpsDenominator);
vector_create(&chunksVector, sizeof(TCAS_Chunk), 0, NULL, NULL);
libtcas_stream_parser_init(compTcasBuf, chunks, fpsNumerator, fpsDenominator, width, height, &parser);
libtcas_stream_parser_parse(&parser, chunksVector);
libtcas_stream_parser_fin(&parser);
free(compTcasBuf);
retTcasBuf = _tcaxlib_convert_chunks_vector_to_tcas_list(chunksVector, layer);
vector_destroy(chunksVector);
return retTcasBuf;
}
/* The item is a borrowed reference. */
static const char *
get_filter(PyObject *category, PyObject *text, Py_ssize_t lineno,
PyObject *module, PyObject **item)
{
PyObject *action;
Py_ssize_t i;
PyObject *warnings_filters;
warnings_filters = get_warnings_attr("filters");
if (warnings_filters == NULL) {
if (PyErr_Occurred())
return NULL;
}
else {
Py_DECREF(_filters);
_filters = warnings_filters;
}
if (!PyList_Check(_filters)) {
PyErr_SetString(PyExc_ValueError,
MODULE_NAME ".filters must be a list");
return NULL;
}
/* _filters could change while we are iterating over it. */
for (i = 0; i < PyList_GET_SIZE(_filters); i++) {
PyObject *tmp_item, *action, *msg, *cat, *mod, *ln_obj;
Py_ssize_t ln;
int is_subclass, good_msg, good_mod;
tmp_item = *item = PyList_GET_ITEM(_filters, i);
if (PyTuple_Size(tmp_item) != 5) {
PyErr_Format(PyExc_ValueError,
MODULE_NAME ".filters item %zd isn't a 5-tuple", i);
return NULL;
}
/* Python code: action, msg, cat, mod, ln = item */
action = PyTuple_GET_ITEM(tmp_item, 0);
msg = PyTuple_GET_ITEM(tmp_item, 1);
cat = PyTuple_GET_ITEM(tmp_item, 2);
mod = PyTuple_GET_ITEM(tmp_item, 3);
ln_obj = PyTuple_GET_ITEM(tmp_item, 4);
good_msg = check_matched(msg, text);
good_mod = check_matched(mod, module);
is_subclass = PyObject_IsSubclass(category, cat);
ln = PyInt_AsSsize_t(ln_obj);
if (good_msg == -1 || good_mod == -1 || is_subclass == -1 ||
(ln == -1 && PyErr_Occurred()))
return NULL;
if (good_msg && is_subclass && good_mod && (ln == 0 || lineno == ln))
return PyString_AsString(action);
}
action = get_default_action();
if (action != NULL) {
return PyString_AsString(action);
}
PyErr_SetString(PyExc_ValueError,
MODULE_NAME ".defaultaction not found");
return NULL;
}
/* Replace LOAD_CONST c1. LOAD_CONST c2 BINOP
with LOAD_CONST binop(c1,c2)
The consts table must still be in list form so that the
new constant can be appended.
Called with codestr pointing to the first LOAD_CONST.
Abandons the transformation if the folding fails (i.e. 1+'a').
If the new constant is a sequence, only folds when the size
is below a threshold value. That keeps pyc files from
becoming large in the presence of code like: (None,)*1000.
*/
static int
fold_binops_on_constants(unsigned char *codestr, PyObject *consts)
{
PyObject *newconst, *v, *w;
Py_ssize_t len_consts, size;
int opcode;
/* Pre-conditions */
assert(PyList_CheckExact(consts));
assert(codestr[0] == LOAD_CONST);
assert(codestr[3] == LOAD_CONST);
/* Create new constant */
v = PyList_GET_ITEM(consts, GETARG(codestr, 0));
w = PyList_GET_ITEM(consts, GETARG(codestr, 3));
opcode = codestr[6];
switch (opcode) {
case BINARY_POWER:
newconst = PyNumber_Power(v, w, Py_None);
break;
case BINARY_MULTIPLY:
newconst = PyNumber_Multiply(v, w);
break;
case BINARY_TRUE_DIVIDE:
newconst = PyNumber_TrueDivide(v, w);
break;
case BINARY_FLOOR_DIVIDE:
newconst = PyNumber_FloorDivide(v, w);
break;
case BINARY_MODULO:
newconst = PyNumber_Remainder(v, w);
break;
case BINARY_ADD:
newconst = PyNumber_Add(v, w);
break;
case BINARY_SUBTRACT:
newconst = PyNumber_Subtract(v, w);
break;
case BINARY_SUBSCR:
newconst = PyObject_GetItem(v, w);
break;
case BINARY_LSHIFT:
newconst = PyNumber_Lshift(v, w);
break;
case BINARY_RSHIFT:
newconst = PyNumber_Rshift(v, w);
break;
case BINARY_AND:
newconst = PyNumber_And(v, w);
break;
case BINARY_XOR:
newconst = PyNumber_Xor(v, w);
break;
case BINARY_OR:
newconst = PyNumber_Or(v, w);
break;
default:
/* Called with an unknown opcode */
PyErr_Format(PyExc_SystemError,
"unexpected binary operation %d on a constant",
opcode);
return 0;
}
if (newconst == NULL) {
if(!PyErr_ExceptionMatches(PyExc_KeyboardInterrupt))
PyErr_Clear();
return 0;
}
size = PyObject_Size(newconst);
if (size == -1) {
if (PyErr_ExceptionMatches(PyExc_KeyboardInterrupt))
return 0;
PyErr_Clear();
} else if (size > 20) {
Py_DECREF(newconst);
return 0;
}
/* Append folded constant into consts table */
len_consts = PyList_GET_SIZE(consts);
if (PyList_Append(consts, newconst)) {
Py_DECREF(newconst);
return 0;
}
Py_DECREF(newconst);
/* Write NOP NOP NOP NOP LOAD_CONST newconst */
memset(codestr, NOP, 4);
codestr[4] = LOAD_CONST;
SETARG(codestr, 4, len_consts);
return 1;
}
/**
* evalDistribution function evaluate a model function with input vector
* @param args: input q as vector or [qx, qy] where qx, qy are vectors
*
*/
static PyObject * evalDistribution(CMassSurfaceFractal *self, PyObject *args){
PyObject *qx, *qy;
PyArrayObject * pars;
int npars ,mpars;
// Get parameters
// Reader parameter dictionary
self->model->cluster_rg = PyFloat_AsDouble( PyDict_GetItemString(self->params, "cluster_rg") );
self->model->scale = PyFloat_AsDouble( PyDict_GetItemString(self->params, "scale") );
self->model->mass_dim = PyFloat_AsDouble( PyDict_GetItemString(self->params, "mass_dim") );
self->model->surface_dim = PyFloat_AsDouble( PyDict_GetItemString(self->params, "surface_dim") );
self->model->background = PyFloat_AsDouble( PyDict_GetItemString(self->params, "background") );
self->model->primary_rg = PyFloat_AsDouble( PyDict_GetItemString(self->params, "primary_rg") );
// Get input and determine whether we have to supply a 1D or 2D return value.
if ( !PyArg_ParseTuple(args,"O",&pars) ) {
PyErr_SetString(CMassSurfaceFractalError,
"CMassSurfaceFractal.evalDistribution expects a q value.");
return NULL;
}
// Check params
if(PyArray_Check(pars)==1) {
// Length of list should 1 or 2
npars = pars->nd;
if(npars==1) {
// input is a numpy array
if (PyArray_Check(pars)) {
return evaluateOneDim(self->model, (PyArrayObject*)pars);
}
}else{
PyErr_SetString(CMassSurfaceFractalError,
"CMassSurfaceFractal.evalDistribution expect numpy array of one dimension.");
return NULL;
}
}else if( PyList_Check(pars)==1) {
// Length of list should be 2 for I(qx,qy)
mpars = PyList_GET_SIZE(pars);
if(mpars!=2) {
PyErr_SetString(CMassSurfaceFractalError,
"CMassSurfaceFractal.evalDistribution expects a list of dimension 2.");
return NULL;
}
qx = PyList_GET_ITEM(pars,0);
qy = PyList_GET_ITEM(pars,1);
if (PyArray_Check(qx) && PyArray_Check(qy)) {
return evaluateTwoDimXY(self->model, (PyArrayObject*)qx,
(PyArrayObject*)qy);
}else{
PyErr_SetString(CMassSurfaceFractalError,
"CMassSurfaceFractal.evalDistribution expect 2 numpy arrays in list.");
return NULL;
}
}
PyErr_SetString(CMassSurfaceFractalError,
"CMassSurfaceFractal.evalDistribution couln't be run.");
return NULL;
}
static PyObject *
marshal_Load_internal(PyObject *py_stream, PyObject *py_callback, int skipcrc)
{
// Return value: New Reference
char *stream;
Py_ssize_t size;
char *s;
char *end;
int type = -1; // current object type
int shared = -1; // indicates whether current object is shared
int i;
char *error = "NO ERROR SPECIFIED";
char errortext[256];
Py_ssize_t length = 0; // generic length value.
int shared_mapsize;
int shared_count; // shared object index counter
int *shared_map; // points to shared object mapping at end of stream
PyObject **shared_obj = NULL; // holds the shared objects
PyObject *obj = NULL; // currently decoded object
PyObject *result = NULL; // final result
int ct_ix = 0;
struct Container ct_stack[MAX_DEPTH];
struct Container *container = &ct_stack[0];
if(PyString_AsStringAndSize(py_stream, &stream, &size) == -1)
return NULL;
s = stream;
container->obj = NULL;
container->type = 0;
container->free = -1;
container->index = 0;
if(size < 6 || *s++ != PROTOCOL_ID)
{
int offset = 0;
result = unpickle(py_stream, &offset);
if(!result)
goto cleanup;
return result;
}
// how many shared objects in this stream?
shared_mapsize = *(int32_t *)s;
s += 4;
// Security Check: assert there is enough data for that many items.
if((5 + shared_mapsize*4) > size)
{
PyErr_Format(UnmarshalError, "Not enough room in stream for map. Wanted %d, but have only %d bytes remaining...", (shared_mapsize*4), ((int)size-5));
goto cleanup;
}
// ok, we got the map data right here...
shared_map = (int32_t *)&stream[size - shared_mapsize * 4];
// Security Check #2: assert all map entries are between 1 and shared_mapsize
for(i=0; i<shared_mapsize; i++)
{
if( (shared_map[i] > shared_mapsize) || (shared_map[i] < 1) )
{
PyErr_SetString(UnmarshalError, "Bogus map data in marshal stream");
goto cleanup;
}
}
// the start of which is incidentally also the end of the object data.
end = (char *)shared_map;
// create object table
shared_obj = PyMem_MALLOC(shared_mapsize * sizeof(PyObject *));
if(!shared_obj)
goto cleanup;
// zero out object table
for(shared_count = 0; shared_count < shared_mapsize; shared_count++)
shared_obj[shared_count] = NULL;
shared_count = 0;
// start decoding.
while(s < end)
{
// This outer loop is responsible for reading and decoding the next
// object from the stream. The object is then handed to the inner loop,
// which adds it to the current container, or returns it to the caller.
// get type of next object to decode and check shared flag
type = *s++;
shared = type & SHARED_FLAG;
type &= ~SHARED_FLAG;
// if token uses a normal length value, read it now.
if(needlength[type])
{
READ_LENGTH;
}
else
length = 0;
#if MARSHAL_DEBUG
// if(shared)
{
char text[220];
DEBUG_INDENT;
sprintf(text, "pos:%4d type:%s(0x%02x) shared:%d len:%4d map:[", s-stream, tokenname[type], type, shared?1:0, length);
printf(text);
for(i=0; i<shared_mapsize; i++)
printf("%d(%d),", shared_obj[i], shared_obj[i] ? ((PyObject *)(shared_obj[i]))->ob_refcnt : 0);
printf("]\r\n");
}
#endif // MARSHAL_DEBUG
switch(type) {
//
// break statement:
// attempts to add the newly decoded object (in the obj variable) to
// the currently building container object.
//
// continue statement:
// indicates the decoded object or type marker was handled/consumed
// by the case and should _not_ be added to the currently building
// container object or used in any other way; immediately decode a
// new object
//
//---------------------------------------------------------------------
// SCALAR TYPES
//---------------------------------------------------------------------
case TYPE_INT8:
CHECK_SIZE(1);
obj = PyInt_FromLong(*(int8_t *)s);
s++;
break;
case TYPE_INT16:
CHECK_SIZE(2);
obj = PyInt_FromLong(*(int16_t *)s);
s += 2;
break;
case TYPE_INT32:
CHECK_SIZE(4);
obj = PyInt_FromLong(*(int32_t *)s);
s += 4;
break;
case TYPE_INT64:
CHECK_SIZE(8);
obj = PyLong_FromLongLong(*(int64_t *)s);
s += 8;
break;
case TYPE_LONG:
CHECK_SIZE(length);
if(!length)
obj = PyLong_FromLong(0);
else
{
obj = _PyLong_FromByteArray((unsigned char *)s, length, 1, 1);
Py_INCREF(obj);
}
CHECK_SHARED(obj);
s += length;
break;
case TYPE_FLOAT:
CHECK_SIZE(8);
obj = PyFloat_FromDouble(*(double *)s);
s += 8;
break;
case TYPE_CHECKSUM:
CHECK_SIZE(4);
if(!skipcrc && (*(uint32_t *)s != (uint32_t)adler32(1, s, (unsigned long)(end-s))))
{
error = "checksum error";
goto fail;
}
s += 4;
// because this type does not yield an object, go grab another
// object right away!
continue;
//---------------------------------------------------------------------
// STRING TYPES
//---------------------------------------------------------------------
case TYPE_STRINGR:
if (length < 1 || length >= PyList_GET_SIZE(string_table))
{
if(PyList_GET_SIZE(string_table))
PyErr_Format(UnmarshalError, "Invalid string table index %d", (int)length);
else
PyErr_SetString(PyExc_RuntimeError, "_stringtable not initialized");
goto cleanup;
}
obj = PyList_GET_ITEM(string_table, length);
Py_INCREF(obj);
break;
case TYPE_STRING:
// appears to be deprecated since machoVersion 213
CHECK_SIZE(1);
length = *(unsigned char *)s++;
CHECK_SIZE(length);
obj = PyString_FromStringAndSize(s, length);
s += length;
break;
case TYPE_STRING1:
CHECK_SIZE(1);
obj = PyString_FromStringAndSize(s, 1);
s++;
break;
case TYPE_STREAM:
// fallthrough, can be treated as string.
case TYPE_STRINGL:
// fallthrough, deprecated since machoVersion 213
case TYPE_BUFFER:
// Type identifier re-used by CCP. treat as string.
CHECK_SIZE(length);
obj = PyString_FromStringAndSize(s, length);
s += length;
CHECK_SHARED(obj);
break;
case TYPE_UNICODE1:
CHECK_SIZE(2);
#ifdef Py_UNICODE_WIDE
obj = _PyUnicodeUCS4_FromUCS2((void *)s, 1);
#else
obj = PyUnicode_FromWideChar((wchar_t *)s, 1);
#endif
s += 2;
break;
case TYPE_UNICODE:
CHECK_SIZE(length*2);
#ifdef Py_UNICODE_WIDE
obj = _PyUnicodeUCS4_FromUCS2((void *)s, (int)length);
#else
obj = PyUnicode_FromWideChar((wchar_t *)s, length);
#endif
s += length*2;
break;
case TYPE_UTF8:
CHECK_SIZE(length);
obj = PyUnicode_DecodeUTF8(s, length, NULL);
s += length;
break;
//---------------------------------------------------------------------
// SEQUENCE/MAPPING TYPES
//---------------------------------------------------------------------
case TYPE_TUPLE1:
NEW_SEQUENCE(TYPE_TUPLE, 1);
continue;
case TYPE_TUPLE2:
NEW_SEQUENCE(TYPE_TUPLE, 2);
continue;
case TYPE_TUPLE:
NEW_SEQUENCE(TYPE_TUPLE, (int)length);
continue;
case TYPE_LIST0:
obj = PyList_New(0);
CHECK_SHARED(obj);
break;
case TYPE_LIST1:
NEW_SEQUENCE(TYPE_LIST, 1);
continue;
case TYPE_LIST:
NEW_SEQUENCE(TYPE_LIST, (int)length);
continue;
case TYPE_DICT:
if(length)
{
CHECK_SIZE(length*2);
PUSH_CONTAINER(TYPE_DICT, (int)length*2);
container->obj = PyDict_New();
container->obj2 = NULL;
container->index = 0;
CHECK_SHARED(container->obj);
continue;
}
else
{
obj = PyDict_New();
CHECK_SHARED(obj);
break;
}
//---------------------------------------------------------------------
// OBJECT TYPES
//---------------------------------------------------------------------
case TYPE_REF:
// length value is index in sharedobj array!
if((length < 1 || length > shared_mapsize))
{
error = "Shared reference index out of range";
goto fail;
}
if(!(obj = shared_obj[length-1]))
{
error = "Shared reference points to invalid object";
goto fail;
}
Py_INCREF(obj);
//printf("Getting object %d from %d (refs:%d)\r\n", (int)obj, length-1, obj->ob_refcnt);
break;
case TYPE_GLOBAL:
{
PyObject *name;
CHECK_SIZE(length);
name = PyString_FromStringAndSize(s, length);
if(!name)
goto cleanup;
s += length;
if(!(obj = find_global(name)))
{
// exception should be set by find_global
goto cleanup;
}
Py_DECREF(name);
CHECK_SHARED(obj);
break;
}
case TYPE_DBROW:
case TYPE_INSTANCE:
case TYPE_NEWOBJ:
case TYPE_REDUCE:
PUSH_CONTAINER(type, -1);
container->obj = NULL;
RESERVE_SLOT(container->index);
continue;
case TYPE_MARK:
// this is a marker, not a real object. list/dict iterators check
// for this type, but it can't be instantiated.
break;
default:
if((obj = constants[type]))
{
Py_INCREF(obj);
}
else
{
error = "Unsupported type";
goto fail;
}
}
// object decoding and construction done!
if(!obj && type != TYPE_MARK)
{
// if obj is somehow NULL, whatever caused it is expected to have
// set an exception at this point.
goto cleanup;
}
#if MARSHAL_DEBUG
/*
if(obj && obj->ob_refcnt < 0)
{
char b[200];
sprintf(b, "type: %d, refcount: %d", type, obj->ob_refcnt);
DEBUG(b);
}
*/
if(obj) {
DEBUG_INDENT;
printf("`-- ");
PyObject_Print(obj, stdout, 0);
printf("\r\n");
fflush(stdout);
}
else
{
DEBUG_INDENT;
printf("*** MARK\r\n");
}
#endif // MARSHAL_DEBUG
while(1)
{
// This inner loop does one of two things:
//
// - return the finished object to the caller if we're at the root
// container.
//
// - add the object to the current container in a container-
// specific manner. note that ownership of the reference is to be
// given to the container object.
#if MARSHAL_DEBUG
{
//char text[220];
DEBUG_INDENT;
printf("container ix:%d (%08lx) type:%s[0x%02x] free:%d index:%d\r\n", ct_ix, container->obj, tokenname[container->type], container->type, container->free, container->index);
}
#endif // MARSHAL_DEBUG
/* if(!container->obj) {
error = "Root container popped off stack";
goto fail;
}
*/
switch(container->type) {
case TYPE_TUPLE:
// tuples steal references.
PyTuple_SET_ITEM(container->obj, container->index++, obj);
break;
case TYPE_LIST:
// lists steal references.
PyList_SET_ITEM(container->obj, container->index++, obj);
break;
case TYPE_DBROW:
if(container->obj)
{
// we have an initialized DBRow. current object is a
// non-scalar object for the row. append it.
if(!dbrow_append_internal((PyDBRowObject *)container->obj, obj))
{
// append call will have set an exception here.
goto cleanup;
}
}
else
{
// we now have a DBRowDescriptor, and the header data
// should follow. Pull it and create the DBRow.
READ_LENGTH;
CHECK_SIZE(length);
container->obj = PyDBRow_New((PyDBRowDescriptorObject *)obj, s, (int)length);
container->free = 1+((PyDBRowDescriptorObject *)obj)->rd_num_objects;
if(!container->obj)
goto cleanup;
Py_DECREF(obj);
s += length;
// add as shared object, if neccessary...
UPDATE_SLOT(container->index, container->obj);
}
break;
case TYPE_INSTANCE:
{
PyObject *cls;
if(container->free == -1)
{
// create class instance
if(!(cls = find_global(obj)))
goto cleanup;
container->obj = PyInstance_NewRaw(cls, 0);
Py_DECREF(cls);
if(!container->obj)
goto cleanup;
UPDATE_SLOT(container->index, container->obj);
Py_DECREF(obj);
break;
}
if(container->free == -2)
{
container->free = 1;
// set state.
if(!set_state(container->obj, obj))
goto cleanup;
Py_DECREF(obj);
break;
}
error = "invalid container state";
goto fail;
}
case TYPE_NEWOBJ:
{
PyObject *cls, *args, *__new__, *state;
// instantiate the object...
if(!(args = PyTuple_GetItem(obj, 0)))
goto cleanup;
if(!(cls = PyTuple_GetItem(args, 0)))
goto cleanup;
__new__ = PyObject_GetAttr(cls, py__new__);
if(!__new__)
goto cleanup;
container->obj = PyObject_CallObject(__new__, args);
Py_DECREF(__new__);
if(!container->obj)
goto cleanup;
// add as shared object, if neccessary...
UPDATE_SLOT(container->index, container->obj);
// is there state data?
if(PyTuple_GET_SIZE(obj) > 1)
{
state = PyTuple_GET_ITEM(obj, 1);
if(!set_state(container->obj, state))
goto cleanup;
}
Py_DECREF(obj);
// switch to list iterator
LIST_ITERATOR;
break;
}
case TYPE_REDUCE:
{
PyObject *callable, *args, *state;
if(!(args = PyTuple_GetItem(obj, 1)))
goto cleanup;
if(!(callable = PyTuple_GET_ITEM(obj, 0)))
goto cleanup;
if(!(container->obj = PyObject_CallObject(callable, args)))
goto cleanup;
UPDATE_SLOT(container->index, container->obj);
if(PyTuple_GET_SIZE(obj) > 2)
{
state = PyTuple_GET_ITEM(obj, 2);
if(!set_state(container->obj, state))
goto cleanup;
}
Py_DECREF(obj);
// switch to list iterator
LIST_ITERATOR;
break;
}
case TYPE_LIST_ITERATOR:
if(type == TYPE_MARK)
{
// clear mark so nested iterator containers do not get terminated prematurely.
type = -1;
// decref the append method
Py_XDECREF(container->obj2);
container->obj2 = NULL;
container->type = TYPE_DICT_ITERATOR;
break;
}
if(!container->obj2)
{
// grab the append method from the container and keep
// it around for speed.
if(!(container->obj2 = PyObject_GetAttr(container->obj, pyappend)))
goto cleanup;
}
if(!PyObject_CallFunctionObjArgs(container->obj2, obj, NULL))
goto cleanup;
#if MARSHAL_DEBUG
DEBUG_INDENT;
printf("Appended %08lx to %08lx\r\n", obj, container->obj);
#endif // MARSHAL_DEBUG
Py_DECREF(obj);
break;
case TYPE_DICT_ITERATOR:
if(type == TYPE_MARK)
{
// clear mark so nested iterator containers do not get terminated prematurely.
type = -1;
// we're done with dict iter. container is finished.
container->free = 1;
break;
}
POPULATE_DICT(container->obj2, obj);
break;
case TYPE_DICT:
POPULATE_DICT(obj, container->obj2);
break;
case 0:
// we're at the root. return the object to caller.
result = obj;
// avoid decreffing this object.
obj = NULL;
goto cleanup;
}
container->free--;
if(container->free)
// still room in this container.
// break out of container handling to get next object for it.
break;
// this container is done, it is the next object to put into the
// container under it!
obj = container->obj;
// switch context to said older container
POP_CONTAINER;
}
// we've processed the object. clear it for next one.
obj = NULL;
}
// if we get here, we're out of data, but it's a "clean" eof; we ran out
// of data while expecting a new object...
error = "Not enough objects in stream";
fail:
PyErr_Format(UnmarshalError, "%s - type:0x%02x ctype:0x%02x len:%d share:%d pos:%d size:%d", error, type, container->type, (int)length, shared, (int)(s-stream), (int)(size));
cleanup:
// on any error the current object we were working on will be unassociated
// with anything, decref it. if decode was succesful or an object failed to
// be created, it will be NULL anyway.
Py_XDECREF(obj);
// same story for containers...
while(container->type)
{
Py_XDECREF(container->obj);
// possibly unassociated object for dict entry?
if(container->type == TYPE_DICT || container->type == TYPE_DICT_ITERATOR)
{
Py_XDECREF(container->obj2);
}
POP_CONTAINER;
}
if(shared_obj)
{
/* shared object list held a safety ref to all objects, decref em */
int i;
for(i=0; i<shared_mapsize; i++)
Py_XDECREF(shared_obj[i]);
/* and free the list */
PyMem_FREE(shared_obj);
}
return result;
}
PyObject* xcsoar_Airspaces_findIntrusions(Pyxcsoar_Airspaces *self, PyObject *args) {
PyObject *py_flight = nullptr;
if (!PyArg_ParseTuple(args, "O", &py_flight)) {
PyErr_SetString(PyExc_AttributeError, "Can't parse argument.");
return nullptr;
}
DebugReplay *replay = ((Pyxcsoar_Flight*)py_flight)->flight->Replay();
if (replay == nullptr) {
PyErr_SetString(PyExc_IOError, "Can't start replay - file not found.");
return nullptr;
}
PyObject *py_result = PyDict_New();
Airspaces::AirspaceVector last_airspaces;
while (replay->Next()) {
const MoreData &basic = replay->Basic();
if (!basic.time_available || !basic.location_available ||
!basic.NavAltitudeAvailable())
continue;
const auto range =
self->airspace_database->QueryInside(ToAircraftState(basic,
replay->Calculated()));
Airspaces::AirspaceVector airspaces(range.begin(), range.end());
for (auto it = airspaces.begin(); it != airspaces.end(); it++) {
PyObject *py_name = PyString_FromString((*it).GetAirspace().GetName());
PyObject *py_airspace = nullptr,
*py_period = nullptr;
if (PyDict_Contains(py_result, py_name) == 0) {
// this is the first fix inside this airspace
py_airspace = PyList_New(0);
PyDict_SetItem(py_result, py_name, py_airspace);
py_period = PyList_New(0);
PyList_Append(py_airspace, py_period);
Py_DECREF(py_period);
} else {
// this airspace was hit some time before...
py_airspace = PyDict_GetItem(py_result, py_name);
// check if the last fix was already inside this airspace
auto in_last = std::find(last_airspaces.begin(), last_airspaces.end(), *it);
if (in_last == last_airspaces.end()) {
// create a new period
py_period = PyList_New(0);
PyList_Append(py_airspace, py_period);
Py_DECREF(py_period);
} else {
py_period = PyList_GET_ITEM(py_airspace, PyList_GET_SIZE(py_airspace) - 1);
}
}
PyList_Append(py_period, Py_BuildValue("{s:N,s:N}",
"time", Python::BrokenDateTimeToPy(basic.date_time_utc),
"location", Python::WriteLonLat(basic.location)));
}
last_airspaces = std::move(airspaces);
}
delete replay;
return py_result;
}
/* Get buffer info from the global dictionary */
static _buffer_info_t*
_buffer_get_info(PyObject *arr)
{
PyObject *key = NULL, *item_list = NULL, *item = NULL;
_buffer_info_t *info = NULL, *old_info = NULL;
if (_buffer_info_cache == NULL) {
_buffer_info_cache = PyDict_New();
if (_buffer_info_cache == NULL) {
return NULL;
}
}
/* Compute information */
info = _buffer_info_new((PyArrayObject*)arr);
if (info == NULL) {
return NULL;
}
/* Check if it is identical with an old one; reuse old one, if yes */
key = PyLong_FromVoidPtr((void*)arr);
if (key == NULL) {
goto fail;
}
item_list = PyDict_GetItem(_buffer_info_cache, key);
if (item_list != NULL) {
Py_INCREF(item_list);
if (PyList_GET_SIZE(item_list) > 0) {
item = PyList_GetItem(item_list, PyList_GET_SIZE(item_list) - 1);
old_info = (_buffer_info_t*)PyLong_AsVoidPtr(item);
if (_buffer_info_cmp(info, old_info) == 0) {
_buffer_info_free(info);
info = old_info;
}
}
}
else {
item_list = PyList_New(0);
if (item_list == NULL) {
goto fail;
}
if (PyDict_SetItem(_buffer_info_cache, key, item_list) != 0) {
goto fail;
}
}
if (info != old_info) {
/* Needs insertion */
item = PyLong_FromVoidPtr((void*)info);
if (item == NULL) {
goto fail;
}
PyList_Append(item_list, item);
Py_DECREF(item);
}
Py_DECREF(item_list);
Py_DECREF(key);
return info;
fail:
if (info != NULL && info != old_info) {
_buffer_info_free(info);
}
Py_XDECREF(item_list);
Py_XDECREF(key);
return NULL;
}