static ExpatStatus
builder_ProcessingInstruction(void *userState, PyObject *target, PyObject *data)
{
ParserState *state = (ParserState *)userState;
NodeObject *node;
#ifdef DEBUG_PARSER
fprintf(stderr, "--- builder_ProcessingInstruction(target=");
PyObject_Print(target, stderr, 0);
fprintf(stderr, ", data=");
PyObject_Print(data, stderr, 0);
fprintf(stderr, ")\n");
#endif
if (state->processing_instruction_factory) {
node = (NodeObject *)
PyObject_CallFunctionObjArgs(state->processing_instruction_factory,
target, data, NULL);
if (node == NULL)
return EXPAT_STATUS_ERROR;
if (!Text_Check(node)) {
PyErr_Format(PyExc_TypeError,
"xml_processing_instruction_factory should return "
"processing_instruction, not %s",
node->ob_type->tp_name);
Py_DECREF(node);
return EXPAT_STATUS_ERROR;
}
} else {
node = (NodeObject *)ProcessingInstruction_New(target, data);
if (node == NULL)
return EXPAT_STATUS_ERROR;
}
/* ParserState_AddNode steals the reference to the new node */
if (ParserState_AddNode(state, node) < 0) {
Py_DECREF(node);
return EXPAT_STATUS_ERROR;
}
/* Callout to rule matching */
if (state->rule_matcher) {
if (RuleMatch_ProcessingInstruction(state->rule_matcher,(PyObject *) node,target,data) < 0) {
return EXPAT_STATUS_ERROR;
}
}
return EXPAT_STATUS_OK;
}
static ExpatStatus
builder_Comment(void *userState, PyObject *data)
{
ParserState *state = (ParserState *)userState;
NodeObject *node;
#ifdef DEBUG_PARSER
fprintf(stderr, "--- builder_Comment(data=");
PyObject_Print(data, stderr, 0);
fprintf(stderr, ")\n");
#endif
if (state->comment_factory) {
node = (NodeObject *)PyObject_CallFunctionObjArgs(state->comment_factory,
data, NULL);
if (node == NULL)
return EXPAT_STATUS_ERROR;
if (!Text_Check(node)) {
PyErr_Format(PyExc_TypeError,
"xml_comment_factory should return comment, not %s",
node->ob_type->tp_name);
Py_DECREF(node);
return EXPAT_STATUS_ERROR;
}
} else {
node = (NodeObject *)Comment_New(data);
if (node == NULL)
return EXPAT_STATUS_ERROR;
}
/* ParserState_AddNode steals the reference to the new node */
if (ParserState_AddNode(state, node) < 0) {
Py_DECREF(node);
return EXPAT_STATUS_ERROR;
}
return EXPAT_STATUS_OK;
}
static PyObject* mod_connect(PyObject* self, PyObject* args, PyObject* kwargs)
{
UNUSED(self);
Object pConnectString;
int fAutoCommit = 0;
int fAnsi = 0; // force ansi
int fReadOnly = 0;
long timeout = 0;
Object encoding;
Object attrs_before; // Optional connect attrs set before connecting
Py_ssize_t size = args ? PyTuple_Size(args) : 0;
if (size > 1)
{
PyErr_SetString(PyExc_TypeError, "function takes at most 1 non-keyword argument");
return 0;
}
if (size == 1)
{
if (!PyString_Check(PyTuple_GET_ITEM(args, 0)) && !PyUnicode_Check(PyTuple_GET_ITEM(args, 0)))
return PyErr_Format(PyExc_TypeError, "argument 1 must be a string or unicode object");
pConnectString.Attach(PyUnicode_FromObject(PyTuple_GetItem(args, 0)));
if (!pConnectString.IsValid())
return 0;
}
if (kwargs && PyDict_Size(kwargs) > 0)
{
Object partsdict(PyDict_New());
if (!partsdict.IsValid())
return 0;
Py_ssize_t pos = 0;
PyObject* key = 0;
PyObject* value = 0;
Object okey; // in case we need to allocate a new key
while (PyDict_Next(kwargs, &pos, &key, &value))
{
if (!Text_Check(key))
return PyErr_Format(PyExc_TypeError, "Dictionary keys passed to connect must be strings");
// // Note: key and value are *borrowed*.
//
// // Check for the two non-connection string keywords we accept. (If we get many more of these, create something
// // table driven. Are we sure there isn't a Python function to parse keywords but leave those it doesn't know?)
// const char* szKey = PyString_AsString(key);
if (Text_EqualsI(key, "autocommit"))
{
fAutoCommit = PyObject_IsTrue(value);
continue;
}
if (Text_EqualsI(key, "ansi"))
{
fAnsi = PyObject_IsTrue(value);
continue;
}
if (Text_EqualsI(key, "timeout"))
{
timeout = PyInt_AsLong(value);
if (PyErr_Occurred())
return 0;
continue;
}
if (Text_EqualsI(key, "readonly"))
{
fReadOnly = PyObject_IsTrue(value);
continue;
}
if (Text_EqualsI(key, "attrs_before"))
{
attrs_before = _CheckAttrsDict(value);
if (PyErr_Occurred())
return 0;
continue;
}
if (Text_EqualsI(key, "encoding"))
{
#if PY_MAJOR_VERSION < 3
if (!PyString_Check(value) || !PyUnicode_Check(value))
return PyErr_Format(PyExc_TypeError, "encoding must be a string or unicode object");
#else
if (!PyUnicode_Check(value))
return PyErr_Format(PyExc_TypeError, "encoding must be a string");
#endif
encoding = value;
continue;
}
// Map DB API recommended names to ODBC names (e.g. user --> uid).
for (size_t i = 0; i < _countof(keywordmaps); i++)
{
if (Text_EqualsI(key, keywordmaps[i].oldname))
{
if (keywordmaps[i].newnameObject == 0)
{
keywordmaps[i].newnameObject = PyString_FromString(keywordmaps[i].newname);
if (keywordmaps[i].newnameObject == 0)
return 0;
}
key = keywordmaps[i].newnameObject;
break;
}
}
PyObject* str = PyObject_Str(value); // convert if necessary
if (!str)
return 0;
if (PyDict_SetItem(partsdict.Get(), key, str) == -1)
{
Py_XDECREF(str);
return 0;
}
Py_XDECREF(str);
}
if (PyDict_Size(partsdict.Get()))
pConnectString.Attach(MakeConnectionString(pConnectString.Get(), partsdict));
}
if (!pConnectString.IsValid())
return PyErr_Format(PyExc_TypeError, "no connection information was passed");
if (henv == SQL_NULL_HANDLE)
{
if (!AllocateEnv())
return 0;
}
return (PyObject*)Connection_New(pConnectString.Get(), fAutoCommit != 0, fAnsi != 0, timeout,
fReadOnly != 0, attrs_before, encoding);
}
static PyObject *py_sorted_tree_items(PyObject *self, PyObject *args)
{
struct tree_item *qsort_entries = NULL;
int name_order, num_entries, n = 0, i;
PyObject *entries, *py_name_order, *ret, *key, *value, *py_mode, *py_sha;
Py_ssize_t pos = 0;
int (*cmp)(const void *, const void *);
if (!PyArg_ParseTuple(args, "OO", &entries, &py_name_order))
goto error;
if (!PyDict_Check(entries)) {
PyErr_SetString(PyExc_TypeError, "Argument not a dictionary");
goto error;
}
name_order = PyObject_IsTrue(py_name_order);
if (name_order == -1)
goto error;
cmp = name_order ? cmp_tree_item_name_order : cmp_tree_item;
num_entries = PyDict_Size(entries);
if (PyErr_Occurred())
goto error;
qsort_entries = PyMem_New(struct tree_item, num_entries);
if (!qsort_entries) {
PyErr_NoMemory();
goto error;
}
while (PyDict_Next(entries, &pos, &key, &value)) {
if (!Text_Check(key)) {
PyErr_SetString(PyExc_TypeError, "Name is not a string");
goto error;
}
if (PyTuple_Size(value) != 2) {
PyErr_SetString(PyExc_ValueError, "Tuple has invalid size");
goto error;
}
py_mode = PyTuple_GET_ITEM(value, 0);
if (!PyInt_Check(py_mode)) {
PyErr_SetString(PyExc_TypeError, "Mode is not an integral type");
goto error;
}
py_sha = PyTuple_GET_ITEM(value, 1);
if (!Text_Check(py_sha)) {
PyErr_SetString(PyExc_TypeError, "SHA is not a string");
goto error;
}
qsort_entries[n].name = Text_Buffer(key);
qsort_entries[n].mode = PyInt_AS_LONG(py_mode);
qsort_entries[n].tuple = PyObject_CallFunctionObjArgs(
tree_entry_cls, key, py_mode, py_sha, NULL);
if (qsort_entries[n].tuple == NULL)
goto error;
n++;
}
qsort(qsort_entries, num_entries, sizeof(struct tree_item), cmp);
ret = PyList_New(num_entries);
if (ret == NULL) {
PyErr_NoMemory();
goto error;
}
for (i = 0; i < num_entries; i++) {
PyList_SET_ITEM(ret, i, qsort_entries[i].tuple);
}
PyMem_Free(qsort_entries);
return ret;
error:
for (i = 0; i < n; i++) {
Py_XDECREF(qsort_entries[i].tuple);
}
PyMem_Free(qsort_entries);
return NULL;
}
