mirror of
https://github.com/python/cpython.git
synced 2025-11-01 18:51:43 +00:00
New experimental modules -- signal and sybase
This commit is contained in:
Guido van Rossum
parent
b98b1b3deb
commit
398d9fec3c
2 changed files with 664 additions and 0 deletions
355
Modules/signalmodule.c
Normal file
355
Modules/signalmodule.c
Normal file
|
|
@ -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;
|
||||
}
|
||||
309
Modules/sybasemodule.c
Normal file
309
Modules/sybasemodule.c
Normal file
|
|
@ -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");
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue