diff options
Diffstat (limited to 'RISCOS/Modules/swimodule.c')
| -rw-r--r-- | RISCOS/Modules/swimodule.c | 431 |
1 files changed, 431 insertions, 0 deletions
diff --git a/RISCOS/Modules/swimodule.c b/RISCOS/Modules/swimodule.c new file mode 100644 index 0000000..12908d5 --- /dev/null +++ b/RISCOS/Modules/swimodule.c @@ -0,0 +1,431 @@ +/* swi + + RISC OS swi functions + + 1.00 Chris Stretch + + + 1.01 12 May 1999 Laurence Tratt + + * Changed swi.error to be a class based exception rather than string based + * Added swi.ArgError which is generated for errors when the user passes invalid arguments to + functions etc + * Added "errnum" attribute to swi.error, so one can now check to see what the error number was +*/ + +#include "h.os" +#include "h.kernel" +#include "Python.h" + +#include <errno.h> + +#define PyBlock_Check(op) ((op)->ob_type == &PyBlockType) + + +static PyObject *SwiError; /* Exception swi.error */ +static PyObject *ArgError; /* Exception swi.ArgError */ +static os_error *e; + +static PyObject *swi_oserror(void) +{ PyErr_SetString(SwiError,e->errmess); + PyObject_SetAttrString(PyErr_Occurred(), "errnum", PyInt_FromLong(e->errnum)); + return 0; +} + +static PyObject *swi_error(char *s) +{ PyErr_SetString(ArgError,s); + return 0; +} + +typedef struct +{ PyObject_HEAD + void *block; + int length; /*length in bytes*/ + int heap; +} PyBlockObject; + +static PyTypeObject PyBlockType; + +/* block commands */ + +static PyObject *PyBlock_New(PyObject *self,PyObject *args) +{ int size; + PyBlockObject *b; + PyObject *init=0; + if(!PyArg_ParseTuple(args,"i|O",&size,&init)) return NULL; + if(size<1) size=1; + b=PyObject_NEW(PyBlockObject,&PyBlockType); + if(!b) return NULL; + b->block=malloc(4*size); + if(!b->block) + { Py_DECREF(b); + return PyErr_NoMemory(); + } + b->length=4*size; + b->heap=1; + if(init) + { if(PyString_Check(init)) + { int n=PyString_Size(init); + if (n>4*size) n=4*size; + memcpy(b->block,PyString_AsString(init),n); + memset((char*)b->block+n,0,4*size-n); + } + else + { int n,k; + long *p=(long*)b->block; + if(!PyList_Check(init)) goto fail; + n=PyList_Size(init); + if (n>size) n=size; + for(k=0;k<n;k++) + { PyObject *q=PyList_GetItem(init,k); + if(!PyInt_Check(q)) goto fail; + p[k]=PyInt_AsLong(q); + } + for(;k<size;k++) p[k]=0; + } + } + return (PyObject *)b; + fail:PyErr_SetString(PyExc_TypeError, + "block initialiser must be string or list of integers"); + Py_DECREF(b); + return NULL; +} + +static PyObject *PyRegister(PyObject *self,PyObject *args) +{ int size,ptr; + PyBlockObject *b; + if(!PyArg_ParseTuple(args,"ii",&size,&ptr)) return NULL; + if(size<1) size=1; + b=PyObject_NEW(PyBlockObject,&PyBlockType); + if(!b) return NULL; + b->block=(void*)ptr; + b->length=4*size; + b->heap=0; + return (PyObject *)b; +} + +static PyObject *PyBlock_ToString(PyBlockObject *self,PyObject *arg) +{ int s=0,e=self->length; + if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL; + if(s<0||e>self->length||s>e) + { PyErr_SetString(PyExc_IndexError,"block index out of range"); + return NULL; + } + return PyString_FromStringAndSize((char*)self->block+s,e-s); +} + +static PyObject *PyBlock_NullString(PyBlockObject *self,PyObject *arg) +{ int s=0,e=self->length,i; + char *p=(char*)self->block; + if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL; + if(s<0||e>self->length||s>e) + { PyErr_SetString(PyExc_IndexError,"block index out of range"); + return NULL; + } + for(i=s;i<e;i++) if(p[i]==0) break; + return PyString_FromStringAndSize((char*)self->block+s,i-s); +} + +static PyObject *PyBlock_CtrlString(PyBlockObject *self,PyObject *arg) +{ int s=0,e=self->length,i; + char *p=(char*)self->block; + if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL; + if(s<0||e>self->length||s>e) + { PyErr_SetString(PyExc_IndexError,"block index out of range"); + return NULL; + } + for(i=s;i<e;i++) if(p[i]<32) break; + return PyString_FromStringAndSize((char*)self->block+s,i-s); +} + +static PyObject *PyBlock_PadString(PyBlockObject *self,PyObject *arg) +{ int s=0,e=self->length,n,m; + char *str; + char c; + char *p=(char*)self->block; + if(!PyArg_ParseTuple(arg,"s#c|ii",&str,&n,&c,&s,&e)) return NULL; + if(s<0||e>self->length||s>e) + { PyErr_SetString(PyExc_IndexError,"block index out of range"); + return NULL; + } + m=e-s; + if(n>m) n=m; + memcpy(p+s,str,n);memset(p+s+n,c,m-n); + Py_INCREF(Py_None);return Py_None; +} + +static PyObject *PyBlock_BitSet(PyBlockObject *self,PyObject *arg) +{ int i,x,y; + int *p=(int*)self->block; + if(!PyArg_ParseTuple(arg,"iii",&i,&x,&y)) return NULL; + if(i<0||i>=self->length/4) + { PyErr_SetString(PyExc_IndexError,"block index out of range"); + return NULL; + } + p[i]=(p[i]&y)^x; + Py_INCREF(Py_None);return Py_None; +} + +static PyObject *PyBlock_Resize(PyBlockObject *self,PyObject *arg) +{ int n; + if(!PyArg_ParseTuple(arg,"i",&n)) return NULL; + if(n<1) n=1; + if(self->heap) + { void *v=realloc(self->block,4*n); + if (!v) return PyErr_NoMemory(); + self->block=v; + } + self->length=4*n; + Py_INCREF(Py_None);return Py_None; +} + +static PyObject *PyBlock_ToFile(PyBlockObject *self,PyObject *arg) +{ int s=0,e=self->length/4; + PyObject *f; + FILE *fp; + if(!PyArg_ParseTuple(arg,"O|ii",&f,&s,&e)) return NULL; + fp=PyFile_AsFile(f); + if (!fp) + { PyErr_SetString(PyExc_TypeError, "arg must be open file"); + return NULL; + } + fwrite((int*)(self->block)+s,4,e-s,fp); + Py_INCREF(Py_None);return Py_None; +} + +static struct PyMethodDef PyBlock_Methods[]= +{ { "tostring",(PyCFunction)PyBlock_ToString,1}, + { "padstring",(PyCFunction)PyBlock_PadString,1}, + { "nullstring",(PyCFunction)PyBlock_NullString,1}, + { "ctrlstring",(PyCFunction)PyBlock_CtrlString,1}, + { "bitset",(PyCFunction)PyBlock_BitSet,1}, + { "resize",(PyCFunction)PyBlock_Resize,1}, + { "tofile",(PyCFunction)PyBlock_ToFile,1}, + { NULL,NULL} /* sentinel */ +}; + +static int block_len(PyBlockObject *b) +{ return b->length/4; +} + +static PyObject *block_concat(PyBlockObject *b,PyBlockObject *c) +{ PyErr_SetString(PyExc_IndexError,"block concatenation not implemented"); + return NULL; +} + +static PyObject *block_repeat(PyBlockObject *b,int i) +{ PyErr_SetString(PyExc_IndexError,"block repetition not implemented"); + return NULL; +} + +static PyObject *block_item(PyBlockObject *b,int i) +{ if(i<0||4*i>=b->length) + { PyErr_SetString(PyExc_IndexError,"block index out of range"); + return NULL; + } + return PyInt_FromLong(((long*)(b->block))[i]); +} + +static PyObject *block_slice(PyBlockObject *b,int i,int j) +{ int n,k; + long *p=b->block; + PyObject *result; + if(j>b->length/4) j=b->length/4; + if(i<0||i>j) + { PyErr_SetString(PyExc_IndexError,"block index out of range"); + return NULL; + } + n=j-i; + result=PyList_New(n); + for(k=0;k<n;k++) PyList_SetItem(result,k,PyInt_FromLong(p[i+k])); + return result; +} + +static int block_ass_item(PyBlockObject *b,int i,PyObject *v) +{ if(i<0||i>=b->length/4) + { PyErr_SetString(PyExc_IndexError,"block index out of range"); + return -1; + } + if(!PyInt_Check(v)) + { PyErr_SetString(PyExc_TypeError,"block item must be integer"); + return -1; + } + ((long*)(b->block))[i]=PyInt_AsLong(v); + return 0; +} + +static int block_ass_slice(PyBlockObject *b,int i,int j,PyObject *v) +{ int n,k; + long *p=b->block; + if(j>b->length/4) j=b->length/4; + if(i<0||i>j) + { PyErr_SetString(PyExc_IndexError,"block index out of range"); + return -1; + } + if(!PyList_Check(v)) goto fail; + n=PyList_Size(v); + if(n>j-i) n=j-i; + for(k=0;k<n;k++) + { PyObject *q=PyList_GetItem(v,k); + if(!PyInt_Check(q)) goto fail; + p[i+k]=PyInt_AsLong(q); + } + for(;k<j-i;k++) p[i+k]=0; + return 0; + fail:PyErr_SetString(PyExc_TypeError,"block slice must be integer list"); + return -1; +} + +static PySequenceMethods block_as_sequence= +{ (inquiry)block_len, /*sq_length*/ + (binaryfunc)block_concat, /*sq_concat*/ + (intargfunc)block_repeat, /*sq_repeat*/ + (intargfunc)block_item, /*sq_item*/ + (intintargfunc)block_slice, /*sq_slice*/ + (intobjargproc)block_ass_item, /*sq_ass_item*/ + (intintobjargproc)block_ass_slice, /*sq_ass_slice*/ +}; + +static PyObject *PyBlock_GetAttr(PyBlockObject *s,char *name) +{ + if (!strcmp(name, "length")) return PyInt_FromLong((long)s->length); + if (!strcmp(name, "start")) return PyInt_FromLong((long)s->block); + if (!strcmp(name,"end")) return PyInt_FromLong(((long)(s->block)+s->length)); + if (!strcmp(name, "__members__")) + { PyObject *list = PyList_New(3); + if (list) + { PyList_SetItem(list, 0, PyString_FromString("length")); + PyList_SetItem(list, 1, PyString_FromString("start")); + PyList_SetItem(list, 2, PyString_FromString("end")); + if (PyErr_Occurred()) { Py_DECREF(list);list = NULL;} + } + return list; + } + return Py_FindMethod(PyBlock_Methods, (PyObject*) s,name); +} + +static void PyBlock_Dealloc(PyBlockObject *b) +{ + if(b->heap) { + if (b->heap) + ; + else + PyMem_DEL(b->block); + } + PyMem_DEL(b); +} + +static PyTypeObject PyBlockType= +{ PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "block", /*tp_name*/ + sizeof(PyBlockObject), /*tp_size*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)PyBlock_Dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)PyBlock_GetAttr, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &block_as_sequence, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ +}; + +/* swi commands */ + +static PyObject *swi_swi(PyObject *self,PyObject *args) +{ PyObject *name,*format,*result,*v; + int swino,carry,rno=0,j,n; + char *swiname,*fmt,*outfmt; + _kernel_swi_regs r; + PyBlockObject *ao; + if(args==NULL||!PyTuple_Check(args)||(n=PyTuple_Size(args))<2) + { PyErr_BadArgument(); return NULL;} + name=PyTuple_GetItem(args,0); + if(!PyArg_Parse(name,"i",&swino)) + { PyErr_Clear(); + if(!PyArg_Parse(name,"s",&swiname)) return NULL; + e=xos_swi_number_from_string(swiname,&swino); + if(e) return swi_oserror(); + } + format=PyTuple_GetItem(args,1); + if(!PyArg_Parse(format,"s",&fmt)) return NULL; + j=2; + for(;;fmt++) + { switch(*fmt) + { case '.': rno++;continue; + case ';':case 0: goto swicall; + case '0':case '1':case '2':case '3':case '4': + case '5':case '6':case '7':case '8':case '9': + r.r[rno++]=*fmt-'0';continue; + case '-':r.r[rno++]=-1;continue; + } + if(j>=n) return swi_error("Too few arguments"); + v=PyTuple_GetItem(args,j++); + switch(*fmt) + { case 'i':if(!PyArg_Parse(v,"i",&r.r[rno])) return NULL; + break; + case 's':if(!PyArg_Parse(v,"s",(char**)(&r.r[rno]))) return NULL; + break; + case 'b':if(!PyArg_Parse(v,"O",(PyObject**)&ao)) return NULL; + if(!PyBlock_Check(v)) return swi_error("Not a block"); + r.r[rno]=(int)(ao->block); + break; + case 'e':if(!PyArg_Parse(v,"O",(PyObject**)&ao)) return NULL; + if(!PyBlock_Check(v)) return swi_error("Not a block"); + r.r[rno]=(int)(ao->block)+ao->length; + break; + default:return swi_error("Odd format character"); + } + rno++; + } + swicall:e=(os_error*)_kernel_swi_c(swino,&r,&r,&carry); + if(e) return swi_oserror(); + if(*fmt==0) { Py_INCREF(Py_None);return Py_None;} + n=0; + for(outfmt=++fmt;*outfmt;outfmt++) switch(*outfmt) + { case 'i':case 's':case '*':n++;break; + case '.':break; + default:return swi_error("Odd format character"); + } + if(n==0) { Py_INCREF(Py_None);return Py_None;} + if(n!=1) + { result=PyTuple_New(n); + if(!result) return NULL; + } + rno=0;j=0; + for(;*fmt;fmt++) + { switch(*fmt) + { case 'i':v=PyInt_FromLong((long)r.r[rno++]); break; + case 's':v=PyString_FromString((char*)(r.r[rno++])); break; + case '.':rno++; continue; + case '*':v=PyInt_FromLong((long)carry); break; + } + if(!v) goto fail; + if(n==1) return v; + PyTuple_SetItem(result,j,v); + j++; + } + return result; + fail:Py_DECREF(result);return 0; +} + +static PyMethodDef SwiMethods[]= +{ { "swi",swi_swi,1}, + { "block",PyBlock_New,1}, + { "register",PyRegister,1}, + { NULL,NULL} /* Sentinel */ +}; + +void initswi() +{ PyObject *m, *d; + m = Py_InitModule("swi", SwiMethods); + d = PyModule_GetDict(m); + SwiError=PyErr_NewException("swi.error", NULL, NULL); + PyDict_SetItemString(d,"error",SwiError); + ArgError=PyErr_NewException("swi.ArgError", NULL, NULL); + PyDict_SetItemString(d,"ArgError",ArgError); +} |