static void
SSOR_dealloc(SSORObject *self)
{
Py_DECREF(self->matrix);
PyMem_DEL(self->temp);
PyMem_DEL(self->temp2);
PyObject_Del(self);
}
static void
Jacobi_dealloc(JacobiObject *self)
{
Py_DECREF(self->matrix);
PyMem_DEL(self->dinv);
PyMem_DEL(self->temp);
PyObject_Del(self);
}
static void PyBlock_Dealloc(PyBlockObject *b)
{
if(b->heap) {
if (b->heap)
;
else
PyMem_DEL(b->block);
}
PyMem_DEL(b);
}
static PyObject *
thread_PyThread_start_new_thread(PyObject *self, PyObject *fargs)
{
PyObject *func, *args, *keyw = NULL;
struct bootstate *boot;
long ident;
if (!PyArg_UnpackTuple(fargs, "start_new_thread", 2, 3,
&func, &args, &keyw))
return NULL;
if (!PyCallable_Check(func)) {
PyErr_SetString(PyExc_TypeError,
"first arg must be callable");
return NULL;
}
if (!PyTuple_Check(args)) {
PyErr_SetString(PyExc_TypeError,
"2nd arg must be a tuple");
return NULL;
}
if (keyw != NULL && !PyDict_Check(keyw)) {
PyErr_SetString(PyExc_TypeError,
"optional 3rd arg must be a dictionary");
return NULL;
}
boot = PyMem_NEW(struct bootstate, 1);
if (boot == NULL)
return PyErr_NoMemory();
boot->interp = PyThreadState_GET()->interp;
boot->func = func;
boot->args = args;
boot->keyw = keyw;
boot->tstate = _PyThreadState_Prealloc(boot->interp);
if (boot->tstate == NULL) {
PyMem_DEL(boot);
return PyErr_NoMemory();
}
Py_INCREF(func);
Py_INCREF(args);
Py_XINCREF(keyw);
PyEval_InitThreads(); /* Start the interpreter's thread-awareness */
ident = PyThread_start_new_thread(t_bootstrap, (void*) boot);
if (ident == -1) {
PyErr_SetString(ThreadError, "can't start new thread");
Py_DECREF(func);
Py_DECREF(args);
Py_XDECREF(keyw);
PyThreadState_Clear(boot->tstate);
PyMem_DEL(boot);
return NULL;
}
return PyLong_FromLong(ident);
}
static void
t_bootstrap(void *boot_raw)
{
struct bootstate *boot = (struct bootstate *) boot_raw;
PyThreadState *tstate;
PyObject *res;
tstate = PyThreadState_New(boot->interp);
PyEval_AcquireThread(tstate);
res = PyEval_CallObjectWithKeywords(
boot->func, boot->args, boot->keyw);
Py_DECREF(boot->func);
Py_DECREF(boot->args);
Py_XDECREF(boot->keyw);
PyMem_DEL(boot_raw);
if (res == NULL) {
if (PyErr_ExceptionMatches(PyExc_SystemExit))
PyErr_Clear();
else {
PySys_WriteStderr("Unhandled exception in thread:\n");
PyErr_PrintEx(0);
}
}
else
Py_DECREF(res);
PyThreadState_Clear(tstate);
PyThreadState_DeleteCurrent();
PyThread_exit_thread();
}
static void
sp_handle_dealloc(sp_handle_object* self)
{
if (self->handle != INVALID_HANDLE_VALUE)
CloseHandle(self->handle);
PyMem_DEL(self);
}
static PyObject *
sv_LoadMap(svobject *self, PyObject *args)
{
PyObject *rgb;
PyObject *res = NULL;
rgb_tuple *mapp = NULL;
int maptype;
int i, j; /* indices */
if (!PyArg_Parse(args, "(iO)", &maptype, &rgb))
return NULL;
if (!PyList_Check(rgb) || PyList_Size(rgb) != 256) {
PyErr_BadArgument();
return NULL;
}
if (!(mapp = PyMem_NEW(rgb_tuple, 256)))
return PyErr_NoMemory();
for (i = 0; i < 256; i++) {
PyObject* v = PyList_GetItem(rgb, i);
if (!v)
goto finally;
if (!PyTuple_Check(v) || PyTuple_Size(v) != 3) {
PyErr_BadArgument();
goto finally;
}
for (j = 0; j < 3; j++) {
PyObject* cell = PyTuple_GetItem(v, j);
if (!cell)
goto finally;
if (!PyInt_Check(cell)) {
PyErr_BadArgument();
goto finally;
}
switch (j) {
case 0: mapp[i].red = PyInt_AsLong(cell); break;
case 1: mapp[i].blue = PyInt_AsLong(cell); break;
case 2: mapp[i].green = PyInt_AsLong(cell); break;
}
if (PyErr_Occurred())
goto finally;
}
}
if (svLoadMap(self->ob_svideo, maptype, mapp)) {
res = sv_error();
goto finally;
}
Py_INCREF(Py_None);
res = Py_None;
finally:
PyMem_DEL(mapp);
return res;
}
static void
Splitter_dealloc(Splitter *self)
{
Py_XDECREF(self->list);
Py_XDECREF(self->synstop);
PyMem_DEL(self);
}
static PyObject * _RRD_call(PyObject *self, PyObject *args) {
char **argv;
int argc, rc;
argv = parse_args(args, &argc);
if (!argv)
return NULL;
if (!strcmp("create", argv[0]))
rc = rrd_create(argc, argv);
else if (!strcmp("update", argv[0]))
rc = rrd_update(argc, argv);
else if (!strcmp("restore", argv[0]))
rc = rrd_restore(argc, argv);
else if (!strcmp("dump", argv[0]))
rc = rrd_dump(argc, argv);
else if (!strcmp("tune", argv[0]))
rc = rrd_tune(argc, argv);
else if (!strcmp("last", argv[0]))
rc = rrd_last(argc, argv);
else if (!strcmp("resize", argv[0]))
rc = rrd_resize(argc, argv);
else if (!strcmp("fetch", argv[0]))
return _RRD_fetch(argc, argv);
else if (!strcmp("graph", argv[0])) {
return _RRD_graph(argc, argv);
}
else {
PyMem_DEL(argv);
PyErr_SetString(PyExc_TypeError,
"invalid action");
return NULL;
}
if (rc == -1) {
PyMem_DEL(argv);
PyErr_SetString(PyExc_ValueError,
rrd_get_error());
rrd_clear_error();
return NULL;
}
PyMem_DEL(argv);
return PyLong_FromLong(rc);
}
void
PyParser_Delete(parser_state *ps)
{
/* NB If you want to save the parse tree,
you must set p_tree to NULL before calling delparser! */
PyNode_Free(ps->p_tree);
PyMem_DEL(ps);
}
static void
poll_dealloc(pollObject *self)
{
if (self->ufds != NULL)
PyMem_DEL(self->ufds);
Py_XDECREF(self->dict);
PyObject_Del(self);
}
static void
Hyphen_dealloc(Hyphenobject *self) {
if (self->hdict != NULL) {
hnj_hyphen_free(self->hdict);
self->hdict = NULL;
}
PyMem_DEL(self);
}
static PyObject *tripledescbc_decrypt(tripledescbc *self, PyObject *args) {
// std::cout << "hello dec 0" << std::endl; std::cout.flush();
PyObject *result = NULL;
byte *plaintext = NULL;
try {
byte *iv;
unsigned int ivlength;
byte *text;
unsigned int textlength;
if(!PyArg_ParseTuple(args, "s#s#", &iv, &ivlength, &text, &textlength)) {
throw Exception(Exception::INVALID_ARGUMENT, "wrong type of parameters passed in from Python");
}
if(ivlength != 8) {
throw Exception(Exception::INVALID_ARGUMENT, "IV length must be 8");
}
CBC_CTS_Mode<DES_XEX3>::Decryption decryption(self->key, 24, iv);
plaintext = new byte[textlength];
if (plaintext == NULL) {
throw MemoryException();
}
StreamTransformationFilter decryptor(decryption, new ArraySink(plaintext, textlength));
decryptor.PutMessageEnd(text, textlength);
result = Py_BuildValue("s#", plaintext, textlength);
if(result == NULL) {
throw MemoryException();
}
xdeletear(plaintext);
return result;
}
catch(CryptoPP::Exception &e) {
if(result != NULL) {
PyMem_DEL(result);
}
xdeletear(plaintext);
PyErr_SetString(TripleDESCBCError, e.what());
return NULL;
}
catch(MemoryException &e) {
if(result != NULL) {
PyMem_DEL(result);
}
xdeletear(plaintext);
PyErr_SetString(PyExc_MemoryError, "Can't allocate memory to do decryption");
return NULL;
}
}
static void PyPolaris_PyDelete(PyObject *self)
{
polaris *pol;
pol = ((PyPolaris *)self)->pl_polaris;
plClose(pol);
PyMem_DEL(self);
}
static void
ilugi_dealloc(PyObject *o)
{
IlugiObject * v = (IlugiObject *) o;
v->id = ILU_NIL;
if (v->name != ILU_NIL)
ilu_free(v->name);
PyMem_DEL(o);
}
void deletekconvobject(PyObject *selfp){ //デストラクタ
kconvobject *self = (kconvobject*)selfp;
if(self->pinputer)
delete self->pinputer;
if(self->poutputer)
delete self->poutputer;
if(self->pchecker)
delete self->pchecker;
PyMem_DEL(self);
self = NULL;
}
static void
py_syck_node_free( SyckNode *self )
{
PyObject *value = PyObject_GetAttrString( (PyObject *)self, "value" );
Py_XDECREF( value );
if ( self->type_id != NULL )
S_FREE( self->type_id );
if ( self->anchor != NULL )
S_FREE( self->anchor );
S_FREE( self );
PyMem_DEL( self );
}
static void
ilual_dealloc(PyObject *o)
{
IlualObject * p = (IlualObject *) o;
if (p->alarm)
{
ilu_UnsetAlarm(p->alarm);
/* free(p->alarm); ? */
}
clearProcAndArgList(p);
PyMem_DEL(o);
}
int
PyRun_InteractiveOne(FILE *fp, char *filename)
{
PyObject *m, *d, *v, *w;
node *n;
perrdetail err;
char *ps1 = "", *ps2 = "";
v = PySys_GetObject("ps1");
if (v != NULL) {
v = PyObject_Str(v);
if (v == NULL)
PyErr_Clear();
else if (PyString_Check(v))
ps1 = PyString_AsString(v);
}
w = PySys_GetObject("ps2");
if (w != NULL) {
w = PyObject_Str(w);
if (w == NULL)
PyErr_Clear();
else if (PyString_Check(w))
ps2 = PyString_AsString(w);
}
n = PyParser_ParseFile(fp, filename, &_PyParser_Grammar,
Py_single_input, ps1, ps2, &err);
Py_XDECREF(v);
Py_XDECREF(w);
if (n == NULL) {
if (err.error == E_EOF) {
if (err.text)
PyMem_DEL(err.text);
return E_EOF;
}
err_input(&err);
PyErr_Print();
return err.error;
}
m = PyImport_AddModule("__main__");
if (m == NULL)
return -1;
d = PyModule_GetDict(m);
v = run_node(n, filename, d, d);
if (v == NULL) {
PyErr_Print();
return -1;
}
Py_DECREF(v);
if (Py_FlushLine())
PyErr_Clear();
return 0;
}
extern EXTERN_API void
cBananaState_dealloc(PyObject* self)
{
struct listItem* thatList;
struct listItem* thisList;
thisList = ((cBananaState*)self) -> currentList;
while (thisList) {
thatList = thisList->lastList;
Py_DECREF(thisList->thisList);
free(thisList);
thisList = thatList;
}
PyMem_DEL(self);
}
parser_state *
PyParser_New(grammar *g, int start)
{
parser_state *ps;
if (!g->g_accel)
PyGrammar_AddAccelerators(g);
ps = PyMem_NEW(parser_state, 1);
if (ps == NULL)
return NULL;
ps->p_grammar = g;
ps->p_generators = 0;
ps->p_tree = PyNode_New(start);
if (ps->p_tree == NULL) {
PyMem_DEL(ps);
return NULL;
}
s_reset(&ps->p_stack);
(void) s_push(&ps->p_stack, PyGrammar_FindDFA(g, start), ps->p_tree);
return ps;
}
static void
t_bootstrap(void *boot_raw)
{
struct bootstate *boot = (struct bootstate *) boot_raw;
PyThreadState *tstate;
PyObject *res;
tstate = boot->tstate;
tstate->thread_id = PyThread_get_thread_ident();
_PyThreadState_Init(tstate);
PyEval_AcquireThread(tstate);
res = PyEval_CallObjectWithKeywords(
boot->func, boot->args, boot->keyw);
if (res == NULL) {
if (PyErr_ExceptionMatches(PyExc_SystemExit))
PyErr_Clear();
else {
PyObject *file;
PySys_WriteStderr(
"Unhandled exception in thread started by ");
file = PySys_GetObject("stderr");
if (file != NULL && file != Py_None)
PyFile_WriteObject(boot->func, file, 0);
else
PyObject_Print(boot->func, stderr, 0);
PySys_WriteStderr("\n");
PyErr_PrintEx(0);
}
}
else
Py_DECREF(res);
Py_DECREF(boot->func);
Py_DECREF(boot->args);
Py_XDECREF(boot->keyw);
PyMem_DEL(boot_raw);
PyThreadState_Clear(tstate);
PyThreadState_DeleteCurrent();
PyThread_exit_thread();
}
static void
py_ao_dealloc(ao_Object *self)
{
ao_close(self->dev);
PyMem_DEL(self);
}
static void
py_ogg_packet_dealloc(PyObject *self)
{
PyMem_DEL(self);
}
static PyObject *tripledescbc_encrypt(tripledescbc *self, PyObject *args) {
// std::cout << "hello enc 0" << std::endl; std::cout.flush();
PyObject *result = NULL;
byte *ciphertext = NULL;
try {
byte *iv;
unsigned int ivlength;
byte *text;
unsigned int textlength;
if(!PyArg_ParseTuple(args, "s#s#", &iv, &ivlength, &text, &textlength)) {
throw Exception(Exception::INVALID_ARGUMENT, "wrong type of parameters passed in from Python");
}
if(ivlength != 8) {
throw Exception(Exception::INVALID_ARGUMENT, "IV length must be 8");
}
// std::cout << "hello enc 0.7" << std::endl; std::cout.flush();
// std::cout << "hello enc 0.7.1, self: " << self << std::endl; std::cout.flush();
// std::cout << "hello enc 0.7.2, self->key: ";
// std::cout << self->key;
// std::cout << std::endl;
// std::cout.flush();
// std::cout << "hello enc 0.7.3, iv: " << iv << std::endl; std::cout.flush();
CBC_CTS_Mode<DES_XEX3>::Encryption encryption(self->key, 24, iv);
// std::cout << "hello enc 0.8" << std::endl; std::cout.flush();
ciphertext = new byte[textlength];
// std::cout << "hello enc 0.9" << std::endl; std::cout.flush();
if (ciphertext == NULL) {
throw MemoryException();
}
// std::cout << "hello enc 1" << std::endl; std::cout.flush();
StreamTransformationFilter encryptor(encryption, new ArraySink(ciphertext, textlength));
// std::cout << "hello enc 2" << std::endl; std::cout.flush();
encryptor.PutMessageEnd(text, textlength);
// std::cout << "hello enc 3" << std::endl; std::cout.flush();
result = Py_BuildValue("s#", ciphertext, textlength);
// std::cout << "hello enc 4" << std::endl; std::cout.flush();
if(result == NULL) {
throw MemoryException();
}
// std::cout << "hello enc 5" << std::endl; std::cout.flush();
xdeletear(ciphertext);
// std::cout << "hello enc 6" << std::endl; std::cout.flush();
return result;
}
catch(CryptoPP::Exception &e) {
if(result != NULL) {
PyMem_DEL(result);
}
xdeletear(ciphertext);
PyErr_SetString(TripleDESCBCError, e.what());
return NULL;
}
catch(MemoryException &e) {
if(result != NULL) {
PyMem_DEL(result);
}
xdeletear(ciphertext);
PyErr_SetString(PyExc_MemoryError, "Can't allocate memory to do encryption");
return NULL;
}
// std::cout << "goodbye enc" << std::endl; std::cout.flush();
}
static PyObject *
select_select(PyObject *self, PyObject *args)
{
#ifdef SELECT_USES_HEAP
pylist *rfd2obj, *wfd2obj, *efd2obj;
#else /* !SELECT_USES_HEAP */
/* XXX: All this should probably be implemented as follows:
* - find the highest descriptor we're interested in
* - add one
* - that's the size
* See: Stevens, APitUE, $12.5.1
*/
pylist rfd2obj[FD_SETSIZE + 1];
pylist wfd2obj[FD_SETSIZE + 1];
pylist efd2obj[FD_SETSIZE + 1];
#endif /* SELECT_USES_HEAP */
PyObject *ifdlist, *ofdlist, *efdlist;
PyObject *ret = NULL;
PyObject *tout = Py_None;
fd_set ifdset, ofdset, efdset;
double timeout;
struct timeval tv, *tvp;
long seconds;
int imax, omax, emax, max;
int n;
/* convert arguments */
if (!PyArg_ParseTuple(args, "OOO|O:select",
&ifdlist, &ofdlist, &efdlist, &tout))
return NULL;
if (tout == Py_None)
tvp = (struct timeval *)0;
else if (!PyNumber_Check(tout)) {
PyErr_SetString(PyExc_TypeError,
"timeout must be a float or None");
return NULL;
}
else {
timeout = PyFloat_AsDouble(tout);
if (timeout == -1 && PyErr_Occurred())
return NULL;
if (timeout > (double)LONG_MAX) {
PyErr_SetString(PyExc_OverflowError,
"timeout period too long");
return NULL;
}
seconds = (long)timeout;
timeout = timeout - (double)seconds;
tv.tv_sec = seconds;
tv.tv_usec = (long)(timeout*1000000.0);
tvp = &tv;
}
#ifdef SELECT_USES_HEAP
/* Allocate memory for the lists */
rfd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1);
wfd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1);
efd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1);
if (rfd2obj == NULL || wfd2obj == NULL || efd2obj == NULL) {
if (rfd2obj) PyMem_DEL(rfd2obj);
if (wfd2obj) PyMem_DEL(wfd2obj);
if (efd2obj) PyMem_DEL(efd2obj);
return PyErr_NoMemory();
}
#endif /* SELECT_USES_HEAP */
/* Convert sequences to fd_sets, and get maximum fd number
* propagates the Python exception set in seq2set()
*/
rfd2obj[0].sentinel = -1;
wfd2obj[0].sentinel = -1;
efd2obj[0].sentinel = -1;
if ((imax=seq2set(ifdlist, &ifdset, rfd2obj)) < 0)
goto finally;
if ((omax=seq2set(ofdlist, &ofdset, wfd2obj)) < 0)
goto finally;
if ((emax=seq2set(efdlist, &efdset, efd2obj)) < 0)
goto finally;
max = imax;
if (omax > max) max = omax;
if (emax > max) max = emax;
Py_BEGIN_ALLOW_THREADS
n = select(max, &ifdset, &ofdset, &efdset, tvp);
Py_END_ALLOW_THREADS
#ifdef MS_WINDOWS
if (n == SOCKET_ERROR) {
PyErr_SetExcFromWindowsErr(SelectError, WSAGetLastError());
}
#else
if (n < 0) {
PyErr_SetFromErrno(SelectError);
}
#endif
else if (n == 0) {
/* optimization */
ifdlist = PyList_New(0);
if (ifdlist) {
ret = PyTuple_Pack(3, ifdlist, ifdlist, ifdlist);
Py_DECREF(ifdlist);
}
}
else {
/* any of these three calls can raise an exception. it's more
convenient to test for this after all three calls... but
is that acceptable?
*/
ifdlist = set2list(&ifdset, rfd2obj);
ofdlist = set2list(&ofdset, wfd2obj);
efdlist = set2list(&efdset, efd2obj);
if (PyErr_Occurred())
ret = NULL;
else
ret = PyTuple_Pack(3, ifdlist, ofdlist, efdlist);
Py_DECREF(ifdlist);
Py_DECREF(ofdlist);
Py_DECREF(efdlist);
}
finally:
reap_obj(rfd2obj);
reap_obj(wfd2obj);
reap_obj(efd2obj);
#ifdef SELECT_USES_HEAP
PyMem_DEL(rfd2obj);
PyMem_DEL(wfd2obj);
PyMem_DEL(efd2obj);
#endif /* SELECT_USES_HEAP */
return ret;
}
static void tripledescbc_delete(tripledescbc *self) {
if(self != NULL) {
xdeletear(self->key);
PyMem_DEL(self);
}
}
static void
err_input(perrdetail *err)
{
PyObject *v, *w, *errtype;
char *msg = NULL;
errtype = PyExc_SyntaxError;
v = Py_BuildValue("(ziiz)", err->filename,
err->lineno, err->offset, err->text);
if (err->text != NULL) {
PyMem_DEL(err->text);
err->text = NULL;
}
switch (err->error) {
case E_SYNTAX:
errtype = PyExc_IndentationError;
if (err->expected == INDENT)
msg = "expected an indented block";
else if (err->token == INDENT)
msg = "unexpected indent";
else if (err->token == DEDENT)
msg = "unexpected unindent";
else {
errtype = PyExc_SyntaxError;
msg = "invalid syntax";
}
break;
case E_TOKEN:
msg = "invalid token";
break;
case E_INTR:
PyErr_SetNone(PyExc_KeyboardInterrupt);
Py_XDECREF(v);
return;
case E_NOMEM:
PyErr_NoMemory();
Py_XDECREF(v);
return;
case E_EOF:
msg = "unexpected EOF while parsing";
break;
case E_TABSPACE:
errtype = PyExc_TabError;
msg = "inconsistent use of tabs and spaces in indentation";
break;
case E_OVERFLOW:
msg = "expression too long";
break;
case E_DEDENT:
errtype = PyExc_IndentationError;
msg = "unindent does not match any outer indentation level";
break;
case E_TOODEEP:
errtype = PyExc_IndentationError;
msg = "too many levels of indentation";
break;
default:
fprintf(stderr, "error=%d\n", err->error);
msg = "unknown parsing error";
break;
}
w = Py_BuildValue("(sO)", msg, v);
PyErr_SetObject(errtype, w);
Py_XDECREF(w);
if (v != NULL) {
PyObject *exc, *tb;
PyErr_Fetch(&errtype, &exc, &tb);
PyErr_NormalizeException(&errtype, &exc, &tb);
if (PyObject_SetAttrString(exc, "filename",
PyTuple_GET_ITEM(v, 0)))
PyErr_Clear();
if (PyObject_SetAttrString(exc, "lineno",
PyTuple_GET_ITEM(v, 1)))
PyErr_Clear();
if (PyObject_SetAttrString(exc, "offset",
PyTuple_GET_ITEM(v, 2)))
PyErr_Clear();
Py_DECREF(v);
PyErr_Restore(errtype, exc, tb);
}
}
static void Pixels_Dealloc (PixelsObject *self)
{
dbg();
gdk_pixbuf_unref (self->pixbuf);
PyMem_DEL (self);
}
static void
PyGtkPSFont_Dealloc(PyGtkPSFont_Object *self)
{
PyMem_DEL(self);
}
