New experimental modules -- signal and sybase

Modules/signalmodule.c

+/***********************************************************
+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;
+}

Modules/sybasemodule.c

+/*
+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");
+  }
+}