Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Removed environment, objc, sybase modules

This commit is contained in:
Guido van Rossum 1996-08-21 22:15:03 +00:00
parent f00eb71d90
commit 4f903463b8
3 changed files with 0 additions and 1064 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
Modules/environment.c
View File

@ -1,104 +0,0 @@
/*
# Copyright 1995, InfoSeek Corporation
# All rights reserved.
# Written by Andy Bensky
#
# Permission to use, copy, modify, and distribute this Python software
# and its associated documentation for any purpose (subject to the
# restriction in the following sentence) without fee is hereby granted,
# provided that the above copyright notice appears in all copies, and
# that both that copyright notice and this permission notice appear in
# supporting documentation, and that the name of InfoSeek not be used in
# advertising or publicity pertaining to distribution of the software
# without specific, prior written permission. This permission is
# explicitly restricted to the copying and modification of the software
# to remain in Python, compiled Python, or other languages (such as C)
# wherein the modified or derived code is exclusively imported into a
# Python module.
#
# INFOSEEK CORPORATION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
# FITNESS. IN NO EVENT SHALL INFOSEEK CORPORATION BE LIABLE FOR ANY
# DIRECT, 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,
# EVEN IF INFOSEEK SHALL HAVE BEEN MADE AWARE OF THE POSSIBILITY OF SUCH
# DAMAGES.
*/
/* Hooks to call the Unix putenv() to modify the environment
*/
#include "allobjects.h"
#include <stdlib.h>
#include <assert.h>
#include <string.h>
/* Error conditions that can be raised */
/* Headers for functions accessible from Python as module methods */
static object *put_environ( object *self, object *args );
static struct methodlist environ_methods[] = {
{"putenv", put_environ},
{NULL, NULL}
};
/*
* Name: initenvironment
* Description:
* Initialzation function that Python will use to establish callbacks to
* the methods of this module.
*
* Returns:
* void -
*
* Notes:
*/
void initenvironment()
{
object *m, *d;
m = initmodule("environment", environ_methods);
d = getmoduledict(m);
}
/*
* Name: put_environ
* Description:
* accepts 2 string objects as arguments and forms a string of the
* form string1=string2 that can be passed to the putenv() system call.
*
* Returns:
* None object if successfull, otherwise raises a SystemError exception
*
*
* Notes:
*/
static object *put_environ( object *self, object *args )
{
char *string1, *string2;
char *set_str;
object *return_object = None;
if (args && getargs(args, "(ss)", &string1, &string2))
{
set_str = malloc(strlen(string1) + strlen(string2) + 2);
assert( set_str );
(void) sprintf(set_str, "%s=%s", string1, string2);
if ( putenv( set_str ) )
{
err_setstr(SystemError, "Error in system putenv call.");
return_object = 0;
}
}
else
{
err_setstr(TypeError, "Usage: putenv(string1, string2)");
return_object = 0;
}
return( return_object );
}

651
Modules/objc.c
View File

