diff options
| -rw-r--r-- | Modules/signalmodule.c | 355 | ||||
| -rw-r--r-- | Modules/sybasemodule.c | 309 |
2 files changed, 664 insertions, 0 deletions
diff --git a/Modules/signalmodule.c b/Modules/signalmodule.c new file mode 100644 index 0000000..a2ed72a --- /dev/null +++ b/Modules/signalmodule.c @@ -0,0 +1,355 @@ +/*********************************************************** +Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum, +Amsterdam, The Netherlands. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +******************************************************************/ + +/* Signal module -- many thanks to Lance Ellinghouse */ + +#include "allobjects.h" +#include "modsupport.h" +#include "ceval.h" +#include "intrcheck.h" + +#include <signal.h> + +struct signalhandler_list { + int tripped; + object *func; +}; + +static struct signalhandler_list sig_list[NSIG]; + +static object *default_sig_object; +static object *default_ignore_object; +static object *default_int_object; + +static object * +default_int_handler(self, arg) + object *self; + object *arg; +{ + err_set(KeyboardInterrupt); + return NULL; +} + +static RETSIGTYPE +signal_handler(sig_num) + int sig_num; +{ + sig_list[sig_num].tripped = 1; + (void *)signal(sig_num, &signal_handler); +} + + +static object * +signal_signal(self, args) + object *self; /* Not used */ + object *args; +{ + object *obj; + int sig_num; + object *old_handler; + RETSIGTYPE (*func)(); + if (!getargs(args, "(iO)", &sig_num, &obj)) + return NULL; + if (sig_num < 1 || sig_num >= NSIG) { + err_setstr(ValueError, "signal number out of range"); + return NULL; + } + if (obj == default_ignore_object) + func = SIG_IGN; + else if (obj == default_sig_object) + func = SIG_DFL; + else if (!is_methodobject(obj) && + !is_funcobject(obj) && + !is_instancemethodobject(obj)) { + err_setstr(TypeError, +"signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object"); + return NULL; + } + else + func = signal_handler; + old_handler = sig_list[sig_num].func; + /* XXX is it always correct to clear tripped? */ + sig_list[sig_num].tripped = 0; + INCREF(obj); + sig_list[sig_num].func = obj; + signal(sig_num, func); + return old_handler; +} + +static object * +signal_getsignal(self, args) + object *self; /* Not used */ + object *args; +{ + int sig_num; + object *old_handler; + if (!getargs(args, "i", &sig_num)) + return NULL; + if (sig_num < 1 || sig_num >= NSIG) { + err_setstr(ValueError, "signal number out of range"); + return NULL; + } + old_handler = sig_list[sig_num].func; + INCREF(old_handler); + return old_handler; +} + + +/* List of functions defined in the module */ + +static struct methodlist signal_methods[] = { + {"signal", signal_signal}, + {"getsignal", signal_getsignal}, + {NULL, NULL} /* sentinel */ +}; + +void +initsignal() +{ + object *m, *d, *x; + object *b_dict; + int i; + /* Create the module and add the functions */ + m = initmodule("signal", signal_methods); + + /* Add some symbolic constants to the module */ + d = getmoduledict(m); + + default_sig_object = newintobject((long)SIG_DFL); + dictinsert(d, "SIG_IGN", default_sig_object); + default_ignore_object = newintobject((long)SIG_IGN); + dictinsert(d, "SIG_DFL", default_ignore_object); + default_int_object = newmethodobject("default_int_handler", + default_int_handler, + (object *)NULL, + 0); + dictinsert(d, "default_int_handler", default_int_object); + + sig_list[0].tripped = 0; + for (i = 1; i < NSIG; i++) { + void *t; /* type cop-out */ + t = signal(i, SIG_IGN); + signal(i, t); + sig_list[i].tripped = 0; + if (t == SIG_DFL) + sig_list[i].func = default_sig_object; + else if (t == SIG_IGN) + sig_list[i].func = default_ignore_object; + else + sig_list[i].func = None; /* None of our business */ + INCREF(sig_list[i].func); + } + if (sig_list[SIGINT].func == default_sig_object) { + /* Install default int handler */ + DECREF(sig_list[SIGINT].func); + sig_list[SIGINT].func = default_int_object; + INCREF(default_int_object); + signal(SIGINT, &signal_handler); + } + +#ifdef SIGHUP + x = newintobject(SIGHUP); + dictinsert(d, "SIGHUP", x); +#endif +#ifdef SIGINT + x = newintobject(SIGINT); + dictinsert(d, "SIGINT", x); +#endif +#ifdef SIGQUIT + x = newintobject(SIGQUIT); + dictinsert(d, "SIGQUIT", x); +#endif +#ifdef SIGILL + x = newintobject(SIGILL); + dictinsert(d, "SIGILL", x); +#endif +#ifdef SIGTRAP + x = newintobject(SIGTRAP); + dictinsert(d, "SIGTRAP", x); +#endif +#ifdef SIGIOT + x = newintobject(SIGIOT); + dictinsert(d, "SIGIOT", x); +#endif +#ifdef SIGABRT + x = newintobject(SIGABRT); + dictinsert(d, "SIGABRT", x); +#endif +#ifdef SIGEMT + x = newintobject(SIGEMT); + dictinsert(d, "SIGEMT", x); +#endif +#ifdef SIGFPE + x = newintobject(SIGFPE); + dictinsert(d, "SIGFPE", x); +#endif +#ifdef SIGKILL + x = newintobject(SIGKILL); + dictinsert(d, "SIGKILL", x); +#endif +#ifdef SIGBUS + x = newintobject(SIGBUS); + dictinsert(d, "SIGBUS", x); +#endif +#ifdef SIGSEGV + x = newintobject(SIGSEGV); + dictinsert(d, "SIGSEGV", x); +#endif +#ifdef SIGSYS + x = newintobject(SIGSYS); + dictinsert(d, "SIGSYS", x); +#endif +#ifdef SIGPIPE + x = newintobject(SIGPIPE); + dictinsert(d, "SIGPIPE", x); +#endif +#ifdef SIGALRM + x = newintobject(SIGALRM); + dictinsert(d, "SIGALRM", x); +#endif +#ifdef SIGTERM + x = newintobject(SIGTERM); + dictinsert(d, "SIGTERM", x); +#endif +#ifdef SIGUSR1 + x = newintobject(SIGUSR1); + dictinsert(d, "SIGUSR1", x); +#endif +#ifdef SIGUSR2 + x = newintobject(SIGUSR2); + dictinsert(d, "SIGUSR2", x); +#endif +#ifdef SIGCLD + x = newintobject(SIGCLD); + dictinsert(d, "SIGCLD", x); +#endif +#ifdef SIGCHLD + x = newintobject(SIGCHLD); + dictinsert(d, "SIGCHLD", x); +#endif +#ifdef SIGPWR + x = newintobject(SIGPWR); + dictinsert(d, "SIGPWR", x); +#endif +#ifdef SIGIO + x = newintobject(SIGIO); + dictinsert(d, "SIGIO", x); +#endif +#ifdef SIGURG + x = newintobject(SIGURG); + dictinsert(d, "SIGURG", x); +#endif +#ifdef SIGWINCH + x = newintobject(SIGWINCH); + dictinsert(d, "SIGWINCH", x); +#endif +#ifdef SIGPOLL + x = newintobject(SIGPOLL); + dictinsert(d, "SIGPOLL", x); +#endif +#ifdef SIGSTOP + x = newintobject(SIGSTOP); + dictinsert(d, "SIGSTOP", x); +#endif +#ifdef SIGTSTP + x = newintobject(SIGTSTP); + dictinsert(d, "SIGTSTP", x); +#endif +#ifdef SIGCONT + x = newintobject(SIGCONT); + dictinsert(d, "SIGCONT", x); +#endif +#ifdef SIGTTIN + x = newintobject(SIGTTIN); + dictinsert(d, "SIGTTIN", x); +#endif +#ifdef SIGTTOU + x = newintobject(SIGTTOU); + dictinsert(d, "SIGTTOU", x); +#endif +#ifdef SIGVTALRM + x = newintobject(SIGVTALRM); + dictinsert(d, "SIGVTALRM", x); +#endif +#ifdef SIGPROF + x = newintobject(SIGPROF); + dictinsert(d, "SIGPROF", x); +#endif +#ifdef SIGCPU + x = newintobject(SIGCPU); + dictinsert(d, "SIGCPU", x); +#endif +#ifdef SIGFSZ + x = newintobject(SIGFSZ); + dictinsert(d, "SIGFSZ", x); +#endif + /* Check for errors */ + if (err_occurred()) + fatal("can't initialize module signal"); +} + +int +sigcheck() +{ + int i; + object *f = getframe(); + if (f == NULL) + f = None; + for (i = 1; i < NSIG; i++) { + if (sig_list[i].tripped) { + object *arglist, *result; + sig_list[i].tripped = 0; + arglist = mkvalue("(iO)", i, f); + if (arglist == NULL) + result = NULL; + else { + result = call_object(sig_list[i].func,arglist); + DECREF(arglist); + } + if (result == NULL) { + return 1; + } else { + DECREF(result); + } + } + } + return 0; +} + +/* Replacement for intrcheck.c functionality */ + +void +initintr() +{ + initsignal(); +} + +int +intrcheck() +{ + if (!sigcheck()) + return 0; + err_clear(); + return 1; +} diff --git a/Modules/sybasemodule.c b/Modules/sybasemodule.c new file mode 100644 index 0000000..860203f --- /dev/null +++ b/Modules/sybasemodule.c @@ -0,0 +1,309 @@ +/* +Subject: Re: Sybase module -- input sought +From: jredford@lehman.com +To: ags@uncompaghre.informatics.jax.org (Alexander G. Smith) +Cc: python-list@cwi.nl +Date: Tue, 10 May 94 11:53:13 -0400 + + +input sought? how about a complete module? :) + +This is a fairly incomplete work.. but I have done things dramatically +differently than sybperl would. Given the nature of the language I +find it is easier to simply get ALL results & then muck with the rows +later as parts of the data. This is a subset of the functionality of a +Modula-3 interface to Sybase that I wrote.. I could send you that if +you are interested in a more complete picture. +*/ + +#include <stdio.h> + +#include <sybfront.h> +#include <sybdb.h> + +#include "allobjects.h" +#include "modsupport.h" + + +static object *SybaseError; /* exception sybase.error */ + + +typedef struct { + OB_HEAD + LOGINREC *login; /* login record */ + DBPROCESS *dbproc; /* login record */ +} sybdbobject; + +extern typeobject SybDbtype; /* Forward */ + + +static sybdbobject * + newsybdbobject(char *user, char *passwd, char *server) +{ + sybdbobject *s; + + s = NEWOBJ(sybdbobject, &SybDbtype); + if (s != NULL) { + s->login = dblogin(); + if (user) { + (void)DBSETLUSER(s->login, user); + } + if (passwd) { + (void)DBSETLPWD(s->login, passwd); + } + if(!(s->dbproc = dbopen(s->login, server))) { + dbloginfree(s->login); + DEL(s); + return (NULL); + } + } + return s; +} + +/* OBJECT FUNCTIONS: sybdb */ + +/* Common code for returning pending results */ +static object + *getresults (DBPROCESS *dbp) +{ + object *results; + object *list; + object *tuple; + object *o; + int retcode; + int cols; + int *fmt; + int i; + + results = newlistobject(0); + while ((retcode = dbresults(dbp)) != NO_MORE_RESULTS) { + if (retcode == SUCCEED && DBROWS(dbp) == SUCCEED) { + list = newlistobject(0); + cols = dbnumcols(dbp); + fmt = (int *)malloc(sizeof(int) * cols); + for (i = 1; i <= cols; i++) { + switch(dbcoltype(dbp, i)) { + case SYBCHAR: + fmt[i-1] = SYBCHAR; + break; + case SYBINT1: + fmt[i-1] = SYBINT1; + break; + case SYBINT2: + fmt[i-1] = SYBINT2; + break; + case SYBINT4: + fmt[i-1] = SYBINT4; + break; + case SYBFLT8: + fmt[i-1] = SYBFLT8; + break; + } + } + while (dbnextrow(dbp) != NO_MORE_ROWS) { + tuple = newtupleobject(cols); + for (i = 1; i <= cols; i++) { + switch(fmt[i-1]) { + case SYBCHAR: + o = newsizedstringobject((char *)dbdata(dbp, i), dbdatlen(dbp, i)); + settupleitem(tuple, i-1, o); + break; + case SYBINT1: + o = newintobject(*((char *)dbdata(dbp, i))); + settupleitem(tuple, i-1, o); + break; + case SYBINT2: + o = newintobject(*((short *)dbdata(dbp, i))); + settupleitem(tuple, i-1, o); + break; + case SYBINT4: + o = newintobject(*((int *)dbdata(dbp, i))); + settupleitem(tuple, i-1, o); + break; + case SYBFLT8: + o = newfloatobject(*((double *)dbdata(dbp, i))); + settupleitem(tuple, i-1, o); + break; + } + } + addlistitem(list,tuple); + } + free(fmt); + addlistitem(results,list); + } + } + return (results); +} + +static object + *sybdb_sql (self, args) +object *self; +object *args; +{ + char *sql; + DBPROCESS *dbp; + + dbp = ((sybdbobject *)self)->dbproc; + err_clear (); + if (!getargs (args, "s", &sql)) { + return NULL; + } + dbcancel(dbp); + dbcmd(dbp, sql); + dbsqlexec(dbp); + return getresults(dbp); +} + +static object + *sybdb_sp (self, args) +object *self; +object *args; +{ + char *sp; + DBPROCESS *dbp; + object *spargs; + object *sparg; + object *results; + object *r; + int spargcnt; + int i; + int retstatus; + + dbp = ((sybdbobject *)self)->dbproc; + err_clear (); + if (!getargs (args, "(sO)", &sp, &spargs)) { + return NULL; + } + + dbcancel(dbp); + dbrpcinit(dbp, sp, 0); + + if (is_tupleobject(spargs)) { + spargcnt=gettuplesize(spargs); + for (i=0; i < spargcnt; i++) { + sparg = gettupleitem(spargs,i); + if (is_intobject(sparg)) { + int i; + i = getintvalue(sparg); + dbrpcparam(dbp, NULL, 0, SYBINT4, -1, -1, &i); + } else if (is_floatobject(sparg)) { + double i; + i = getfloatvalue(sparg); + dbrpcparam(dbp, NULL, 0, SYBFLT8, -1, -1, &i); + } else if (is_stringobject(sparg)) { + dbrpcparam(dbp, NULL, 0, SYBCHAR, -1, getstringsize(sparg), getstringvalue(sparg)); + } else { + err_setstr (SybaseError, "Could not handle paramaters to procedure."); + return NULL; + } + } + } else if (spargs != None) { + err_setstr (SybaseError, "Could not handle paramaters to procedure."); + return NULL; + } + dbrpcsend(dbp); + dbsqlok(dbp); + + results = getresults(dbp); + retstatus = dbretstatus(dbp); + + r = mkvalue("(iO)", retstatus, results); + DECREF(results); + return (r); +} + + +static struct methodlist sybdb_methods[] = { + {"sql", sybdb_sql}, + {"sp", sybdb_sp}, + {NULL, NULL} /* sentinel */ +}; + +static void +sybdb_dealloc(s) + sybdbobject *s; +{ + dbloginfree(s->login); + dbclose(s->dbproc); + DEL(s); +} + +static object * +sybdb_getattr(s, name) + sybdbobject *s; + char *name; +{ + return findmethod(sybdb_methods, (object *) s, name); +} + + +typeobject SybDbtype = { + OB_HEAD_INIT(&Typetype) + 0, + "sybdb", + sizeof(sybdbobject), + 0, + sybdb_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + sybdb_getattr, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ +}; + + + + + +/* MODULE FUNCTIONS: sybase */ + +static object + *sybase_new (self, args) +object *self; /* Not used */ +object *args; +{ + char *user, *passwd, *server; + object *db; + + err_clear (); + if (!getargs (args, "(zzz)", &user, &passwd, &server)) { + return NULL; + } + db = (object *) newsybdbobject(user, passwd, server); + if (!db) { + /* XXX Should be setting some errstr stuff here based on sybase errors */ + err_setstr (SybaseError, "Could not open connection to server."); + return NULL; + } + return db; +} + + +/* List of module functions */ +static struct methodlist sybase_methods[]= +{ + {"new", sybase_new}, + {NULL, NULL} /* sentinel */ +}; + +/* Module initialisation */ +void initsybase () +{ + object *m, *d; + + /* Create the module and add the functions */ + m = initmodule ("sybase", sybase_methods); + /* Add some symbolic constants to the module */ + d = getmoduledict (m); + SybaseError = newstringobject ("sybase.error"); + if (SybaseError == NULL || dictinsert (d, "error", SybaseError) != 0) { + fatal ("can't define sybase.error"); + } + /* Check for errors */ + if (err_occurred ()){ + fatal ("can't initialize module sybase"); + } +} |