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(PyBytes_Check(lineno_obj));
lineno = (unsigned char*)PyBytes_AS_STRING(lineno_obj);
tabsiz = PyBytes_GET_SIZE(lineno_obj);
if (memchr(lineno, 255, tabsiz) != NULL)
goto exitUnchanged;
/* Avoid situations where jump retargeting could overflow */
assert(PyBytes_Check(code));
codelen = PyBytes_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,
PyBytes_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])) {
reoptimize_current:
opcode = codestr[i];
lastlc = cumlc;
cumlc = 0;
switch (opcode) {
/* Replace UNARY_NOT POP_JUMP_IF_FALSE
with POP_JUMP_IF_TRUE */
case UNARY_NOT:
if (codestr[i+1] != POP_JUMP_IF_FALSE
|| !ISBASICBLOCK(blocks,i,4))
continue;
j = GETARG(codestr, i+1);
codestr[i] = POP_JUMP_IF_TRUE;
SETARG(codestr, i, j);
codestr[i+3] = NOP;
goto reoptimize_current;
/* 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/True/False
with LOAD_CONST None/True/False */
case LOAD_NAME:
case LOAD_GLOBAL:
j = GETARG(codestr, i);
name = _PyUnicode_AsString(PyTuple_GET_ITEM(names, j));
h = load_global(codestr, i, name, consts);
if (h < 0)
goto exitError;
else if (h == 0)
continue;
cumlc = lastlc + 1;
break;
/* Skip over LOAD_CONST trueconst
POP_JUMP_IF_FALSE xx. This improves
"while 1" performance. */
case LOAD_CONST:
cumlc = lastlc + 1;
j = GETARG(codestr, i);
if (codestr[i+3] != POP_JUMP_IF_FALSE ||
!ISBASICBLOCK(blocks,i,6) ||
!PyObject_IsTrue(PyList_GET_ITEM(consts, j)))
continue;
memset(codestr+i, NOP, 6);
cumlc = 0;
break;
/* Try to fold tuples of constants (includes a case for lists and sets
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:
case BUILD_SET:
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 || opcode == BUILD_SET) &&
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) ||
opcode == BUILD_SET)
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_INVERT:
case UNARY_POSITIVE:
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_OR_POP y y:JUMP_IF_FALSE_OR_POP z
--> x:JUMP_IF_FALSE_OR_POP z
x:JUMP_IF_FALSE_OR_POP y y:JUMP_IF_TRUE_OR_POP z
--> x:POP_JUMP_IF_FALSE y+3
where y+3 is the instruction following the second test.
*/
case JUMP_IF_FALSE_OR_POP:
case JUMP_IF_TRUE_OR_POP:
tgt = GETJUMPTGT(codestr, i);
j = codestr[tgt];
if (CONDITIONAL_JUMP(j)) {
/* NOTE: all possible jumps here are
absolute! */
if (JUMPS_ON_TRUE(j) == JUMPS_ON_TRUE(opcode)) {
/* The second jump will be
taken iff the first is. */
tgttgt = GETJUMPTGT(codestr, tgt);
/* The current opcode inherits
its target's stack behaviour */
codestr[i] = j;
SETARG(codestr, i, tgttgt);
goto reoptimize_current;
} else {
/* The second jump is not taken
if the first is (so jump past
it), and all conditional
jumps pop their argument when
they're not taken (so change
the first jump to pop its
argument when it's taken). */
if (JUMPS_ON_TRUE(opcode))
codestr[i] = POP_JUMP_IF_TRUE;
else
codestr[i] = POP_JUMP_IF_FALSE;
SETARG(codestr, i, (tgt + 3));
goto reoptimize_current;
}
}
/* Intentional fallthrough */
/* Replace jumps to unconditional jumps */
case POP_JUMP_IF_FALSE:
case POP_JUMP_IF_TRUE:
case FOR_ITER:
case JUMP_FORWARD:
case JUMP_ABSOLUTE:
case CONTINUE_LOOP:
case SETUP_LOOP:
case SETUP_EXCEPT:
case SETUP_FINALLY:
case SETUP_WITH:
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:
if (codestr[i+3] != MAKE_FUNCTION)
goto exitUnchanged;
/* don't visit MAKE_FUNCTION as GETARG will be wrong */
i += 3;
break;
/* 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:
case POP_JUMP_IF_FALSE:
case POP_JUMP_IF_TRUE:
case JUMP_IF_FALSE_OR_POP:
case JUMP_IF_TRUE_OR_POP:
j = addrmap[GETARG(codestr, i)];
SETARG(codestr, i, j);
break;
case FOR_ITER:
case JUMP_FORWARD:
case SETUP_LOOP:
case SETUP_EXCEPT:
case SETUP_FINALLY:
case SETUP_WITH:
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 = PyBytes_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 bool GetParameterInfo(Cursor* cur, Py_ssize_t index, PyObject* param, ParamInfo& info)
{
// Determines the type of SQL parameter that will be used for this parameter based on the Python data type.
//
// Populates `info`.
// TODO: if the param is a SQLParameter object, then bind to the wrapped value and use the input/output type from that
// Hold a reference to param until info is freed, because info will often be holding data borrowed from param.
if (PyObject_TypeCheck(param, (PyTypeObject*)SQLParameter_type))
{
info.pParam = ((SQLParameter*)param)->value;
info.InputOutputType = ((SQLParameter*)param)->type;
}
else
{
info.pParam = param;
info.InputOutputType = SQL_PARAM_INPUT;
}
if (info.pParam == Py_None)
return GetNullInfo(cur, index, info);
if (info.pParam == null_binary)
return GetNullBinaryInfo(cur, index, info);
if (PyBytes_Check(info.pParam))
return GetBytesInfo(cur, index, info.pParam, info);
if (PyUnicode_Check(info.pParam))
return GetUnicodeInfo(cur, index, info.pParam, info);
if (PyBool_Check(info.pParam))
return GetBooleanInfo(cur, index, info.pParam, info);
if (PyDateTime_Check(info.pParam))
return GetDateTimeInfo(cur, index, info.pParam, info);
if (PyDate_Check(info.pParam))
return GetDateInfo(cur, index, info.pParam, info);
if (PyTime_Check(info.pParam))
return GetTimeInfo(cur, index, info.pParam, info);
if (PyLong_Check(info.pParam))
return GetLongInfo(cur, index, info.pParam, info);
if (PyFloat_Check(info.pParam))
return GetFloatInfo(cur, index, info.pParam, info);
if (PyDecimal_Check(info.pParam))
return GetDecimalInfo(cur, index, info.pParam, info);
#if PY_VERSION_HEX >= 0x02060000
if (PyByteArray_Check(info.pParam))
return GetByteArrayInfo(cur, index, info.pParam, info);
#endif
#if PY_MAJOR_VERSION < 3
if (PyInt_Check(info.pParam))
return GetIntInfo(cur, index, info.pParam, info);
if (PyBuffer_Check(info.pParam))
return GetBufferInfo(cur, index, info.pParam, info);
#endif
RaiseErrorV("HY105", ProgrammingError, "Invalid parameter type. param-index=%zd param-type=%s", index, Py_TYPE(info.pParam)->tp_name);
return false;
}
/**
* \note group can be a pointer array or a group.
* assume we already checked key is a string.
*
* \return success.
*/
bool BPy_IDProperty_Map_ValidateAndCreate(PyObject *name_obj, IDProperty *group, PyObject *ob)
{
IDProperty *prop = NULL;
IDPropertyTemplate val = {0};
const char *name;
if (name_obj) {
Py_ssize_t name_size;
name = _PyUnicode_AsStringAndSize(name_obj, &name_size);
if (name == NULL) {
PyErr_Format(PyExc_KeyError,
"invalid id-property key, expected a string, not a %.200s",
Py_TYPE(name_obj)->tp_name);
return false;
}
if (name_size > MAX_IDPROP_NAME) {
PyErr_SetString(PyExc_KeyError, "the length of IDProperty names is limited to 63 characters");
return false;
}
}
else {
name = "";
}
if (PyFloat_Check(ob)) {
val.d = PyFloat_AsDouble(ob);
prop = IDP_New(IDP_DOUBLE, &val, name);
}
else if (PyLong_Check(ob)) {
val.i = _PyLong_AsInt(ob);
if (val.i == -1 && PyErr_Occurred()) {
return false;
}
prop = IDP_New(IDP_INT, &val, name);
}
else if (PyUnicode_Check(ob)) {
#ifdef USE_STRING_COERCE
PyObject *value_coerce = NULL;
val.string.str = (char *)PyC_UnicodeAsByte(ob, &value_coerce);
val.string.subtype = IDP_STRING_SUB_UTF8;
prop = IDP_New(IDP_STRING, &val, name);
Py_XDECREF(value_coerce);
#else
val.str = _PyUnicode_AsString(ob);
prop = IDP_New(IDP_STRING, val, name);
#endif
}
else if (PyBytes_Check(ob)) {
val.string.str = PyBytes_AS_STRING(ob);
val.string.len = PyBytes_GET_SIZE(ob);
val.string.subtype = IDP_STRING_SUB_BYTE;
prop = IDP_New(IDP_STRING, &val, name);
//prop = IDP_NewString(PyBytes_AS_STRING(ob), name, PyBytes_GET_SIZE(ob));
//prop->subtype = IDP_STRING_SUB_BYTE;
}
else if (PySequence_Check(ob)) {
PyObject *ob_seq_fast = PySequence_Fast(ob, "py -> idprop");
PyObject *item;
int i;
if (ob_seq_fast == NULL) {
return false;
}
if ((val.array.type = idp_sequence_type(ob_seq_fast)) == -1) {
Py_DECREF(ob_seq_fast);
PyErr_SetString(PyExc_TypeError, "only floats, ints and dicts are allowed in ID property arrays");
return false;
}
/* validate sequence and derive type.
* we assume IDP_INT unless we hit a float
* number; then we assume it's */
val.array.len = PySequence_Fast_GET_SIZE(ob_seq_fast);
switch (val.array.type) {
case IDP_DOUBLE:
{
double *prop_data;
prop = IDP_New(IDP_ARRAY, &val, name);
prop_data = IDP_Array(prop);
for (i = 0; i < val.array.len; i++) {
item = PySequence_Fast_GET_ITEM(ob_seq_fast, i);
if (((prop_data[i] = PyFloat_AsDouble(item)) == -1.0) && PyErr_Occurred()) {
Py_DECREF(ob_seq_fast);
return false;
}
}
break;
}
case IDP_INT:
{
int *prop_data;
prop = IDP_New(IDP_ARRAY, &val, name);
prop_data = IDP_Array(prop);
for (i = 0; i < val.array.len; i++) {
item = PySequence_Fast_GET_ITEM(ob_seq_fast, i);
if (((prop_data[i] = _PyLong_AsInt(item)) == -1) && PyErr_Occurred()) {
Py_DECREF(ob_seq_fast);
return false;
}
}
break;
}
case IDP_IDPARRAY:
{
prop = IDP_NewIDPArray(name);
for (i = 0; i < val.array.len; i++) {
item = PySequence_Fast_GET_ITEM(ob_seq_fast, i);
if (BPy_IDProperty_Map_ValidateAndCreate(NULL, prop, item) == false) {
Py_DECREF(ob_seq_fast);
return false;
}
}
break;
}
default:
/* should never happen */
Py_DECREF(ob_seq_fast);
PyErr_SetString(PyExc_RuntimeError, "internal error with idp array.type");
return false;
}
Py_DECREF(ob_seq_fast);
}
else if (PyMapping_Check(ob)) {
PyObject *keys, *vals, *key, *pval;
int i, len;
/*yay! we get into recursive stuff now!*/
keys = PyMapping_Keys(ob);
vals = PyMapping_Values(ob);
/* we allocate the group first; if we hit any invalid data,
* we can delete it easily enough.*/
prop = IDP_New(IDP_GROUP, &val, name);
len = PyMapping_Length(ob);
for (i = 0; i < len; i++) {
key = PySequence_GetItem(keys, i);
pval = PySequence_GetItem(vals, i);
if (BPy_IDProperty_Map_ValidateAndCreate(key, prop, pval) == false) {
IDP_FreeProperty(prop);
MEM_freeN(prop);
Py_XDECREF(keys);
Py_XDECREF(vals);
Py_XDECREF(key);
Py_XDECREF(pval);
/* error is already set */
return false;
}
Py_XDECREF(key);
Py_XDECREF(pval);
}
Py_XDECREF(keys);
Py_XDECREF(vals);
}
else {
PyErr_Format(PyExc_TypeError,
"invalid id-property type %.200s not supported",
Py_TYPE(ob)->tp_name);
return false;
}
if (group->type == IDP_IDPARRAY) {
IDP_AppendArray(group, prop);
// IDP_FreeProperty(item); /* IDP_AppendArray does a shallow copy (memcpy), only free memory */
MEM_freeN(prop);
}
else {
IDP_ReplaceInGroup(group, prop);
}
return true;
}
static PyObject *
log_to_postgres(PyObject *self, PyObject *args, PyObject *kwargs)
{
char *message = NULL;
char *hintstr = NULL,
*detailstr = NULL;
int level = 1;
int severity;
PyObject *hint,
*p_message,
*detail;
if (!PyArg_ParseTuple(args, "O|i", &p_message, &level))
{
errorCheck();
Py_INCREF(Py_None);
return Py_None;
}
if (PyBytes_Check(p_message))
{
message = PyBytes_AsString(p_message);
}
else if (PyUnicode_Check(p_message))
{
message = strdup(PyUnicode_AsPgString(p_message));
}
else
{
PyObject *temp = PyObject_Str(p_message);
errorCheck();
message = strdup(PyString_AsString(temp));
errorCheck();
Py_DECREF(temp);
}
switch (level)
{
case 0:
severity = DEBUG1;
break;
case 1:
severity = NOTICE;
break;
case 2:
severity = WARNING;
break;
case 3:
severity = ERROR;
break;
case 4:
severity = FATAL;
break;
default:
severity = INFO;
break;
}
hint = PyDict_GetItemString(kwargs, "hint");
detail = PyDict_GetItemString(kwargs, "detail");
if (errstart(severity, __FILE__, __LINE__, PG_FUNCNAME_MACRO, TEXTDOMAIN))
{
errmsg("%s", message);
if (hint != NULL && hint != Py_None)
{
hintstr = PyString_AsString(hint);
errhint("%s", hintstr);
}
if (detail != NULL && detail != Py_None)
{
detailstr = PyString_AsString(detail);
errdetail("%s", detailstr);
}
Py_DECREF(args);
Py_DECREF(kwargs);
errfinish(0);
}
else
{
Py_DECREF(args);
Py_DECREF(kwargs);
}
Py_INCREF(Py_None);
return Py_None;
}
PyObject *
_pyccn_cmd_encode_ContentObject(PyObject *UNUSED(self), PyObject *args)
{
PyObject *py_content_object, *py_name, *py_content, *py_signed_info,
*py_key;
PyObject *py_o = NULL, *ret = NULL;
struct ccn_charbuf *name, *signed_info, *content_object = NULL;
struct ccn_pkey *private_key;
const char *digest_alg = NULL;
char *content;
Py_ssize_t content_len;
int r;
if (!PyArg_ParseTuple(args, "OOOOO", &py_content_object, &py_name,
&py_content, &py_signed_info, &py_key))
return NULL;
if (strcmp(py_content_object->ob_type->tp_name, "ContentObject")) {
PyErr_SetString(PyExc_TypeError, "Must pass a ContentObject as arg 1");
return NULL;
}
if (!CCNObject_IsValid(NAME, py_name)) {
PyErr_SetString(PyExc_TypeError, "Must pass a CCN Name as arg 2");
return NULL;
} else
name = CCNObject_Get(NAME, py_name);
if (py_content != Py_None && !PyBytes_Check(py_content)) {
PyErr_SetString(PyExc_TypeError, "Must pass a Bytes as arg 3");
return NULL;
} else if (py_content == Py_None) {
content = NULL;
content_len = 0;
} else {
r = PyBytes_AsStringAndSize(py_content, &content, &content_len);
if (r < 0)
return NULL;
}
if (!CCNObject_IsValid(SIGNED_INFO, py_signed_info)) {
PyErr_SetString(PyExc_TypeError, "Must pass a CCN SignedInfo as arg 4");
return NULL;
} else
signed_info = CCNObject_Get(SIGNED_INFO, py_signed_info);
if (strcmp(py_key->ob_type->tp_name, "Key")) {
PyErr_SetString(PyExc_TypeError, "Must pass a Key as arg 4");
return NULL;
}
// DigestAlgorithm
py_o = PyObject_GetAttrString(py_content_object, "digestAlgorithm");
if (py_o != Py_None) {
PyErr_SetString(PyExc_NotImplementedError, "non-default digest"
" algorithm not yet supported");
goto error;
}
Py_CLEAR(py_o);
// Key
private_key = Key_to_ccn_private(py_key);
// Note that we don't load this key into the keystore hashtable in the library
// because it makes this method require access to a ccn handle, and in fact,
// ccn_sign_content just uses what's in signedinfo (after an error check by
// chk_signing_params and then calls ccn_encode_ContentObject anyway
//
// Encode the content object
// Build the ContentObject here.
content_object = ccn_charbuf_create();
JUMP_IF_NULL_MEM(content_object, error);
r = ccn_encode_ContentObject(content_object, name, signed_info, content,
content_len, digest_alg, private_key);
debug("ccn_encode_ContentObject res=%d\n", r);
if (r < 0) {
ccn_charbuf_destroy(&content_object);
PyErr_SetString(g_PyExc_CCNError, "Unable to encode ContentObject");
goto error;
}
ret = CCNObject_New(CONTENT_OBJECT, content_object);
error:
Py_XDECREF(py_o);
return ret;
}
void *
weechat_python_exec (struct t_plugin_script *script,
int ret_type, const char *function,
char *format, void **argv)
{
struct t_plugin_script *old_python_current_script;
PyThreadState *old_interpreter;
PyObject *evMain, *evDict, *evFunc, *rc;
void *argv2[16], *ret_value;
int i, argc, *ret_int;
ret_value = NULL;
/* PyEval_AcquireLock (); */
old_python_current_script = python_current_script;
python_current_script = script;
old_interpreter = NULL;
if (script->interpreter)
{
old_interpreter = PyThreadState_Swap (NULL);
PyThreadState_Swap (script->interpreter);
}
evMain = PyImport_AddModule ((char *) "__main__");
evDict = PyModule_GetDict (evMain);
evFunc = PyDict_GetItemString (evDict, function);
if ( !(evFunc && PyCallable_Check (evFunc)) )
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to run function \"%s\""),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function);
/* PyEval_ReleaseThread (python_current_script->interpreter); */
goto end;
}
if (argv && argv[0])
{
argc = strlen (format);
for (i = 0; i < 16; i++)
{
argv2[i] = (i < argc) ? argv[i] : NULL;
}
rc = PyObject_CallFunction (evFunc, format,
argv2[0], argv2[1],
argv2[2], argv2[3],
argv2[4], argv2[5],
argv2[6], argv2[7],
argv2[8], argv2[9],
argv2[10], argv2[11],
argv2[12], argv2[13],
argv2[14], argv2[15]);
}
else
{
rc = PyObject_CallFunction (evFunc, NULL);
}
/*
* ugly hack : rc = NULL while 'return weechat.WEECHAT_RC_OK ....
* because of '#define WEECHAT_RC_OK 0'
*/
if (rc == NULL)
rc = PyLong_FromLong ((long)0);
if (PyErr_Occurred())
{
PyErr_Print ();
Py_XDECREF(rc);
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_STRING) && (PyUnicode_Check (rc)))
{
ret_value = weechat_python_unicode_to_string (rc);
Py_XDECREF(rc);
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_STRING) && (PyBytes_Check (rc)))
{
if (PyBytes_AsString (rc))
ret_value = strdup (PyBytes_AsString (rc));
else
ret_value = NULL;
Py_XDECREF(rc);
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_INT) && (PY_INTEGER_CHECK(rc)))
{
ret_int = malloc (sizeof (*ret_int));
if (ret_int)
*ret_int = (int) PyLong_AsLong (rc);
ret_value = ret_int;
Py_XDECREF(rc);
}
else if (ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE)
{
ret_value = weechat_python_dict_to_hashtable (rc,
WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING);
Py_XDECREF(rc);
}
else
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"%s\" must return "
"a valid value"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function);
}
if (!ret_value)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: error in function \"%s\""),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function);
}
/* PyEval_ReleaseThread (python_current_script->interpreter); */
end:
python_current_script = old_python_current_script;
if (old_interpreter)
PyThreadState_Swap (old_interpreter);
return ret_value;
}
static PyObject *
io_open(PyObject *self, PyObject *args, PyObject *kwds)
{
char *kwlist[] = {"file", "mode", "buffering",
"encoding", "errors", "newline",
"closefd", NULL};
PyObject *file;
char *mode = "r";
int buffering = -1, closefd = 1;
char *encoding = NULL, *errors = NULL, *newline = NULL;
unsigned i;
int reading = 0, writing = 0, appending = 0, updating = 0;
int text = 0, binary = 0, universal = 0;
char rawmode[5], *m;
int line_buffering;
long isatty;
PyObject *raw, *modeobj = NULL, *buffer, *wrapper, *result = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|sizzzi:open", kwlist,
&file, &mode, &buffering,
&encoding, &errors, &newline,
&closefd)) {
return NULL;
}
if (!PyUnicode_Check(file) &&
!PyBytes_Check(file) &&
!PyNumber_Check(file)) {
PyObject *repr = PyObject_Repr(file);
if (repr != NULL) {
PyErr_Format(PyExc_TypeError, "invalid file: %s",
PyString_AS_STRING(repr));
Py_DECREF(repr);
}
return NULL;
}
/* Decode mode */
for (i = 0; i < strlen(mode); i++) {
char c = mode[i];
switch (c) {
case 'r':
reading = 1;
break;
case 'w':
writing = 1;
break;
case 'a':
appending = 1;
break;
case '+':
updating = 1;
break;
case 't':
text = 1;
break;
case 'b':
binary = 1;
break;
case 'U':
universal = 1;
reading = 1;
break;
default:
goto invalid_mode;
}
/* c must not be duplicated */
if (strchr(mode+i+1, c)) {
invalid_mode:
PyErr_Format(PyExc_ValueError, "invalid mode: '%s'", mode);
return NULL;
}
}
m = rawmode;
if (reading) *(m++) = 'r';
if (writing) *(m++) = 'w';
if (appending) *(m++) = 'a';
if (updating) *(m++) = '+';
*m = '\0';
/* Parameters validation */
if (universal) {
if (writing || appending) {
PyErr_SetString(PyExc_ValueError,
"can't use U and writing mode at once");
return NULL;
}
reading = 1;
}
if (text && binary) {
PyErr_SetString(PyExc_ValueError,
"can't have text and binary mode at once");
return NULL;
}
if (reading + writing + appending > 1) {
PyErr_SetString(PyExc_ValueError,
"must have exactly one of read/write/append mode");
return NULL;
}
if (binary && encoding != NULL) {
PyErr_SetString(PyExc_ValueError,
"binary mode doesn't take an encoding argument");
return NULL;
}
if (binary && errors != NULL) {
PyErr_SetString(PyExc_ValueError,
"binary mode doesn't take an errors argument");
return NULL;
}
if (binary && newline != NULL) {
PyErr_SetString(PyExc_ValueError,
"binary mode doesn't take a newline argument");
return NULL;
}
/* Create the Raw file stream */
raw = PyObject_CallFunction((PyObject *)&PyFileIO_Type,
"Osi", file, rawmode, closefd);
if (raw == NULL)
return NULL;
result = raw;
modeobj = PyUnicode_FromString(mode);
if (modeobj == NULL)
goto error;
/* buffering */
{
PyObject *res = PyObject_CallMethod(raw, "isatty", NULL);
if (res == NULL)
goto error;
isatty = PyLong_AsLong(res);
Py_DECREF(res);
if (isatty == -1 && PyErr_Occurred())
goto error;
}
if (buffering == 1 || (buffering < 0 && isatty)) {
buffering = -1;
line_buffering = 1;
}
else
line_buffering = 0;
if (buffering < 0) {
buffering = DEFAULT_BUFFER_SIZE;
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
{
struct stat st;
int fileno;
PyObject *res = PyObject_CallMethod(raw, "fileno", NULL);
if (res == NULL)
goto error;
fileno = _PyInt_AsInt(res);
Py_DECREF(res);
if (fileno == -1 && PyErr_Occurred())
goto error;
if (fstat(fileno, &st) >= 0 && st.st_blksize > 1)
buffering = st.st_blksize;
}
#endif
}
if (buffering < 0) {
PyErr_SetString(PyExc_ValueError,
"invalid buffering size");
goto error;
}
/* if not buffering, returns the raw file object */
if (buffering == 0) {
if (!binary) {
PyErr_SetString(PyExc_ValueError,
"can't have unbuffered text I/O");
goto error;
}
Py_DECREF(modeobj);
return result;
}
/* wraps into a buffered file */
{
PyObject *Buffered_class;
if (updating)
Buffered_class = (PyObject *)&PyBufferedRandom_Type;
else if (writing || appending)
Buffered_class = (PyObject *)&PyBufferedWriter_Type;
else if (reading)
Buffered_class = (PyObject *)&PyBufferedReader_Type;
else {
PyErr_Format(PyExc_ValueError,
"unknown mode: '%s'", mode);
goto error;
}
buffer = PyObject_CallFunction(Buffered_class, "Oi", raw, buffering);
}
if (buffer == NULL)
goto error;
result = buffer;
Py_DECREF(raw);
/* if binary, returns the buffered file */
if (binary) {
Py_DECREF(modeobj);
return result;
}
/* wraps into a TextIOWrapper */
wrapper = PyObject_CallFunction((PyObject *)&PyTextIOWrapper_Type,
"Osssi",
buffer,
encoding, errors, newline,
line_buffering);
if (wrapper == NULL)
goto error;
result = wrapper;
Py_DECREF(buffer);
if (PyObject_SetAttrString(wrapper, "mode", modeobj) < 0)
goto error;
Py_DECREF(modeobj);
return result;
error:
if (result != NULL) {
PyObject *exc, *val, *tb, *close_result;
PyErr_Fetch(&exc, &val, &tb);
close_result = PyObject_CallMethod(result, "close", NULL);
_PyErr_ReplaceException(exc, val, tb);
Py_XDECREF(close_result);
Py_DECREF(result);
}
Py_XDECREF(modeobj);
return NULL;
}
PyObject *Connection_query(Connection *self, PyObject *args)
{
void *ret;
PyObject *inQuery = NULL;
PyObject *query = NULL;
PyObject *iterable = NULL;
PyObject *escapedQuery = NULL;
if (!UMConnection_IsConnected(self->conn))
{
return PyErr_Format(PyExc_RuntimeError, "Not connected");
}
if (!PyArg_ParseTuple (args, "O|O", &inQuery, &iterable))
{
return NULL;
}
if (iterable)
{
PyObject *iterator = PyObject_GetIter(iterable);
if (iterator == NULL)
{
PyErr_Clear();
return PyErr_Format(PyExc_TypeError, "Expected iterable");
}
Py_DECREF(iterator);
}
if (!PyBytes_Check(inQuery))
{
if (!PyBytes_Check(inQuery))
{
PRINTMARK();
return PyErr_Format(PyExc_TypeError, "Query argument must be either String or Unicode");
}
query = self->PFN_PyUnicode_Encode(PyBytes_AS_STRING(inQuery), PyBytes_GET_SIZE(inQuery), NULL);
if (query == NULL)
{
if (!PyErr_Occurred())
{
PyErr_SetObject(PyExc_ValueError, query);
return NULL;
}
return NULL;
}
}
else
{
query = inQuery;
Py_INCREF(query);
}
if (iterable)
{
PRINTMARK();
escapedQuery = EscapeQueryArguments(self, query, iterable);
Py_DECREF(query);
if (escapedQuery == NULL)
{
if (!PyErr_Occurred())
{
return PyErr_Format(PyExc_RuntimeError, "Exception not set in EscapeQueryArguments chain");
}
return NULL;
}
}
else
{
escapedQuery = query;
}
ret = UMConnection_Query(self->conn, PyBytes_AS_STRING(escapedQuery), PyBytes_GET_SIZE(escapedQuery));
Py_DECREF(escapedQuery);
PRINTMARK();
if (ret == NULL)
{
return HandleError(self, "query");
}
PRINTMARK();
return (PyObject *) ret;
}
PyObject *_a85_encode(PyObject *module, PyObject *args)
{
unsigned char *inData;
int length, blocks, extra, i, k, lim;
unsigned long block, res;
char *buf;
PyObject *retVal=NULL, *inObj, *_o1=NULL;
if(!PyArg_ParseTuple(args, "O", &inObj)) return NULL;
if(PyUnicode_Check(inObj)){
_o1 = PyUnicode_AsLatin1String(inObj);
if(!_o1){
PyErr_SetString(PyExc_ValueError,"argument not decodable as latin1");
ERROR_EXIT();
}
inData = PyBytes_AsString(_o1);
inObj = _o1;
if(!inData){
PyErr_SetString(PyExc_ValueError,"argument not converted to internal char string");
ERROR_EXIT();
}
}
else if(!PyBytes_Check(inObj)){
PyErr_SetString(PyExc_ValueError,"argument should be " BYTESNAME " or latin1 decodable " STRNAME);
ERROR_EXIT();
}
inData = PyBytes_AsString(inObj);
length = PyBytes_GET_SIZE(inObj);
blocks = length / 4;
extra = length % 4;
buf = (char*)malloc((blocks+1)*5+3);
lim = 4*blocks;
for(k=i=0; i<lim; i += 4){
/*
* If you evere have trouble with this consider using masking to ensure
* that the shifted quantity is only 8 bits long
*/
block = ((unsigned long)inData[i]<<24)|((unsigned long)inData[i+1]<<16)
|((unsigned long)inData[i+2]<<8)|((unsigned long)inData[i+3]);
if (block == 0) buf[k++] = 'z';
else {
res = block/a85_4;
buf[k++] = (char)(res+33);
block -= res*a85_4;
res = block/a85_3;
buf[k++] = (char)(res+33);
block -= res*a85_3;
res = block/a85_2;
buf[k++] = (char)(res+33);
block -= res*a85_2;
res = block / a85_1;
buf[k++] = (char)(res+33);
buf[k++] = (char)(block-res*a85_1+33);
}
}
if(extra>0){
block = 0L;
for (i=0; i<extra; i++)
block += (unsigned long)inData[length-extra+i] << (24-8*i);
res = block/a85_4;
buf[k++] = (char)(res+33);
if(extra>=1){
block -= res*a85_4;
res = block/a85_3;
buf[k++] = (char)(res+33);
if(extra>=2){
block -= res*a85_3;
res = block/a85_2;
buf[k++] = (char)(res+33);
if(extra>=3) buf[k++] = (char)((block-res*a85_2)/a85_1+33);
}
}
}
buf[k++] = '~';
buf[k++] = '>';
retVal = PyUnicode_FromStringAndSize(buf, k);
free(buf);
if(!retVal){
PyErr_SetString(PyExc_ValueError,"failed to create return " STRNAME " value" );
ERROR_EXIT();
}
L_exit:
Py_XDECREF(_o1);
return retVal;
L_ERR:
ADD_TB(module,"asciiBase85Encode");
goto L_exit;
}
static PyObject *
_io__IOBase_readline_impl(PyObject *self, Py_ssize_t limit)
/*[clinic end generated code: output=4479f79b58187840 input=d0c596794e877bff]*/
{
/* For backwards compatibility, a (slowish) readline(). */
PyObject *peek, *buffer, *result;
Py_ssize_t old_size = -1;
if (_PyObject_LookupAttr(self, _PyIO_str_peek, &peek) < 0) {
return NULL;
}
buffer = PyByteArray_FromStringAndSize(NULL, 0);
if (buffer == NULL) {
Py_XDECREF(peek);
return NULL;
}
while (limit < 0 || PyByteArray_GET_SIZE(buffer) < limit) {
Py_ssize_t nreadahead = 1;
PyObject *b;
if (peek != NULL) {
PyObject *readahead = PyObject_CallFunctionObjArgs(peek, _PyLong_One, NULL);
if (readahead == NULL) {
/* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
when EINTR occurs so we needn't do it ourselves. */
if (_PyIO_trap_eintr()) {
continue;
}
goto fail;
}
if (!PyBytes_Check(readahead)) {
PyErr_Format(PyExc_OSError,
"peek() should have returned a bytes object, "
"not '%.200s'", Py_TYPE(readahead)->tp_name);
Py_DECREF(readahead);
goto fail;
}
if (PyBytes_GET_SIZE(readahead) > 0) {
Py_ssize_t n = 0;
const char *buf = PyBytes_AS_STRING(readahead);
if (limit >= 0) {
do {
if (n >= PyBytes_GET_SIZE(readahead) || n >= limit)
break;
if (buf[n++] == '\n')
break;
} while (1);
}
else {
do {
if (n >= PyBytes_GET_SIZE(readahead))
break;
if (buf[n++] == '\n')
break;
} while (1);
}
nreadahead = n;
}
Py_DECREF(readahead);
}
b = _PyObject_CallMethodId(self, &PyId_read, "n", nreadahead);
if (b == NULL) {
/* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals()
when EINTR occurs so we needn't do it ourselves. */
if (_PyIO_trap_eintr()) {
continue;
}
goto fail;
}
if (!PyBytes_Check(b)) {
PyErr_Format(PyExc_OSError,
"read() should have returned a bytes object, "
"not '%.200s'", Py_TYPE(b)->tp_name);
Py_DECREF(b);
goto fail;
}
if (PyBytes_GET_SIZE(b) == 0) {
Py_DECREF(b);
break;
}
old_size = PyByteArray_GET_SIZE(buffer);
if (PyByteArray_Resize(buffer, old_size + PyBytes_GET_SIZE(b)) < 0) {
Py_DECREF(b);
goto fail;
}
memcpy(PyByteArray_AS_STRING(buffer) + old_size,
PyBytes_AS_STRING(b), PyBytes_GET_SIZE(b));
Py_DECREF(b);
if (PyByteArray_AS_STRING(buffer)[PyByteArray_GET_SIZE(buffer) - 1] == '\n')
break;
}
result = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(buffer),
PyByteArray_GET_SIZE(buffer));
Py_XDECREF(peek);
Py_DECREF(buffer);
return result;
fail:
Py_XDECREF(peek);
Py_DECREF(buffer);
return NULL;
}
PyObject *EscapeQueryArguments(Connection *self, PyObject *inQuery, PyObject *iterable)
{
size_t cbOutQuery = 0;
char *obuffer;
char *optr;
char *iptr;
int heap = 0;
int hasArg = 0;
int appendLen;
PyObject *retobj;
PyObject *iterator;
PyObject *arg;
// Estimate output length
cbOutQuery += PyBytes_GET_SIZE(inQuery);
iterator = PyObject_GetIter(iterable);
while ( (arg = PyIter_Next(iterator)))
{
// Quotes;
cbOutQuery += 2;
// Worst case escape and utf-8
if (PyBytes_Check(arg))
cbOutQuery += (PyBytes_GET_SIZE(arg) * 2);
else
if (PyBytes_Check(arg))
cbOutQuery += (PyBytes_GET_SIZE(arg) * 6);
else
cbOutQuery += 64;
Py_DECREF(arg);
}
Py_DECREF(iterator);
if (cbOutQuery > (1024 * 64))
{
/*
FIXME: Allocate a PyString and resize it just like the Python code does it */
obuffer = (char *) PyObject_Malloc(cbOutQuery);
heap = 1;
}
else
{
obuffer = (char *) alloca (cbOutQuery);
}
optr = obuffer;
iptr = PyBytes_AS_STRING(inQuery);
hasArg = 0;
iterator = PyObject_GetIter(iterable);
while (1)
{
switch (*iptr)
{
case '\0':
goto END_PARSE;
case '%':
iptr ++;
if (*iptr != 's' && *iptr != '%')
{
Py_DECREF(iterator);
if (heap) PyObject_Free(obuffer);
return PyErr_Format (PyExc_ValueError, "Found character %c expected %%", *iptr);
}
if (*iptr == '%')
{
*(optr++) = *(iptr)++;
break;
}
iptr ++;
arg = PyIter_Next(iterator);
if (arg == NULL)
{
Py_DECREF(iterator);
if (heap) PyObject_Free(obuffer);
return PyErr_Format (PyExc_ValueError, "Unexpected end of iterator found");
}
appendLen = AppendEscapedArg(self, optr, obuffer + cbOutQuery, arg);
Py_DECREF(arg);
if (appendLen == -1)
{
Py_DECREF(iterator);
if (heap) PyObject_Free(obuffer);
return NULL;
}
optr += appendLen;
break;
default:
*(optr++) = *(iptr)++;
break;
}
}
END_PARSE:
Py_DECREF(iterator);
retobj = PyBytes_FromStringAndSize (obuffer, (optr - obuffer));
if (heap)
{
PyObject_Free(obuffer);
}
return retobj;
}
static PyObject *
pylzma_calculate_key(PyObject *self, PyObject *args, PyObject *kwargs)
{
char *password;
PARSE_LENGTH_TYPE pwlen;
int cycles;
PyObject *pysalt=NULL;
char *salt;
Py_ssize_t saltlen;
char *digest="sha256";
char key[32];
// possible keywords for this function
static char *kwlist[] = {"password", "cycles", "salt", "digest", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#i|Os", kwlist, &password, &pwlen, &cycles, &pysalt, &digest))
return NULL;
if (pysalt == Py_None) {
pysalt = NULL;
} else if (!PyBytes_Check(pysalt)) {
PyErr_Format(PyExc_TypeError, "salt must be a string, got a %s", pysalt->ob_type->tp_name);
return NULL;
}
if (strcmp(digest, "sha256") != 0) {
PyErr_Format(PyExc_TypeError, "digest %s is unsupported", digest);
return NULL;
}
if (pysalt != NULL) {
salt = PyBytes_AS_STRING(pysalt);
saltlen = PyBytes_Size(pysalt);
} else {
salt = NULL;
saltlen = 0;
}
if (cycles == 0x3f) {
int pos;
int i;
for (pos = 0; pos < saltlen; pos++)
key[pos] = salt[pos];
for (i = 0; i<pwlen && pos < 32; i++)
key[pos++] = password[i];
for (; pos < 32; pos++)
key[pos] = 0;
} else {
CSha256 sha;
long round;
int i;
long rounds = (long) 1 << cycles;
unsigned char temp[8] = { 0,0,0,0,0,0,0,0 };
Py_BEGIN_ALLOW_THREADS
Sha256_Init(&sha);
for (round = 0; round < rounds; round++) {
Sha256_Update(&sha, (Byte *) salt, saltlen);
Sha256_Update(&sha, (Byte *) password, pwlen);
Sha256_Update(&sha, (Byte *) temp, 8);
for (i = 0; i < 8; i++)
if (++(temp[i]) != 0)
break;
}
Sha256_Final(&sha, (Byte *) &key);
Py_END_ALLOW_THREADS
}
return PyBytes_FromStringAndSize(key, 32);
}
static PyObject *
arrayflags_getitem(PyArrayFlagsObject *self, PyObject *ind)
{
char *key = NULL;
char buf[16];
int n;
if (PyUnicode_Check(ind)) {
PyObject *tmp_str;
tmp_str = PyUnicode_AsASCIIString(ind);
if (tmp_str == NULL) {
return NULL;
}
key = PyBytes_AS_STRING(tmp_str);
n = PyBytes_GET_SIZE(tmp_str);
if (n > 16) {
Py_DECREF(tmp_str);
goto fail;
}
memcpy(buf, key, n);
Py_DECREF(tmp_str);
key = buf;
}
else if (PyBytes_Check(ind)) {
key = PyBytes_AS_STRING(ind);
n = PyBytes_GET_SIZE(ind);
}
else {
goto fail;
}
switch(n) {
case 1:
switch(key[0]) {
case 'C':
return arrayflags_contiguous_get(self);
case 'F':
return arrayflags_fortran_get(self);
case 'W':
return arrayflags_writeable_get(self);
case 'B':
return arrayflags_behaved_get(self);
case 'O':
return arrayflags_owndata_get(self);
case 'A':
return arrayflags_aligned_get(self);
case 'U':
return arrayflags_updateifcopy_get(self);
default:
goto fail;
}
break;
case 2:
if (strncmp(key, "CA", n) == 0) {
return arrayflags_carray_get(self);
}
if (strncmp(key, "FA", n) == 0) {
return arrayflags_farray_get(self);
}
break;
case 3:
if (strncmp(key, "FNC", n) == 0) {
return arrayflags_fnc_get(self);
}
break;
case 4:
if (strncmp(key, "FORC", n) == 0) {
return arrayflags_forc_get(self);
}
break;
case 6:
if (strncmp(key, "CARRAY", n) == 0) {
return arrayflags_carray_get(self);
}
if (strncmp(key, "FARRAY", n) == 0) {
return arrayflags_farray_get(self);
}
if (strncmp(key, "MASKNA", n) == 0) {
return arrayflags_maskna_get(self);
}
break;
case 7:
if (strncmp(key,"FORTRAN",n) == 0) {
return arrayflags_fortran_get(self);
}
if (strncmp(key,"BEHAVED",n) == 0) {
return arrayflags_behaved_get(self);
}
if (strncmp(key,"OWNDATA",n) == 0) {
return arrayflags_owndata_get(self);
}
if (strncmp(key,"ALIGNED",n) == 0) {
return arrayflags_aligned_get(self);
}
break;
case 9:
if (strncmp(key,"WRITEABLE",n) == 0) {
return arrayflags_writeable_get(self);
}
if (strncmp(key, "OWNMASKNA", n) == 0) {
return arrayflags_ownmaskna_get(self);
}
break;
case 10:
if (strncmp(key,"CONTIGUOUS",n) == 0) {
return arrayflags_contiguous_get(self);
}
break;
case 12:
if (strncmp(key, "UPDATEIFCOPY", n) == 0) {
return arrayflags_updateifcopy_get(self);
}
if (strncmp(key, "C_CONTIGUOUS", n) == 0) {
return arrayflags_contiguous_get(self);
}
if (strncmp(key, "F_CONTIGUOUS", n) == 0) {
return arrayflags_fortran_get(self);
}
break;
}
fail:
PyErr_SetString(PyExc_KeyError, "Unknown flag");
return NULL;
}
/****************************
* SV* Py2Pl(PyObject *obj)
*
* Converts arbitrary Python data structures to Perl data structures
* Note on references: does not Py_DECREF(obj).
*
* Modifications by Eric Wilhelm 2004-07-11 marked as elw
*
****************************/
SV *Py2Pl(PyObject * const obj) {
/* elw: see what python says things are */
#if PY_MAJOR_VERSION >= 3
int const is_string = PyBytes_Check(obj) || PyUnicode_Check(obj);
#else
int const is_string = PyString_Check(obj) || PyUnicode_Check(obj);
#endif
#ifdef I_PY_DEBUG
PyObject *this_type = PyObject_Type(obj); /* new reference */
PyObject *t_string = PyObject_Str(this_type); /* new reference */
#if PY_MAJOR_VERSION >= 3
PyObject *type_str_bytes = PyUnicode_AsUTF8String(t_string); /* new reference */
char *type_str = PyBytes_AsString(type_str_bytes);
#else
char *type_str = PyString_AsString(t_string);
#endif
Printf(("type is %s\n", type_str));
printf("Py2Pl object:\n\t");
PyObject_Print(obj, stdout, Py_PRINT_RAW);
printf("\ntype:\n\t");
PyObject_Print(this_type, stdout, Py_PRINT_RAW);
printf("\n");
Printf(("String check: %i\n", is_string));
Printf(("Number check: %i\n", PyNumber_Check(obj)));
Printf(("Int check: %i\n", PyInt_Check(obj)));
Printf(("Long check: %i\n", PyLong_Check(obj)));
Printf(("Float check: %i\n", PyFloat_Check(obj)));
Printf(("Type check: %i\n", PyType_Check(obj)));
#if PY_MAJOR_VERSION < 3
Printf(("Class check: %i\n", PyClass_Check(obj)));
Printf(("Instance check: %i\n", PyInstance_Check(obj)));
#endif
Printf(("Dict check: %i\n", PyDict_Check(obj)));
Printf(("Mapping check: %i\n", PyMapping_Check(obj)));
Printf(("Sequence check: %i\n", PySequence_Check(obj)));
Printf(("Iter check: %i\n", PyIter_Check(obj)));
Printf(("Function check: %i\n", PyFunction_Check(obj)));
Printf(("Module check: %i\n", PyModule_Check(obj)));
Printf(("Method check: %i\n", PyMethod_Check(obj)));
#if PY_MAJOR_VERSION < 3
if ((obj->ob_type->tp_flags & Py_TPFLAGS_HEAPTYPE))
printf("heaptype true\n");
if ((obj->ob_type->tp_flags & Py_TPFLAGS_HAVE_CLASS))
printf("has class\n");
#else
Py_DECREF(type_str_bytes);
#endif
Py_DECREF(t_string);
Py_DECREF(this_type);
#endif
/* elw: this needs to be early */
/* None (like undef) */
if (!obj || obj == Py_None) {
Printf(("Py2Pl: Py_None\n"));
return &PL_sv_undef;
}
else
#ifdef EXPOSE_PERL
/* unwrap Perl objects */
if (PerlObjObject_Check(obj)) {
Printf(("Py2Pl: Obj_object\n"));
return ((PerlObj_object *) obj)->obj;
}
/* unwrap Perl code refs */
else if (PerlSubObject_Check(obj)) {
Printf(("Py2Pl: Sub_object\n"));
SV * ref = ((PerlSub_object *) obj)->ref;
if (! ref) { /* probably an inherited method */
if (! ((PerlSub_object *) obj)->obj)
croak("Error: could not find a code reference or object method for PerlSub");
SV * const sub_obj = (SV*)SvRV(((PerlSub_object *) obj)->obj);
HV * const pkg = SvSTASH(sub_obj);
#if PY_MAJOR_VERSION >= 3
char * const sub = PyBytes_AsString(((PerlSub_object *) obj)->sub);
#else
PyObject *obj_sub_str = PyObject_Str(((PerlSub_object *) obj)->sub); /* new ref. */
char * const sub = PyString_AsString(obj_sub_str);
#endif
GV * const gv = Perl_gv_fetchmethod_autoload(aTHX_ pkg, sub, TRUE);
if (gv && isGV(gv)) {
ref = (SV *)GvCV(gv);
}
#if PY_MAJOR_VERSION < 3
Py_DECREF(obj_sub_str);
#endif
}
return newRV_inc((SV *) ref);
}
else
#endif
/* wrap an instance of a Python class */
/* elw: here we need to make these look like instances: */
if ((obj->ob_type->tp_flags & Py_TPFLAGS_HEAPTYPE)
#if PY_MAJOR_VERSION < 3
|| PyInstance_Check(obj)
#endif
) {
/* This is a Python class instance -- bless it into an
* Inline::Python::Object. If we're being called from an
* Inline::Python class, it will be re-blessed into whatever
* class that is.
*/
SV * const inst_ptr = newSViv(0);
SV * const inst = newSVrv(inst_ptr, "Inline::Python::Object");;
_inline_magic priv;
/* set up magic */
priv.key = INLINE_MAGIC_KEY;
sv_magic(inst, inst, PERL_MAGIC_ext, (char *) &priv, sizeof(priv));
MAGIC * const mg = mg_find(inst, PERL_MAGIC_ext);
mg->mg_virtual = &inline_mg_vtbl;
sv_setiv(inst, (IV) obj);
/*SvREADONLY_on(inst); */ /* to uncomment this means I can't
re-bless it */
Py_INCREF(obj);
Printf(("Py2Pl: Instance. Obj: %p, inst_ptr: %p\n", obj, inst_ptr));
sv_2mortal(inst_ptr);
return inst_ptr;
}
/* a tuple or a list */
else if (PySequence_Check(obj) && !is_string) {
AV * const retval = newAV();
int i;
int const sz = PySequence_Length(obj);
Printf(("sequence (%i)\n", sz));
for (i = 0; i < sz; i++) {
PyObject * const tmp = PySequence_GetItem(obj, i); /* new reference */
SV * const next = Py2Pl(tmp);
av_push(retval, next);
if (sv_isobject(next)) // needed because objects get mortalized in Py2Pl
SvREFCNT_inc(next);
Py_DECREF(tmp);
}
if (PyTuple_Check(obj)) {
_inline_magic priv;
priv.key = TUPLE_MAGIC_KEY;
sv_magic((SV * const)retval, (SV * const)NULL, PERL_MAGIC_ext, (char *) &priv, sizeof(priv));
}
return newRV_noinc((SV *) retval);
}
/* a dictionary or fake Mapping object */
/* elw: PyMapping_Check() now returns true for strings */
else if (! is_string && PyMapping_Check(obj)) {
HV * const retval = newHV();
int i;
int const sz = PyMapping_Length(obj);
PyObject * const keys = PyMapping_Keys(obj); /* new reference */
PyObject * const vals = PyMapping_Values(obj); /* new reference */
Printf(("Py2Pl: dict/map\n"));
Printf(("mapping (%i)\n", sz));
for (i = 0; i < sz; i++) {
PyObject * const key = PySequence_GetItem(keys, i), /* new reference */
* const val = PySequence_GetItem(vals, i); /* new reference */
SV * const sv_val = Py2Pl(val);
char * key_val;
if (PyUnicode_Check(key)) {
PyObject * const utf8_string = PyUnicode_AsUTF8String(key); /* new reference */
#if PY_MAJOR_VERSION >= 3
key_val = PyBytes_AsString(utf8_string);
SV * const utf8_key = newSVpv(key_val, PyBytes_Size(utf8_string));
#else
key_val = PyString_AsString(utf8_string);
SV * const utf8_key = newSVpv(key_val, PyString_Size(utf8_string));
#endif
SvUTF8_on(utf8_key);
hv_store_ent(retval, utf8_key, sv_val, 0);
Py_DECREF(utf8_string);
}
else {
PyObject * s = NULL;
#if PY_MAJOR_VERSION >= 3
PyObject * s_bytes = NULL;
if (PyBytes_Check(key)) {
key_val = PyBytes_AsString(key);
#else
if (PyString_Check(key)) {
key_val = PyString_AsString(key);
#endif
}
else {
/* Warning -- encountered a non-string key value while converting a
* Python dictionary into a Perl hash. Perl can only use strings as
* key values. Using Python's string representation of the key as
* Perl's key value.
*/
s = PyObject_Str(key); /* new reference */
#if PY_MAJOR_VERSION >= 3
s_bytes = PyUnicode_AsUTF8String(s); /* new reference */
key_val = PyBytes_AsString(s_bytes);
#else
key_val = PyString_AsString(s);
#endif
Py_DECREF(s);
if (PL_dowarn)
warn("Stringifying non-string hash key value: '%s'",
key_val);
}
if (!key_val) {
croak("Invalid key on key %i of mapping\n", i);
}
hv_store(retval, key_val, strlen(key_val), sv_val, 0);
#if PY_MAJOR_VERSION >= 3
Py_XDECREF(s_bytes);
#endif
Py_XDECREF(s);
}
if (sv_isobject(sv_val)) // needed because objects get mortalized in Py2Pl
SvREFCNT_inc(sv_val);
Py_DECREF(key);
Py_DECREF(val);
}
Py_DECREF(keys);
Py_DECREF(vals);
return newRV_noinc((SV *) retval);
}
/* a boolean */
else if (PyBool_Check(obj)) {
static PyObject *
pyhashxx_hashxx(PyObject* self, PyObject *args, PyObject *kwds)
{
unsigned int seed = 0;
const char* err_msg = NULL;
PyObject* err_obj = NULL;
Py_ssize_t args_len = 0;
unsigned int digest = 0;
void* state = NULL;
if (kwds != NULL) {
Py_ssize_t kwds_size = PyDict_Size(kwds);
PyObject* seed_obj = PyDict_GetItemString(kwds, "seed");
if (kwds_size > 1) {
err_msg = "Unexpected keyword arguments, only 'seed' is supported.";
goto badarg;
}
if (kwds_size == 1) {
if (seed_obj == NULL) {
err_msg = "Unexpected keyword argument, only 'seed' is supported.";
goto badarg;
}
#if PY_MAJOR_VERSION < 3
if (PyInt_Check(seed_obj))
seed = PyInt_AsLong(seed_obj);
else
#endif
if (PyLong_Check(seed_obj))
seed = PyLong_AsLong(seed_obj);
else {
err_msg = "Unexpected seed value type: %S";
err_obj = seed_obj;
goto badseed;
}
}
}
args_len = PyTuple_GET_SIZE(args);
if (args_len == 0) {
err_msg = "Received no arguments to be hashed.";
goto badarg;
}
// If possible, use the shorter, faster version that elides
// allocating the state variable because it knows there is only
// one input.
if (args_len == 1) {
PyObject* hash_obj = PyTuple_GetItem(args, 0);
int did_hash = 1;
#if PY_MAJOR_VERSION >= 3
if (PyBytes_Check(hash_obj)) {
digest = XXH32(PyBytes_AsString(hash_obj), PyBytes_Size(hash_obj), seed);
}
#else
if (PyString_Check(hash_obj)) {
digest = XXH32(PyString_AsString(hash_obj), PyString_Size(hash_obj), seed);
}
#endif
else if (PyByteArray_Check(hash_obj)) {
digest = XXH32(PyByteArray_AsString(hash_obj), PyByteArray_Size(hash_obj), seed);
}
else if (hash_obj == Py_None) {
// Nothing to hash
digest = XXH32("", 0, seed);
}
else {
did_hash = 0;
}
if (did_hash)
return Py_BuildValue("I", digest);
}
// Otherwise, do it the long, slower way
state = XXH32_init(seed);
if (_update_hash(state, args) == NULL) {
XXH32_destroy(state);
return NULL;
}
digest = XXH32_digest(state);
XXH32_destroy(state);
return Py_BuildValue("I", digest);
badarg:
PyErr_SetString(PyExc_TypeError, err_msg);
return NULL;
badseed:
PyErr_Format(PyExc_TypeError, err_msg, Py_TYPE(err_obj));
return NULL;
}
PyObject *_a85_decode(PyObject *module, PyObject *args)
{
unsigned char *inData, *p, *q, *tmp, *buf;
unsigned int length, blocks, extra, k, num, c1, c2, c3, c4, c5;
static unsigned pad[] = {0,0,0xffffff,0xffff,0xff};
PyObject *retVal=NULL, *inObj, *_o1=NULL;
if(!PyArg_ParseTuple(args, "O", &inObj)) return NULL;
if(PyUnicode_Check(inObj)){
_o1 = PyUnicode_AsLatin1String(inObj);
if(!_o1){
PyErr_SetString(PyExc_ValueError,"argument not decodable as latin1");
ERROR_EXIT();
}
inData = PyBytes_AsString(_o1);
inObj = _o1;
if(!inData){
PyErr_SetString(PyExc_ValueError,"argument not converted to internal char string");
ERROR_EXIT();
}
}
else if(!PyBytes_Check(inObj)){
PyErr_SetString(PyExc_ValueError,"argument should be " BYTESNAME " or latin1 decodable " STRNAME);
ERROR_EXIT();
}
inData = PyBytes_AsString(inObj);
length = PyBytes_GET_SIZE(inObj);
for(k=0,q=inData, p=q+length;q<p && (q=(unsigned char*)strchr((const char*)q,'z'));k++, q++); /*count 'z'*/
length += k*4;
tmp = q = (unsigned char*)malloc(length+1);
while(inData<p && (k = *inData++)){
if(isspace(k)) continue;
if(k=='z'){
/*turn 'z' into '!!!!!'*/
memcpy(q,"!!!!!",5);
q += 5;
}
else
*q++ = k;
}
inData = tmp;
length = q - inData;
buf = inData+length-2;
if(buf[0]!='~' || buf[1]!='>'){
PyErr_SetString(PyExc_ValueError, "Invalid terminator for Ascii Base 85 Stream");
free(inData);
ERROR_EXIT();
}
length -= 2;
buf[0] = 0;
blocks = length / 5;
extra = length % 5;
buf = (unsigned char*)malloc((blocks+1)*4);
q = inData+blocks*5;
for(k=0;inData<q;inData+=5){
c1 = inData[0]-33;
c2 = inData[1]-33;
c3 = inData[2]-33;
c4 = inData[3]-33;
c5 = inData[4]-33;
num = (((c1*85+c2)*85+c3)*85+c4)*85+c5;
buf[k++] = num>>24;
buf[k++] = num>>16;
buf[k++] = num>>8;
buf[k++] = num;
}
if(extra>1){
c1 = inData[0]-33;
c2 = extra>=2 ? inData[1]-33: 0;
c3 = extra>=3 ? inData[2]-33: 0;
c4 = extra>=4 ? inData[3]-33: 0;
c5 = 0;
num = (((c1*85+c2)*85+c3)*85+c4)*85+c5 + pad[extra];
if(extra>1){
buf[k++] = num>>24;
if(extra>2){
buf[k++] = num>>16;
if(extra>3){
buf[k++] = num>>8;
}
struct t_hashtable *
weechat_python_dict_to_hashtable (PyObject *dict, int size,
const char *type_keys,
const char *type_values)
{
struct t_hashtable *hashtable;
PyObject *key, *value;
Py_ssize_t pos;
char *str_key, *str_value;
hashtable = weechat_hashtable_new (size, type_keys, type_values,
NULL, NULL);
if (!hashtable)
return NULL;
pos = 0;
while (PyDict_Next (dict, &pos, &key, &value))
{
str_key = NULL;
str_value = NULL;
if (PyBytes_Check (key))
{
if (PyBytes_AsString (key))
str_key = strdup (PyBytes_AsString (key));
}
else
{
str_key = weechat_python_unicode_to_string (key);
}
if (PyBytes_Check (value))
{
if (PyBytes_AsString (value))
str_value = strdup (PyBytes_AsString (value));
}
else
{
str_value = weechat_python_unicode_to_string (value);
}
if (str_key)
{
if (strcmp (type_values, WEECHAT_HASHTABLE_STRING) == 0)
{
weechat_hashtable_set (hashtable, str_key, str_value);
}
else if (strcmp (type_values, WEECHAT_HASHTABLE_POINTER) == 0)
{
weechat_hashtable_set (hashtable, str_key,
plugin_script_str2ptr (weechat_python_plugin,
NULL, NULL,
str_value));
}
}
if (str_key)
free (str_key);
if (str_value)
free (str_value);
}
return hashtable;
}
static void
ghostify(cPersistentObject *self)
{
PyObject **dictptr, *slotnames;
/* are we already a ghost? */
if (self->state == cPersistent_GHOST_STATE)
return;
/* Is it ever possible to not have a cache? */
if (self->cache == NULL)
{
self->state = cPersistent_GHOST_STATE;
return;
}
if (self->ring.r_next == NULL)
{
/* There's no way to raise an error in this routine. */
#ifdef Py_DEBUG
fatal_1350(self, "ghostify", "claims to be in a cache but isn't");
#else
return;
#endif
}
/* If we're ghostifying an object, we better have some non-ghosts. */
assert(self->cache->non_ghost_count > 0);
self->cache->non_ghost_count--;
self->cache->total_estimated_size -=
_estimated_size_in_bytes(self->estimated_size);
ring_del(&self->ring);
self->state = cPersistent_GHOST_STATE;
/* clear __dict__ */
dictptr = _PyObject_GetDictPtr((PyObject *)self);
if (dictptr && *dictptr)
{
Py_DECREF(*dictptr);
*dictptr = NULL;
}
/* clear all slots besides _p_*
* ( for backward-compatibility reason we do this only if class does not
* override __new__ ) */
if (Py_TYPE(self)->tp_new == Pertype.tp_new)
{
slotnames = pickle_slotnames(Py_TYPE(self));
if (slotnames && slotnames != Py_None)
{
int i;
for (i = 0; i < PyList_GET_SIZE(slotnames); i++)
{
PyObject *name;
char *cname;
int is_special;
name = PyList_GET_ITEM(slotnames, i);
#ifdef PY3K
if (PyUnicode_Check(name))
{
PyObject *converted = convert_name(name);
cname = PyBytes_AS_STRING(converted);
#else
if (PyBytes_Check(name))
{
cname = PyBytes_AS_STRING(name);
#endif
is_special = !strncmp(cname, "_p_", 3);
#ifdef PY3K
Py_DECREF(converted);
#endif
if (is_special) /* skip persistent */
{
continue;
}
}
/* NOTE: this skips our delattr hook */
if (PyObject_GenericSetAttr((PyObject *)self, name, NULL) < 0)
/* delattr of non-set slot will raise AttributeError - we
* simply ignore. */
PyErr_Clear();
}
}
Py_XDECREF(slotnames);
}
/* We remove the reference to the just ghosted object that the ring
* holds. Note that the dictionary of oids->objects has an uncounted
* reference, so if the ring's reference was the only one, this frees
* the ghost object. Note further that the object's dealloc knows to
* inform the dictionary that it is going away.
*/
Py_DECREF(self);
}
static int
changed(cPersistentObject *self)
{
if ((self->state == cPersistent_UPTODATE_STATE ||
self->state == cPersistent_STICKY_STATE)
&& self->jar)
{
PyObject *meth, *arg, *result;
static PyObject *s_register;
if (s_register == NULL)
s_register = INTERN("register");
meth = PyObject_GetAttr((PyObject *)self->jar, s_register);
if (meth == NULL)
return -1;
arg = PyTuple_New(1);
if (arg == NULL)
{
Py_DECREF(meth);
return -1;
}
Py_INCREF(self);
PyTuple_SET_ITEM(arg, 0, (PyObject *)self);
result = PyEval_CallObject(meth, arg);
Py_DECREF(arg);
Py_DECREF(meth);
if (result == NULL)
return -1;
Py_DECREF(result);
self->state = cPersistent_CHANGED_STATE;
}
return 0;
}
static int
readCurrent(cPersistentObject *self)
{
if ((self->state == cPersistent_UPTODATE_STATE ||
self->state == cPersistent_STICKY_STATE)
&& self->jar && self->oid)
{
static PyObject *s_readCurrent=NULL;
PyObject *r;
if (s_readCurrent == NULL)
s_readCurrent = INTERN("readCurrent");
r = PyObject_CallMethodObjArgs(self->jar, s_readCurrent, self, NULL);
if (r == NULL)
return -1;
Py_DECREF(r);
}
return 0;
}
static PyObject *
Per__p_deactivate(cPersistentObject *self)
{
if (self->state == cPersistent_UPTODATE_STATE && self->jar)
{
PyObject **dictptr = _PyObject_GetDictPtr((PyObject *)self);
if (dictptr && *dictptr)
{
Py_DECREF(*dictptr);
*dictptr = NULL;
}
/* Note that we need to set to ghost state unless we are
called directly. Methods that override this need to
do the same! */
ghostify(self);
if (PyErr_Occurred())
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
Per__p_activate(cPersistentObject *self)
{
if (unghostify(self) < 0)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static int Per_set_changed(cPersistentObject *self, PyObject *v);
static PyObject *
Per__p_invalidate(cPersistentObject *self)
{
signed char old_state = self->state;
if (old_state != cPersistent_GHOST_STATE)
{
if (Per_set_changed(self, NULL) < 0)
return NULL;
ghostify(self);
if (PyErr_Occurred())
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
iobase_readline(PyObject *self, PyObject *args)
{
/* For backwards compatibility, a (slowish) readline(). */
Py_ssize_t limit = -1;
int has_peek = 0;
PyObject *buffer, *result;
Py_ssize_t old_size = -1;
if (!PyArg_ParseTuple(args, "|O&:readline", &_PyIO_ConvertSsize_t, &limit)) {
return NULL;
}
if (PyObject_HasAttrString(self, "peek"))
has_peek = 1;
buffer = PyByteArray_FromStringAndSize(NULL, 0);
if (buffer == NULL)
return NULL;
while (limit < 0 || Py_SIZE(buffer) < limit) {
Py_ssize_t nreadahead = 1;
PyObject *b;
if (has_peek) {
PyObject *readahead = PyObject_CallMethod(self, "peek", "i", 1);
if (readahead == NULL)
goto fail;
if (!PyBytes_Check(readahead)) {
PyErr_Format(PyExc_IOError,
"peek() should have returned a bytes object, "
"not '%.200s'", Py_TYPE(readahead)->tp_name);
Py_DECREF(readahead);
goto fail;
}
if (PyBytes_GET_SIZE(readahead) > 0) {
Py_ssize_t n = 0;
const char *buf = PyBytes_AS_STRING(readahead);
if (limit >= 0) {
do {
if (n >= PyBytes_GET_SIZE(readahead) || n >= limit)
break;
if (buf[n++] == '\n')
break;
} while (1);
}
else {
do {
if (n >= PyBytes_GET_SIZE(readahead))
break;
if (buf[n++] == '\n')
break;
} while (1);
}
nreadahead = n;
}
Py_DECREF(readahead);
}
b = PyObject_CallMethod(self, "read", "n", nreadahead);
if (b == NULL)
goto fail;
if (!PyBytes_Check(b)) {
PyErr_Format(PyExc_IOError,
"read() should have returned a bytes object, "
"not '%.200s'", Py_TYPE(b)->tp_name);
Py_DECREF(b);
goto fail;
}
if (PyBytes_GET_SIZE(b) == 0) {
Py_DECREF(b);
break;
}
old_size = PyByteArray_GET_SIZE(buffer);
PyByteArray_Resize(buffer, old_size + PyBytes_GET_SIZE(b));
memcpy(PyByteArray_AS_STRING(buffer) + old_size,
PyBytes_AS_STRING(b), PyBytes_GET_SIZE(b));
Py_DECREF(b);
if (PyByteArray_AS_STRING(buffer)[PyByteArray_GET_SIZE(buffer) - 1] == '\n')
break;
}
result = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(buffer),
PyByteArray_GET_SIZE(buffer));
Py_DECREF(buffer);
return result;
fail:
Py_DECREF(buffer);
return NULL;
}
static PyObject *
pickle_copy_dict(PyObject *state)
{
PyObject *copy, *key, *value;
char *ckey;
Py_ssize_t pos = 0;
copy = PyDict_New();
if (!copy)
return NULL;
if (!state)
return copy;
while (PyDict_Next(state, &pos, &key, &value))
{
int is_special;
#ifdef PY3K
if (key && PyUnicode_Check(key))
{
PyObject *converted = convert_name(key);
ckey = PyBytes_AS_STRING(converted);
#else
if (key && PyBytes_Check(key))
{
ckey = PyBytes_AS_STRING(key);
#endif
is_special = (*ckey == '_' &&
(ckey[1] == 'v' || ckey[1] == 'p') &&
ckey[2] == '_');
#ifdef PY3K
Py_DECREF(converted);
#endif
if (is_special) /* skip volatile and persistent */
continue;
}
if (PyObject_SetItem(copy, key, value) < 0)
goto err;
}
return copy;
err:
Py_DECREF(copy);
return NULL;
}
static char pickle___getstate__doc[] =
"Get the object serialization state\n"
"\n"
"If the object has no assigned slots and has no instance dictionary, then \n"
"None is returned.\n"
"\n"
"If the object has no assigned slots and has an instance dictionary, then \n"
"the a copy of the instance dictionary is returned. The copy has any items \n"
"with names starting with '_v_' or '_p_' ommitted.\n"
"\n"
"If the object has assigned slots, then a two-element tuple is returned. \n"
"The first element is either None or a copy of the instance dictionary, \n"
"as described above. The second element is a dictionary with items \n"
"for each of the assigned slots.\n"
;
static PyObject *
pickle___getstate__(PyObject *self)
{
PyObject *slotnames=NULL, *slots=NULL, *state=NULL;
PyObject **dictp;
int n=0;
slotnames = pickle_slotnames(Py_TYPE(self));
if (!slotnames)
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)
goto end;
for (i = 0; i < PyList_GET_SIZE(slotnames); i++)
{
PyObject *name, *value;
char *cname;
int is_special;
name = PyList_GET_ITEM(slotnames, i);
#ifdef PY3K
if (PyUnicode_Check(name))
{
PyObject *converted = convert_name(name);
cname = PyBytes_AS_STRING(converted);
#else
if (PyBytes_Check(name))
{
cname = PyBytes_AS_STRING(name);
#endif
is_special = (*cname == '_' &&
(cname[1] == 'v' || cname[1] == 'p') &&
cname[2] == '_');
#ifdef PY3K
Py_DECREF(converted);
#endif
if (is_special) /* skip volatile and persistent */
{
continue;
}
}
/* Unclear: Will this go through our getattr hook? */
value = PyObject_GetAttr(self, name);
if (value == NULL)
PyErr_Clear();
else
{
int err = PyDict_SetItem(slots, name, value);
Py_DECREF(value);
if (err < 0)
goto end;
n++;
}
}
}
if (n)
state = Py_BuildValue("(NO)", state, slots);
end:
Py_XDECREF(slotnames);
Py_XDECREF(slots);
return state;
}
static int
pickle_setattrs_from_dict(PyObject *self, PyObject *dict)
{
PyObject *key, *value;
Py_ssize_t pos = 0;
if (!PyDict_Check(dict))
{
PyErr_SetString(PyExc_TypeError, "Expected dictionary");
return -1;
}
while (PyDict_Next(dict, &pos, &key, &value))
{
if (PyObject_SetAttr(self, key, value) < 0)
return -1;
}
return 0;
}
PyObject *
session_connect(PyObject *self, PyObject *args)
{
sp_session_config config;
PyObject *client;
sp_session *session;
sp_error error;
char *username, *password;
char *cache_location, *settings_location, *user_agent;
if (!PyArg_ParseTuple(args, "O", &client))
return NULL;
PyEval_InitThreads();
memset(&config, 0, sizeof(config));
config.api_version = SPOTIFY_API_VERSION;
config.userdata = (void *)client;
config.callbacks = &g_callbacks;
cache_location = PySpotify_GetConfigString(client, "cache_location");
if (!cache_location)
return NULL;
config.cache_location = cache_location;
#ifdef DEBUG
fprintf(stderr, "[DEBUG]-session- Cache location is '%s'\n",
cache_location);
#endif
settings_location = PySpotify_GetConfigString(client, "settings_location");
config.settings_location = settings_location;
#ifdef DEBUG
fprintf(stderr, "[DEBUG]-session- Settings location is '%s'\n",
settings_location);
#endif
PyObject *application_key =
PyObject_GetAttr(client, PyBytes_FromString("application_key"));
if (!application_key) {
PyErr_SetString(SpotifyError,
"application_key not set");
return NULL;
}
else if (!PyBytes_Check(application_key)) {
PyErr_SetString(SpotifyError,
"application_key must be a byte string");
return NULL;
}
char *s_appkey;
Py_ssize_t l_appkey;
PyBytes_AsStringAndSize(application_key, &s_appkey, &l_appkey);
config.application_key_size = l_appkey;
config.application_key = PyMem_Malloc(l_appkey);
memcpy((char *)config.application_key, s_appkey, l_appkey);
user_agent = PySpotify_GetConfigString(client, "user_agent");
if (!user_agent)
return NULL;
if (strlen(user_agent) > 255) {
PyErr_SetString(SpotifyError, "user agent must be 255 characters max");
}
config.user_agent = user_agent;
#ifdef DEBUG
fprintf(stderr, "[DEBUG]-session- User agent set to '%s'\n",
user_agent);
#endif
username = PySpotify_GetConfigString(client, "username");
if (!username)
return NULL;
password = PySpotify_GetConfigString(client, "password");
if (!password)
return NULL;
Py_BEGIN_ALLOW_THREADS;
#ifdef DEBUG
fprintf(stderr, "[DEBUG]-session- creating session...\n");
#endif
error = sp_session_create(&config, &session);
Py_END_ALLOW_THREADS;
if (error != SP_ERROR_OK) {
PyErr_SetString(SpotifyError, sp_error_message(error));
return NULL;
}
session_constructed = 1;
#ifdef DEBUG
fprintf(stderr, "[DEBUG]-session- login as %s in progress...\n",
username);
#endif
Py_BEGIN_ALLOW_THREADS;
sp_session_login(session, username, password);
Py_END_ALLOW_THREADS;
g_session = session;
Session *psession =
(Session *) PyObject_CallObject((PyObject *)&SessionType, NULL);
psession->_session = session;
return (PyObject *)psession;
}
PyObject*
PyImaging_LibTiffEncoderNew(PyObject* self, PyObject* args)
{
ImagingEncoderObject* encoder;
char* mode;
char* rawmode;
char* compname;
char* filename;
int fp;
PyObject *dir;
PyObject *key, *value;
Py_ssize_t pos = 0;
int status;
Py_ssize_t d_size;
PyObject *keys, *values;
if (! PyArg_ParseTuple(args, "sssisO", &mode, &rawmode, &compname, &fp, &filename, &dir)) {
return NULL;
}
if (!PyDict_Check(dir)) {
PyErr_SetString(PyExc_ValueError, "Invalid Dictionary");
return NULL;
} else {
d_size = PyDict_Size(dir);
TRACE(("dict size: %d\n", (int)d_size));
keys = PyDict_Keys(dir);
values = PyDict_Values(dir);
for (pos=0;pos<d_size;pos++){
TRACE((" key: %d\n", (int)PyInt_AsLong(PyList_GetItem(keys,pos))));
}
pos = 0;
}
TRACE(("new tiff encoder %s fp: %d, filename: %s \n", compname, fp, filename));
encoder = PyImaging_EncoderNew(sizeof(TIFFSTATE));
if (encoder == NULL)
return NULL;
if (get_packer(encoder, mode, rawmode) < 0)
return NULL;
if (! ImagingLibTiffEncodeInit(&encoder->state, filename, fp)) {
Py_DECREF(encoder);
PyErr_SetString(PyExc_RuntimeError, "tiff codec initialization failed");
return NULL;
}
// While failes on 64 bit machines, complains that pos is an int instead of a Py_ssize_t
// while (PyDict_Next(dir, &pos, &key, &value)) {
for (pos=0;pos<d_size;pos++){
key = PyList_GetItem(keys,pos);
value = PyList_GetItem(values,pos);
status = 0;
TRACE(("Attempting to set key: %d\n", (int)PyInt_AsLong(key)));
if (PyInt_Check(value)) {
TRACE(("Setting from Int: %d %ld \n", (int)PyInt_AsLong(key),PyInt_AsLong(value)));
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) PyInt_AsLong(key),
PyInt_AsLong(value));
} else if(PyBytes_Check(value)) {
TRACE(("Setting from Bytes: %d, %s \n", (int)PyInt_AsLong(key),PyBytes_AsString(value)));
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) PyInt_AsLong(key),
PyBytes_AsString(value));
} else if(PyList_Check(value)) {
int len,i;
float *floatav;
int *intav;
TRACE(("Setting from List: %d \n", (int)PyInt_AsLong(key)));
len = (int)PyList_Size(value);
if (len) {
if (PyInt_Check(PyList_GetItem(value,0))) {
TRACE((" %d elements, setting as ints \n", len));
intav = malloc(sizeof(int)*len);
if (intav) {
for (i=0;i<len;i++) {
intav[i] = (int)PyInt_AsLong(PyList_GetItem(value,i));
}
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) PyInt_AsLong(key),
intav);
free(intav);
}
} else {
TRACE((" %d elements, setting as floats \n", len));
floatav = malloc(sizeof(float)*len);
if (floatav) {
for (i=0;i<len;i++) {
floatav[i] = (float)PyFloat_AsDouble(PyList_GetItem(value,i));
}
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) PyInt_AsLong(key),
floatav);
free(floatav);
}
}
}
} else if (PyFloat_Check(value)) {
TRACE(("Setting from Float: %d, %f \n", (int)PyInt_AsLong(key),PyFloat_AsDouble(value)));
status = ImagingLibTiffSetField(&encoder->state,
(ttag_t) PyInt_AsLong(key),
(float)PyFloat_AsDouble(value));
} else {
TRACE(("Unhandled type for key %d : %s \n",
(int)PyInt_AsLong(key),
PyBytes_AsString(PyObject_Str(value))));
}
if (!status) {
TRACE(("Error setting Field\n"));
Py_DECREF(encoder);
PyErr_SetString(PyExc_RuntimeError, "Error setting from dictionary");
return NULL;
}
}
encoder->encode = ImagingLibTiffEncode;
return (PyObject*) encoder;
}
static PyObject *
pytrap_init(PyObject *self, PyObject *args, PyObject *keywds)
{
char **argv = NULL;
char *arg;
PyObject *argvlist;
PyObject *strObj;
int argc = 0, i, ifcin = 1, ifcout = 0;
static char *kwlist[] = {"argv", "ifcin", "ifcout", NULL};
if (!PyArg_ParseTupleAndKeywords(args, keywds, "O!|ii", kwlist, &PyList_Type, &argvlist, &ifcin, &ifcout)) {
return NULL;
}
argc = PyList_Size(argvlist);
if (argc ==0) {
PyErr_SetString(TrapError, "argv list must not be empty.");
return NULL;
}
argv = calloc(argc, sizeof(char *));
for (i=0; i<argc; i++) {
strObj = PyList_GetItem(argvlist, i);
#if PY_MAJOR_VERSION >= 3
if (!PyUnicode_Check(strObj)) {
#else
if (!PyString_Check(strObj)) {
#endif
PyErr_SetString(TrapError, "argv must contain string.");
goto failure;
}
#if PY_MAJOR_VERSION >= 3
arg = PyUnicode_AsUTF8AndSize(strObj, NULL);
#else
arg = PyString_AS_STRING(strObj);
#endif
argv[i] = arg;
}
int ret = local_trap_init(argc, argv, module_info, ifcin, ifcout);
if (ret != 0) {
PyErr_SetString(TrapError, "Initialization failed");
return NULL;
}
Py_RETURN_NONE;
failure:
free(argv);
return NULL;
}
static PyObject *
pytrap_send(PyObject *self, PyObject *args, PyObject *keywds)
{
uint32_t ifcidx = 0;
PyObject *dataObj;
char *data;
Py_ssize_t data_size;
static char *kwlist[] = {"data", "ifcidx", NULL};
if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|I", kwlist, &dataObj, &ifcidx)) {
return NULL;
}
if (PyByteArray_Check(dataObj)) {
data_size = PyByteArray_Size(dataObj);
data = PyByteArray_AsString(dataObj);
} else if (PyBytes_Check(dataObj)) {
PyBytes_AsStringAndSize(dataObj, &data, &data_size);
} else {
PyErr_SetString(PyExc_TypeError, "Argument data must be of bytes or bytearray type.");
return NULL;
}
if (data_size > 0xFFFF) {
PyErr_SetString(TrapError, "Data length is out of range (0-65535)");
return NULL;
}
int ret;
Py_BEGIN_ALLOW_THREADS
ret = trap_send(ifcidx, data, (uint16_t) data_size);
Py_END_ALLOW_THREADS
if (ret == TRAP_E_TIMEOUT) {
PyErr_SetString(TimeoutError, "Timeout");
return NULL;
} else if (ret == TRAP_E_BAD_IFC_INDEX) {
PyErr_SetString(TrapError, "Bad index of IFC.");
return NULL;
} else if (ret == TRAP_E_TERMINATED) {
PyErr_SetString(TrapTerminated, "IFC was terminated.");
return NULL;
}
Py_RETURN_NONE;
}
int path_converter(PyObject *o, void *p)
{
struct path_arg *path = p;
int is_index, is_bytes, is_unicode;
PyObject *bytes = NULL;
Py_ssize_t length = 0;
char *tmp;
if (o == NULL) {
path_cleanup(p);
return 1;
}
path->object = path->cleanup = NULL;
Py_INCREF(o);
path->fd = -1;
is_index = path->allow_fd && PyIndex_Check(o);
is_bytes = PyBytes_Check(o);
is_unicode = PyUnicode_Check(o);
if (!is_index && !is_bytes && !is_unicode) {
_Py_IDENTIFIER(__fspath__);
PyObject *func;
func = _PyObject_LookupSpecial(o, &PyId___fspath__);
if (func == NULL)
goto err_format;
Py_DECREF(o);
o = PyObject_CallFunctionObjArgs(func, NULL);
Py_DECREF(func);
if (o == NULL)
return 0;
is_bytes = PyBytes_Check(o);
is_unicode = PyUnicode_Check(o);
}
if (is_unicode) {
if (!PyUnicode_FSConverter(o, &bytes))
goto err;
} else if (is_bytes) {
bytes = o;
Py_INCREF(bytes);
} else if (is_index) {
if (!fd_converter(o, &path->fd))
goto err;
path->path = NULL;
goto out;
} else {
err_format:
PyErr_Format(PyExc_TypeError, "expected %s, not %s",
path->allow_fd ? "string, bytes, os.PathLike, or integer" :
"string, bytes, or os.PathLike",
Py_TYPE(o)->tp_name);
goto err;
}
length = PyBytes_GET_SIZE(bytes);
tmp = PyBytes_AS_STRING(bytes);
if ((size_t)length != strlen(tmp)) {
PyErr_SetString(PyExc_TypeError,
"path has embedded nul character");
goto err;
}
path->path = tmp;
if (bytes == o)
Py_DECREF(bytes);
else
path->cleanup = bytes;
path->fd = -1;
out:
path->length = length;
path->object = o;
return Py_CLEANUP_SUPPORTED;
err:
Py_XDECREF(o);
Py_XDECREF(bytes);
return 0;
}
static PyObject *txdelta_call(PyObject *self, PyObject *args, PyObject *kwargs)
{
char *kwnames[] = { "window", NULL };
svn_txdelta_window_t window;
TxDeltaWindowHandlerObject *obj = (TxDeltaWindowHandlerObject *)self;
PyObject *py_window, *py_ops, *py_new_data;
int i;
svn_string_t new_data;
svn_error_t *error;
svn_txdelta_op_t *ops;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", kwnames, &py_window))
return NULL;
if (py_window == Py_None) {
RUN_SVN(obj->txdelta_handler(NULL, obj->txdelta_baton));
Py_RETURN_NONE;
}
if (!PyArg_ParseTuple(py_window, SVN_FILESIZE_T_PYFMT "kkiOO",
&window.sview_offset, &window.sview_len, &window.tview_len,
&window.src_ops, &py_ops, &py_new_data))
return NULL;
if (py_new_data == Py_None) {
window.new_data = NULL;
} else {
if (!PyBytes_Check(py_new_data)) {
PyErr_SetString(PyExc_TypeError, "delta data should be bytes");
return NULL;
}
new_data.data = PyBytes_AsString(py_new_data);
new_data.len = PyBytes_Size(py_new_data);
window.new_data = &new_data;
}
if (!PyList_Check(py_ops)) {
PyErr_SetString(PyExc_TypeError, "ops not a list");
return NULL;
}
window.num_ops = PyList_Size(py_ops);
window.ops = ops = malloc(sizeof(svn_txdelta_op_t) * window.num_ops);
for (i = 0; i < window.num_ops; i++) {
PyObject *windowitem = PyList_GetItem(py_ops, i);
if (!PyArg_ParseTuple(windowitem, "ikk", &ops[i].action_code,
&ops[i].offset, &ops[i].length)) {
free(ops);
return NULL;
}
}
Py_BEGIN_ALLOW_THREADS
error = obj->txdelta_handler(&window, obj->txdelta_baton);
Py_END_ALLOW_THREADS
if (error != NULL) {
handle_svn_error(error);
svn_error_clear(error);
free(ops);
return NULL;
}
free(ops);
Py_RETURN_NONE;
}
PyObject *
PyFile_GetLine(PyObject *f, int n)
{
PyObject *result;
if (f == NULL) {
PyErr_BadInternalCall();
return NULL;
}
{
PyObject *reader;
PyObject *args;
_Py_IDENTIFIER(readline);
reader = _PyObject_GetAttrId(f, &PyId_readline);
if (reader == NULL)
return NULL;
if (n <= 0)
args = PyTuple_New(0);
else
args = Py_BuildValue("(i)", n);
if (args == NULL) {
Py_DECREF(reader);
return NULL;
}
result = PyEval_CallObject(reader, args);
Py_DECREF(reader);
Py_DECREF(args);
if (result != NULL && !PyBytes_Check(result) &&
!PyUnicode_Check(result)) {
Py_DECREF(result);
result = NULL;
PyErr_SetString(PyExc_TypeError,
"object.readline() returned non-string");
}
}
if (n < 0 && result != NULL && PyBytes_Check(result)) {
char *s = PyBytes_AS_STRING(result);
Py_ssize_t len = PyBytes_GET_SIZE(result);
if (len == 0) {
Py_DECREF(result);
result = NULL;
PyErr_SetString(PyExc_EOFError,
"EOF when reading a line");
}
else if (s[len-1] == '\n') {
if (result->ob_refcnt == 1)
_PyBytes_Resize(&result, len-1);
else {
PyObject *v;
v = PyBytes_FromStringAndSize(s, len-1);
Py_DECREF(result);
result = v;
}
}
}
if (n < 0 && result != NULL && PyUnicode_Check(result)) {
Py_ssize_t len = PyUnicode_GET_LENGTH(result);
if (len == 0) {
Py_DECREF(result);
result = NULL;
PyErr_SetString(PyExc_EOFError,
"EOF when reading a line");
}
else if (PyUnicode_READ_CHAR(result, len-1) == '\n') {
PyObject *v;
v = PyUnicode_Substring(result, 0, len-1);
Py_DECREF(result);
result = v;
}
}
return result;
}
PyCodeObject *
PyCode_New(int argcount, int kwonlyargcount,
int nlocals, int stacksize, int flags,
PyObject *code, PyObject *consts, PyObject *names,
PyObject *varnames, PyObject *freevars, PyObject *cellvars,
PyObject *filename, PyObject *name, int firstlineno,
PyObject *lnotab)
{
PyCodeObject *co;
unsigned char *cell2arg = NULL;
Py_ssize_t i, n_cellvars;
/* Check argument types */
if (argcount < 0 || kwonlyargcount < 0 || nlocals < 0 ||
code == NULL ||
consts == NULL || !PyTuple_Check(consts) ||
names == NULL || !PyTuple_Check(names) ||
varnames == NULL || !PyTuple_Check(varnames) ||
freevars == NULL || !PyTuple_Check(freevars) ||
cellvars == NULL || !PyTuple_Check(cellvars) ||
name == NULL || !PyUnicode_Check(name) ||
filename == NULL || !PyUnicode_Check(filename) ||
lnotab == NULL || !PyBytes_Check(lnotab) ||
!PyObject_CheckReadBuffer(code)) {
PyErr_BadInternalCall();
return NULL;
}
/* Ensure that the filename is a ready Unicode string */
if (PyUnicode_READY(filename) < 0)
return NULL;
n_cellvars = PyTuple_GET_SIZE(cellvars);
intern_strings(names);
intern_strings(varnames);
intern_strings(freevars);
intern_strings(cellvars);
/* Intern selected string constants */
for (i = PyTuple_GET_SIZE(consts); --i >= 0; ) {
PyObject *v = PyTuple_GetItem(consts, i);
if (!all_name_chars(v))
continue;
PyUnicode_InternInPlace(&PyTuple_GET_ITEM(consts, i));
}
/* Create mapping between cells and arguments if needed. */
if (n_cellvars) {
Py_ssize_t total_args = argcount + kwonlyargcount +
((flags & CO_VARARGS) != 0) + ((flags & CO_VARKEYWORDS) != 0);
Py_ssize_t alloc_size = sizeof(unsigned char) * n_cellvars;
int used_cell2arg = 0;
cell2arg = PyMem_MALLOC(alloc_size);
if (cell2arg == NULL)
return NULL;
memset(cell2arg, CO_CELL_NOT_AN_ARG, alloc_size);
/* Find cells which are also arguments. */
for (i = 0; i < n_cellvars; i++) {
Py_ssize_t j;
PyObject *cell = PyTuple_GET_ITEM(cellvars, i);
for (j = 0; j < total_args; j++) {
PyObject *arg = PyTuple_GET_ITEM(varnames, j);
if (!PyUnicode_Compare(cell, arg)) {
cell2arg[i] = j;
used_cell2arg = 1;
break;
}
}
}
if (!used_cell2arg) {
PyMem_FREE(cell2arg);
cell2arg = NULL;
}
}
co = PyObject_NEW(PyCodeObject, &PyCode_Type);
if (co == NULL) {
if (cell2arg)
PyMem_FREE(cell2arg);
return NULL;
}
co->co_argcount = argcount;
co->co_kwonlyargcount = kwonlyargcount;
co->co_nlocals = nlocals;
co->co_stacksize = stacksize;
co->co_flags = flags;
Py_INCREF(code);
co->co_code = code;
Py_INCREF(consts);
co->co_consts = consts;
Py_INCREF(names);
co->co_names = names;
Py_INCREF(varnames);
co->co_varnames = varnames;
Py_INCREF(freevars);
co->co_freevars = freevars;
Py_INCREF(cellvars);
co->co_cellvars = cellvars;
co->co_cell2arg = cell2arg;
Py_INCREF(filename);
co->co_filename = filename;
Py_INCREF(name);
co->co_name = name;
co->co_firstlineno = firstlineno;
Py_INCREF(lnotab);
co->co_lnotab = lnotab;
co->co_zombieframe = NULL;
co->co_weakreflist = NULL;
return co;
}
static int
mpz_set_PyStr(mpz_ptr z, PyObject *s, int base)
{
char *cp;
Py_ssize_t len;
size_t i;
PyObject *ascii_str = NULL;
if (PyBytes_Check(s)) {
len = PyBytes_Size(s);
cp = PyBytes_AsString(s);
}
else if (PyUnicode_Check(s)) {
ascii_str = PyUnicode_AsASCIIString(s);
if (!ascii_str) {
VALUE_ERROR("string contains non-ASCII characters");
return -1;
}
len = PyBytes_Size(ascii_str);
cp = PyBytes_AsString(ascii_str);
}
else {
TYPE_ERROR("object is not string or Unicode");
return -1;
}
/* Don't allow NULL characters */
for (i = 0; i < len; i++) {
if (cp[i] == '\0') {
VALUE_ERROR("string contains NULL characters");
Py_XDECREF(ascii_str);
return -1;
}
}
/* Check for leading base indicators. */
if (base == 0) {
if (cp[0] == '0') {
if (cp[1] == 'b') { base = 2; cp += 2; }
else if (cp[1] == 'o') { base = 8; cp += 2; }
else if (cp[1] == 'x') { base = 16; cp += 2; }
else { base = 10; }
}
else {
base = 10;
}
}
else if (cp[0] == '0') {
/* If the specified base matches the leading base indicators, then
* we need to skip the base indicators.
*/
if (cp[1] =='b' && base == 2) { cp += 2; }
else if (cp[1] =='o' && base == 8) { cp += 2; }
else if (cp[1] =='x' && base == 16) { cp += 2; }
}
/* delegate rest to GMP's _set_str function */
if (-1 == mpz_set_str(z, cp, base)) {
VALUE_ERROR("invalid digits");
Py_XDECREF(ascii_str);
return -1;
}
Py_XDECREF(ascii_str);
return 1;
}
static PyObject* __Pyx_PyExec3(PyObject* o, PyObject* globals, PyObject* locals) {
PyObject* result;
PyObject* s = 0;
char *code = 0;
if (!globals || globals == Py_None) {
globals = PyModule_GetDict($module_cname);
if (!globals)
goto bad;
} else if (!PyDict_Check(globals)) {
PyErr_Format(PyExc_TypeError, "exec() arg 2 must be a dict, not %.200s",
Py_TYPE(globals)->tp_name);
goto bad;
}
if (!locals || locals == Py_None) {
locals = globals;
}
if (PyDict_GetItem(globals, PYIDENT("__builtins__")) == NULL) {
if (PyDict_SetItem(globals, PYIDENT("__builtins__"), PyEval_GetBuiltins()) < 0)
goto bad;
}
if (PyCode_Check(o)) {
if (PyCode_GetNumFree((PyCodeObject *)o) > 0) {
PyErr_SetString(PyExc_TypeError,
"code object passed to exec() may not contain free variables");
goto bad;
}
#if PY_VERSION_HEX < 0x030200B1
result = PyEval_EvalCode((PyCodeObject *)o, globals, locals);
#else
result = PyEval_EvalCode(o, globals, locals);
#endif
} else {
PyCompilerFlags cf;
cf.cf_flags = 0;
if (PyUnicode_Check(o)) {
cf.cf_flags = PyCF_SOURCE_IS_UTF8;
s = PyUnicode_AsUTF8String(o);
if (!s) goto bad;
o = s;
#if PY_MAJOR_VERSION >= 3
} else if (!PyBytes_Check(o)) {
#else
} else if (!PyString_Check(o)) {
#endif
PyErr_Format(PyExc_TypeError,
"exec: arg 1 must be string, bytes or code object, got %.200s",
Py_TYPE(o)->tp_name);
goto bad;
}
#if PY_MAJOR_VERSION >= 3
code = PyBytes_AS_STRING(o);
#else
code = PyString_AS_STRING(o);
#endif
if (PyEval_MergeCompilerFlags(&cf)) {
result = PyRun_StringFlags(code, Py_file_input, globals, locals, &cf);
} else {
result = PyRun_String(code, Py_file_input, globals, locals);
}
Py_XDECREF(s);
}
return result;
bad:
Py_XDECREF(s);
return 0;
}
NPY_NO_EXPORT int
PyArray_DTypeFromObjectHelper(PyObject *obj, int maxdims,
PyArray_Descr **out_dtype, int string_type)
{
int i, size;
PyArray_Descr *dtype = NULL;
PyObject *ip;
Py_buffer buffer_view;
/* Check if it's an ndarray */
if (PyArray_Check(obj)) {
dtype = PyArray_DESCR((PyArrayObject *)obj);
Py_INCREF(dtype);
goto promote_types;
}
/* See if it's a python None */
if (obj == Py_None) {
dtype = PyArray_DescrFromType(NPY_OBJECT);
if (dtype == NULL) {
goto fail;
}
Py_INCREF(dtype);
goto promote_types;
}
/* Check if it's a NumPy scalar */
else if (PyArray_IsScalar(obj, Generic)) {
if (!string_type) {
dtype = PyArray_DescrFromScalar(obj);
if (dtype == NULL) {
goto fail;
}
}
else {
int itemsize;
PyObject *temp;
if (string_type == NPY_STRING) {
if ((temp = PyObject_Str(obj)) == NULL) {
return -1;
}
#if defined(NPY_PY3K)
#if PY_VERSION_HEX >= 0x03030000
itemsize = PyUnicode_GetLength(temp);
#else
itemsize = PyUnicode_GET_SIZE(temp);
#endif
#else
itemsize = PyString_GET_SIZE(temp);
#endif
}
else if (string_type == NPY_UNICODE) {
#if defined(NPY_PY3K)
if ((temp = PyObject_Str(obj)) == NULL) {
#else
if ((temp = PyObject_Unicode(obj)) == NULL) {
#endif
return -1;
}
itemsize = PyUnicode_GET_DATA_SIZE(temp);
#ifndef Py_UNICODE_WIDE
itemsize <<= 1;
#endif
}
else {
goto fail;
}
Py_DECREF(temp);
if (*out_dtype != NULL &&
(*out_dtype)->type_num == string_type &&
(*out_dtype)->elsize >= itemsize) {
return 0;
}
dtype = PyArray_DescrNewFromType(string_type);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = itemsize;
}
goto promote_types;
}
/* Check if it's a Python scalar */
dtype = _array_find_python_scalar_type(obj);
if (dtype != NULL) {
if (string_type) {
int itemsize;
PyObject *temp;
if (string_type == NPY_STRING) {
if ((temp = PyObject_Str(obj)) == NULL) {
return -1;
}
#if defined(NPY_PY3K)
#if PY_VERSION_HEX >= 0x03030000
itemsize = PyUnicode_GetLength(temp);
#else
itemsize = PyUnicode_GET_SIZE(temp);
#endif
#else
itemsize = PyString_GET_SIZE(temp);
#endif
}
else if (string_type == NPY_UNICODE) {
#if defined(NPY_PY3K)
if ((temp = PyObject_Str(obj)) == NULL) {
#else
if ((temp = PyObject_Unicode(obj)) == NULL) {
#endif
return -1;
}
itemsize = PyUnicode_GET_DATA_SIZE(temp);
#ifndef Py_UNICODE_WIDE
itemsize <<= 1;
#endif
}
else {
goto fail;
}
Py_DECREF(temp);
if (*out_dtype != NULL &&
(*out_dtype)->type_num == string_type &&
(*out_dtype)->elsize >= itemsize) {
return 0;
}
dtype = PyArray_DescrNewFromType(string_type);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = itemsize;
}
goto promote_types;
}
/* Check if it's an ASCII string */
if (PyBytes_Check(obj)) {
int itemsize = PyString_GET_SIZE(obj);
/* If it's already a big enough string, don't bother type promoting */
if (*out_dtype != NULL &&
(*out_dtype)->type_num == NPY_STRING &&
(*out_dtype)->elsize >= itemsize) {
return 0;
}
dtype = PyArray_DescrNewFromType(NPY_STRING);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = itemsize;
goto promote_types;
}
/* Check if it's a Unicode string */
if (PyUnicode_Check(obj)) {
int itemsize = PyUnicode_GET_DATA_SIZE(obj);
#ifndef Py_UNICODE_WIDE
itemsize <<= 1;
#endif
/*
* If it's already a big enough unicode object,
* don't bother type promoting
*/
if (*out_dtype != NULL &&
(*out_dtype)->type_num == NPY_UNICODE &&
(*out_dtype)->elsize >= itemsize) {
return 0;
}
dtype = PyArray_DescrNewFromType(NPY_UNICODE);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = itemsize;
goto promote_types;
}
/* PEP 3118 buffer interface */
if (PyObject_CheckBuffer(obj) == 1) {
memset(&buffer_view, 0, sizeof(Py_buffer));
if (PyObject_GetBuffer(obj, &buffer_view,
PyBUF_FORMAT|PyBUF_STRIDES) == 0 ||
PyObject_GetBuffer(obj, &buffer_view, PyBUF_FORMAT) == 0) {
PyErr_Clear();
dtype = _descriptor_from_pep3118_format(buffer_view.format);
PyBuffer_Release(&buffer_view);
if (dtype) {
goto promote_types;
}
}
else if (PyObject_GetBuffer(obj, &buffer_view, PyBUF_STRIDES) == 0 ||
PyObject_GetBuffer(obj, &buffer_view, PyBUF_SIMPLE) == 0) {
PyErr_Clear();
dtype = PyArray_DescrNewFromType(NPY_VOID);
dtype->elsize = buffer_view.itemsize;
PyBuffer_Release(&buffer_view);
goto promote_types;
}
else {
PyErr_Clear();
}
}
/* The array interface */
ip = PyArray_GetAttrString_SuppressException(obj, "__array_interface__");
if (ip != NULL) {
if (PyDict_Check(ip)) {
PyObject *typestr;
#if defined(NPY_PY3K)
PyObject *tmp = NULL;
#endif
typestr = PyDict_GetItemString(ip, "typestr");
#if defined(NPY_PY3K)
/* Allow unicode type strings */
if (PyUnicode_Check(typestr)) {
tmp = PyUnicode_AsASCIIString(typestr);
typestr = tmp;
}
#endif
if (typestr && PyBytes_Check(typestr)) {
dtype =_array_typedescr_fromstr(PyBytes_AS_STRING(typestr));
#if defined(NPY_PY3K)
if (tmp == typestr) {
Py_DECREF(tmp);
}
#endif
Py_DECREF(ip);
if (dtype == NULL) {
goto fail;
}
goto promote_types;
}
}
Py_DECREF(ip);
}
/* The array struct interface */
ip = PyArray_GetAttrString_SuppressException(obj, "__array_struct__");
if (ip != NULL) {
PyArrayInterface *inter;
char buf[40];
if (NpyCapsule_Check(ip)) {
inter = (PyArrayInterface *)NpyCapsule_AsVoidPtr(ip);
if (inter->two == 2) {
PyOS_snprintf(buf, sizeof(buf),
"|%c%d", inter->typekind, inter->itemsize);
dtype = _array_typedescr_fromstr(buf);
Py_DECREF(ip);
if (dtype == NULL) {
goto fail;
}
goto promote_types;
}
}
Py_DECREF(ip);
}
/* The old buffer interface */
#if !defined(NPY_PY3K)
if (PyBuffer_Check(obj)) {
dtype = PyArray_DescrNewFromType(NPY_VOID);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = Py_TYPE(obj)->tp_as_sequence->sq_length(obj);
PyErr_Clear();
goto promote_types;
}
#endif
/* The __array__ attribute */
ip = PyArray_GetAttrString_SuppressException(obj, "__array__");
if (ip != NULL) {
Py_DECREF(ip);
ip = PyObject_CallMethod(obj, "__array__", NULL);
if(ip && PyArray_Check(ip)) {
dtype = PyArray_DESCR((PyArrayObject *)ip);
Py_INCREF(dtype);
Py_DECREF(ip);
goto promote_types;
}
Py_XDECREF(ip);
if (PyErr_Occurred()) {
goto fail;
}
}
/* Not exactly sure what this is about... */
#if !defined(NPY_PY3K)
if (PyInstance_Check(obj)) {
dtype = _use_default_type(obj);
if (dtype == NULL) {
goto fail;
}
else {
goto promote_types;
}
}
#endif
/*
* If we reached the maximum recursion depth without hitting one
* of the above cases, the output dtype should be OBJECT
*/
if (maxdims == 0 || !PySequence_Check(obj)) {
if (*out_dtype == NULL || (*out_dtype)->type_num != NPY_OBJECT) {
Py_XDECREF(*out_dtype);
*out_dtype = PyArray_DescrFromType(NPY_OBJECT);
if (*out_dtype == NULL) {
return -1;
}
}
return 0;
}
/* Recursive case */
size = PySequence_Size(obj);
if (size < 0) {
goto fail;
}
/* Recursive call for each sequence item */
for (i = 0; i < size; ++i) {
int res;
ip = PySequence_GetItem(obj, i);
if (ip == NULL) {
goto fail;
}
res = PyArray_DTypeFromObjectHelper(ip, maxdims - 1,
out_dtype, string_type);
if (res < 0) {
Py_DECREF(ip);
goto fail;
}
else if (res > 0) {
Py_DECREF(ip);
return res;
}
Py_DECREF(ip);
}
return 0;
promote_types:
/* Set 'out_dtype' if it's NULL */
if (*out_dtype == NULL) {
if (!string_type && dtype->type_num == NPY_STRING) {
Py_DECREF(dtype);
return RETRY_WITH_STRING;
}
if (!string_type && dtype->type_num == NPY_UNICODE) {
Py_DECREF(dtype);
return RETRY_WITH_UNICODE;
}
*out_dtype = dtype;
return 0;
}
/* Do type promotion with 'out_dtype' */
else {
PyArray_Descr *res_dtype = PyArray_PromoteTypes(dtype, *out_dtype);
Py_DECREF(dtype);
if (res_dtype == NULL) {
return -1;
}
if (!string_type &&
res_dtype->type_num == NPY_UNICODE &&
(*out_dtype)->type_num != NPY_UNICODE) {
Py_DECREF(res_dtype);
return RETRY_WITH_UNICODE;
}
if (!string_type &&
res_dtype->type_num == NPY_STRING &&
(*out_dtype)->type_num != NPY_STRING) {
Py_DECREF(res_dtype);
return RETRY_WITH_STRING;
}
Py_DECREF(*out_dtype);
*out_dtype = res_dtype;
return 0;
}
fail:
Py_XDECREF(*out_dtype);
*out_dtype = NULL;
return -1;
}
#undef RETRY_WITH_STRING
#undef RETRY_WITH_UNICODE
/* new reference */
NPY_NO_EXPORT PyArray_Descr *
_array_typedescr_fromstr(char *c_str)
{
PyArray_Descr *descr = NULL;
PyObject *stringobj = PyString_FromString(c_str);
if (stringobj == NULL) {
return NULL;
}
if (PyArray_DescrConverter(stringobj, &descr) != NPY_SUCCEED) {
Py_DECREF(stringobj);
return NULL;
}
Py_DECREF(stringobj);
return descr;
}
NPY_NO_EXPORT char *
index2ptr(PyArrayObject *mp, npy_intp i)
{
npy_intp dim0;
if (PyArray_NDIM(mp) == 0) {
PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed");
return NULL;
}
dim0 = PyArray_DIMS(mp)[0];
if (check_and_adjust_index(&i, dim0, 0) < 0)
return NULL;
if (i == 0) {
return PyArray_DATA(mp);
}
return PyArray_BYTES(mp)+i*PyArray_STRIDES(mp)[0];
}