@ -1,651 +0,0 @@
/***********************************************************
Copyright 1991-1995 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.
******************************************************************/
/* Objective-C interface for NeXTStep */
/* Tested with NeXTStep 3.3 on Intel and Sparc architectures */
/* Original author: Jon M. Kutemeier */
/* Revamped and maintained by: Guido van Rossum */
/* XXX To do:
- bug??? x.send('name', []) gives weird error
- rename functions from objc_* to ObjC_*
- change send(sel, [a, b, c]) to send(self, a, b, c)
- call back to Python from Objective-C
*/
/* Python header file */
#include "Python.h"
/* NeXT headers */
#include <sys/param.h>
#include <mach-o/rld.h>
#include <objc/objc.h>
#include <objc/objc-runtime.h>
#import <remote/NXProxy.h>
/* Distinguish between ObjC classes and instances */
typedef enum {
OBJC_CLASS,
OBJC_INSTANCE,
} ObjC_Typecode;
/* Exception raised for ObjC specific errors */
static PyObject *ObjC_Error;
/* Python wrapper about ObjC id (instance or class) */
typedef struct {
PyObject_HEAD
id obj;
ObjC_Typecode type;
int owned;
} ObjCObject;
/* Corresponding Python type object */
staticforward PyTypeObject ObjC_Type;
/* Corresponding Python type check macro */
#define ObjC_Check(o) ((o)->ob_type == &ObjC_Type)
/* Create a new ObjCObject */
static ObjCObject *
newObjCObject(obj, type, owned)
id obj;
ObjC_Typecode type;
int owned;
{
ObjCObject *self;
self = PyObject_NEW(ObjCObject, &ObjC_Type);
if (self == NULL)
return NULL;
self->obj = obj;
self->type = type;
self->owned = owned;
return self;
}
static void
objc_sendfree(self)
ObjCObject *self;
{
if (self->obj)
self->obj = (id)objc_msgSend(self->obj, SELUID("free"));
}
/* Deallocate an ObjCObject */
static void
objc_dealloc(self)
ObjCObject *self;
{
if (self->owned)
objc_sendfree(self);
PyMem_DEL(self);
}
/* Return a string representation of an ObjCObject */
static PyObject *
objc_repr(self)
ObjCObject *self;
{
char buffer[512];
char *p = buffer;
if (self->obj == nil)
p = "<Objective-C nil>";
else {
char *t;
switch (self->type) {
case OBJC_CLASS: t = "class"; break;
case OBJC_INSTANCE: t = "instance"; break;
default: t = "???"; break;
}
sprintf(buffer, "<Objective-C %s %s at %lx>",
NAMEOF(self->obj), t, (long)(self->obj));
}
return PyString_FromString(p);
}
/*** ObjCObject methods ***/
/* Call an object's free method */
static PyObject *
objc_free(self, args)
ObjCObject *self;
PyObject *args;
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
objc_sendfree(self);
}
/* Send a message to an ObjCObject.
The Python call looks like e.g. obj.send('moveTo::', [arg1, arg2])
which translates into Objective-C as [obj moveTo: arg1 : arg2] */
static PyObject *
objc_send(self, args)
ObjCObject *self;
PyObject *args;
{
char *methodname;
char *margBuff = NULL;
PyObject *retobject = NULL;
PyObject *arglist;
id receiver, obj;
char *type;
SEL sel;
Method meth;
unsigned int margCount, margSize;
int offset, i;
if (!PyArg_ParseTuple(args, "sO!", &methodname, &PyList_Type, &arglist))
return NULL;
/* Get the method descriptor from the object */
receiver = self->obj;
sel = SELUID(methodname);
switch(self->type) {
case OBJC_CLASS:
meth = class_getClassMethod(receiver->isa, sel);
break;
case OBJC_INSTANCE:
meth = class_getInstanceMethod(receiver->isa, sel);
break;
default:
PyErr_SetString(ObjC_Error,
"receiver's type is neither instance not class!?!?");
return NULL;
}
if (!meth) {
PyErr_SetString(ObjC_Error, "receiver has no method by that name");
return NULL;
}
/* Fill in the argument list, type-checking the arguments */
margCount = method_getNumberOfArguments(meth);
if (PyList_Size(arglist) + 2 != margCount) {
PyErr_SetString(ObjC_Error,
"wrong number of arguments for this method");
return NULL;
}
margSize = method_getSizeOfArguments(meth);
margBuff = PyMem_NEW(char, margSize+1);
if (margBuff == NULL)
return PyErr_NoMemory();
method_getArgumentInfo(meth, 0, &type, &offset);
marg_setValue(margBuff, offset, id, receiver);
method_getArgumentInfo(meth, 1, &type, &offset);
marg_setValue(margBuff, offset, SEL, sel);
for (i = 2; i < margCount; i++) {
PyObject *argument;
method_getArgumentInfo(meth, i, &type, &offset);
argument = PyList_GetItem(arglist, i-2);
/* scan past protocol-type modifiers */
while (strchr("rnNoOV", *type) != 0)
type++;
/* common type checks */
switch(*type) {
/* XXX The errors here should point out which argument */
case 'c':
case '*':
case 'C':
if (!PyString_Check(argument)) {
PyErr_SetString(ObjC_Error, "string argument expected");
goto error;
}
break;
case 'i':
case 's':
case 'I':
case 'S':
case 'l':
case 'L':
case '^':
if (!PyInt_Check(argument)) {
PyErr_SetString(ObjC_Error, "integer argument expected");
goto error;
}
break;
case 'f':
case 'd':
if (!PyFloat_Check(argument)) {
PyErr_SetString(ObjC_Error, "float argument expected");
goto error;
}
break;
}
/* convert and store the argument */
switch (*type) {
case 'c': /* char */
marg_setValue(margBuff, offset, char,
PyString_AsString(argument)[0]);
break;
case 'C': /* unsigned char */
marg_setValue(margBuff, offset, unsigned char,
PyString_AsString(argument)[0]);
break;
case '*': /* string */
marg_setValue(margBuff, offset, char *,
PyString_AsString(argument));
break;
case 'i': /* int */
marg_setValue(margBuff, offset, int,
PyInt_AsLong(argument));
break;
case 'I': /* unsigned int */
marg_setValue(margBuff, offset, unsigned int,
PyInt_AsLong(argument));
break;
case 's': /* short */
marg_setValue(margBuff, offset, short,
PyInt_AsLong(argument));
break;
case 'S': /* unsigned short */
marg_setValue(margBuff, offset, unsigned short,
PyInt_AsLong(argument));
break;
case 'l': /* long */
marg_setValue(margBuff, offset, long,
PyInt_AsLong(argument));
break;
case 'L': /* unsigned long */
marg_setValue(margBuff, offset, unsigned long,
PyInt_AsLong(argument));
break;
case 'f': /* float */
marg_setValue(margBuff, offset, float,
(float)PyFloat_AsDouble(argument));
break;
case 'd': /* double */
marg_setValue(margBuff, offset, double,
PyFloat_AsDouble(argument));
break;
case '@': /* id (or None) */
if (ObjC_Check(argument))
marg_setValue(margBuff, offset, id,
((ObjCObject *)(argument))->obj);
else if (argument == Py_None)
marg_setValue(margBuff, offset, id, nil);
else {
PyErr_SetString(ObjC_Error, "id or None argument expected");
goto error;
}
break;
case '^': /* void * (use int) */
marg_setValue(margBuff, offset, void *,
(void *)PyInt_AsLong(argument));
break;
case ':': /* SEL (use string or int) */
if (PyInt_Check(argument))
marg_setValue(margBuff, offset, SEL,
(SEL)PyInt_AsLong(argument));
else if (PyString_Check(argument))
marg_setValue(margBuff, offset, SEL,
SELUID(PyString_AsString(argument)));
else {
PyErr_SetString(ObjC_Error,
"selector string or int argument expected");
goto error;
}
break;
case '#': /* Class (may also use int) */
if (ObjC_Check(argument) &&
((ObjCObject *)argument)->type == OBJC_INSTANCE)
marg_setValue(margBuff, offset, Class *,
(Class *)((ObjCObject *)argument)->obj);
else if (PyInt_Check(argument))
marg_setValue(margBuff, offset, Class *,
(Class *)PyInt_AsLong(argument));
else {
PyErr_SetString(ObjC_Error,
"ObjC class object required");
goto error;
}
break;
default:
PyErr_SetString(ObjC_Error, "unknown argument type");
goto error;
}
}
/* Call the method and set the return value */
type = meth->method_types;
while (strchr("rnNoOV", *type))
type++;
switch(*type) {
/* Cast objc_msgSendv to a function returning the right thing */
#define MS_CAST(type) ((type (*)())objc_msgSendv)
case 'c':
case '*':
case 'C':
retobject = (PyObject *)PyString_FromString(
MS_CAST(char *)(receiver, sel, margSize, margBuff));
break;
case 'i':
case 's':
case 'I':
case 'S':
retobject = (PyObject *)PyInt_FromLong(
MS_CAST(int)(receiver, sel, margSize, margBuff));
break;
case 'l':
case 'L':
case '^':
retobject = (PyObject *)PyInt_FromLong(
MS_CAST(long)(receiver, sel, margSize, margBuff));
break;
case 'f':
retobject = (PyObject *)PyFloat_FromDouble(
MS_CAST(float)(receiver, sel, margSize, margBuff));
break;
case 'd':
retobject = (PyObject *)PyFloat_FromDouble(
MS_CAST(double)(receiver, sel, margSize, margBuff));
break;
case '@':
obj = MS_CAST(id)(receiver, sel, margSize, margBuff);
if (obj == nil) {
retobject = Py_None;
Py_INCREF(retobject);
}
else if (obj != receiver)
retobject = (PyObject *)newObjCObject(obj, OBJC_INSTANCE, 0);
else {
retobject = (PyObject *)self;
Py_INCREF(retobject);
}
break;
case ':':
retobject = (PyObject *)PyInt_FromLong(
(long)MS_CAST(SEL)(receiver, sel, margSize, margBuff));
break;
case '#':
retobject = (PyObject *)PyInt_FromLong(
(long)MS_CAST(Class *)(receiver, sel, margSize, margBuff));
break;
#undef MS_CAST
}
error:
PyMem_XDEL(margBuff);
return retobject;
}
/* List of methods for ObjCObject */
static PyMethodDef objc_methods[] = {
{"send", (PyCFunction)objc_send, 1},
{"free", (PyCFunction)objc_free, 1},
{NULL, NULL} /* sentinel */
};
/* Get an attribute of an ObjCObject */
static PyObject *
objc_getattr(self, name)
ObjCObject *self;
char *name;
{
PyObject *method;
/* Try a function method */
method = Py_FindMethod(objc_methods, (PyObject *)self, name);
if (method != NULL)
return method;
PyErr_Clear();
/* Try an instance variable */
if (strcmp(name, "obj") == 0)
return PyInt_FromLong((long)self->obj);
if (strcmp(name, "type") == 0)
return PyInt_FromLong((long)self->type);
if (strcmp(name, "owned") == 0)
return PyInt_FromLong((long)self->owned);
if (strcmp(name, "name") == 0)
return PyString_FromString(NAMEOF(self->obj));
if (strcmp(name, "__members__") == 0)
return Py_BuildValue("[sss]", "name", "obj", "owned", "type");
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
/* The type object */
static PyTypeObject ObjC_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"objc", /*tp_name*/
sizeof(ObjCObject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)objc_dealloc, /*tp_dealloc*/
0, /*tp_print*/
(getattrfunc)objc_getattr, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare*/
(reprfunc)objc_repr, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, 0, 0, 0, /*xxx1-4*/
"Objective-C id wrapper", /*tp_doc*/
};
/*** Top-level functions ***/
/* Max #files passed to loadobjectfile() */
#define MAXRLD 128
/* Load a list of object files */
static PyObject *
objc_loadobjectfiles(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
NXStream *errorStream;
struct mach_header *new_header;
const char *filenames[MAXRLD+1];
long ret;
char *streamBuf;
PyObject *filelist, *file;
int listsize, len, maxLen, i;
if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &filelist))
return NULL;
listsize = PyList_Size(filelist);
if (listsize > MAXRLD) {
PyErr_SetString(ObjC_Error, "more than 128 files in list");
return NULL;
}
errorStream = NXOpenMemory(NULL, 0, NX_WRITEONLY);
for (i = 0; i < listsize; i++) {
file = PyList_GetItem(filelist, i);
if (!PyString_Check(file))
{
PyErr_SetString(ObjC_Error,
"all list items must be strings");
return NULL;
}
filenames[i] = PyString_AsString(file);
}
filenames[listsize] = NULL;
ret = objc_loadModules(filenames, errorStream, NULL, &new_header, NULL);
/* extract the error messages for the exception */
if(ret) {
NXPutc(errorStream, (char)0);
NXGetMemoryBuffer(errorStream, &streamBuf, &len, &maxLen);
PyErr_SetString(ObjC_Error, streamBuf);
}
NXCloseMemory(errorStream, NX_FREEBUFFER);
if(ret)
return NULL;
Py_XINCREF(Py_None);
return Py_None;
}
static PyObject *
objc_lookupclass(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
char *classname;
id class;
if (!PyArg_ParseTuple(args, "s", &classname))
return NULL;
if (!(class = objc_lookUpClass(classname)))
{
PyErr_SetString(ObjC_Error, "unknown ObjC class");
return NULL;
}
return (PyObject *)newObjCObject(class, OBJC_CLASS, 0);
}
/* List all classes */
static PyObject *
objc_listclasses(self, args)
ObjCObject *self;
PyObject *args;
{
NXHashTable *class_hash = objc_getClasses();
NXHashState state = NXInitHashState(class_hash);
Class classid;
PyObject *list;
if (!PyArg_ParseTuple(args, ""))
return NULL;
list = PyList_New(0);
if (list == NULL)
return NULL;
while (NXNextHashState(class_hash, &state, (void**)&classid)) {
ObjCObject *item = newObjCObject(classid, OBJC_CLASS, 0);
if (item == NULL || PyList_Append(list, (PyObject *)item) < 0) {
Py_XDECREF(item);
Py_DECREF(list);
return NULL;
}
Py_INCREF(item);
}
return list;
}
/* List of top-level functions */
static PyMethodDef objc_class_methods[] = {
{"loadobjectfiles", objc_loadobjectfiles, 1},
{"lookupclass", objc_lookupclass, 1},
{"listclasses", objc_listclasses, 1},
{NULL, NULL} /* sentinel */
};
/* Initialize for the module */
void
initobjc()
{
PyObject *m, *d;
m = Py_InitModule("objc", objc_class_methods);
d = PyModule_GetDict(m);
ObjC_Error = PyString_FromString("objc.error");
PyDict_SetItemString(d, "error", ObjC_Error);
if (PyErr_Occurred())
Py_FatalError("can't initialize module objc");
#ifdef WITH_THREAD
objc_setMultithreaded(1);
#endif
}

309
Modules/sybasemodule.c
View File

@ -1,309 +0,0 @@
/*
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");
}
}