RISCOS/Modules/swimodule.c

   1 /* swi
   2
   3    RISC OS swi functions
   4
   5  1.00               Chris Stretch
   6
   7
   8  1.01  12 May 1999  Laurence Tratt
   9
  10    * Changed swi.error to be a class based exception rather than string based
  11    * Added swi.ArgError which is generated for errors when the user passes invalid arguments to
  12        functions etc
  13    * Added "errnum" attribute to swi.error, so one can now check to see what the error number was
  14 */
  15
  16 #include "h.os"
  17 #include "h.kernel"
  18 #include "Python.h"
  19
  20 #include <errno.h>
  21
  22 #define PyBlock_Check(op) ((op)->ob_type == &PyBlockType)
  23
  24
  25 static PyObject *SwiError; /* Exception swi.error */
  26 static PyObject *ArgError; /* Exception swi.ArgError */
  27 static os_error *e;
  28
  29 static PyObject *swi_oserror(void)
  30 { PyErr_SetString(SwiError,e->errmess);
  31   PyObject_SetAttrString(PyErr_Occurred(), "errnum", PyInt_FromLong(e->errnum));
  32   return 0;
  33 }
  34
  35 static PyObject *swi_error(char *s)
  36 { PyErr_SetString(ArgError,s);
  37   return 0;
  38 }
  39
  40 typedef struct
  41 { PyObject_HEAD
  42   void *block;
  43   int length; /*length in bytes*/
  44   int heap;
  45 } PyBlockObject;
  46
  47 static PyTypeObject PyBlockType;
  48
  49 /* block commands */
  50
  51 static PyObject *PyBlock_New(PyObject *self,PyObject *args)
  52 { int size;
  53   PyBlockObject *b;
  54   PyObject *init=0;
  55   if(!PyArg_ParseTuple(args,"i|O",&size,&init)) return NULL;
  56   if(size<1) size=1;
  57   b=PyObject_NEW(PyBlockObject,&PyBlockType);
  58   if(!b) return NULL;
  59   b->block=malloc(4*size);
  60   if(!b->block)
  61   { Py_DECREF(b);
  62     return PyErr_NoMemory();
  63   }
  64   b->length=4*size;
  65   b->heap=1;
  66   if(init)
  67   { if(PyString_Check(init))
  68     { int n=PyString_Size(init);
  69       if (n>4*size) n=4*size;
  70       memcpy(b->block,PyString_AsString(init),n);
  71       memset((char*)b->block+n,0,4*size-n);
  72     }
  73     else
  74     { int n,k;
  75       long *p=(long*)b->block;
  76       if(!PyList_Check(init)) goto fail;
  77       n=PyList_Size(init);
  78       if (n>size) n=size;
  79       for(k=0;k<n;k++)
  80       { PyObject *q=PyList_GetItem(init,k);
  81         if(!PyInt_Check(q)) goto fail;
  82         p[k]=PyInt_AsLong(q);
  83       }
  84       for(;k<size;k++) p[k]=0;
  85     }
  86   }
  87   return (PyObject *)b;
  88   fail:PyErr_SetString(PyExc_TypeError,
  89      "block initialiser must be string or list of integers");
  90   Py_DECREF(b);
  91   return NULL;
  92 }
  93
  94 static PyObject *PyRegister(PyObject *self,PyObject *args)
  95 { int size,ptr;
  96   PyBlockObject *b;
  97   if(!PyArg_ParseTuple(args,"ii",&size,&ptr)) return NULL;
  98   if(size<1) size=1;
  99   b=PyObject_NEW(PyBlockObject,&PyBlockType);
 100   if(!b) return NULL;
 101   b->block=(void*)ptr;
 102   b->length=4*size;
 103   b->heap=0;
 104   return (PyObject *)b;
 105 }
 106
 107 static PyObject *PyBlock_ToString(PyBlockObject *self,PyObject *arg)
 108 { int s=0,e=self->length;
 109   if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL;
 110   if(s<0||e>self->length||s>e)
 111   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 112     return NULL;
 113   }
 114   return PyString_FromStringAndSize((char*)self->block+s,e-s);
 115 }
 116
 117 static PyObject *PyBlock_NullString(PyBlockObject *self,PyObject *arg)
 118 { int s=0,e=self->length,i;
 119   char *p=(char*)self->block;
 120   if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL;
 121   if(s<0||e>self->length||s>e)
 122   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 123     return NULL;
 124   }
 125   for(i=s;i<e;i++) if(p[i]==0) break;
 126   return PyString_FromStringAndSize((char*)self->block+s,i-s);
 127 }
 128
 129 static PyObject *PyBlock_CtrlString(PyBlockObject *self,PyObject *arg)
 130 { int s=0,e=self->length,i;
 131   char *p=(char*)self->block;
 132   if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL;
 133   if(s<0||e>self->length||s>e)
 134   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 135     return NULL;
 136   }
 137   for(i=s;i<e;i++) if(p[i]<32) break;
 138   return PyString_FromStringAndSize((char*)self->block+s,i-s);
 139 }
 140
 141 static PyObject *PyBlock_PadString(PyBlockObject *self,PyObject *arg)
 142 { int s=0,e=self->length,n,m;
 143   char *str;
 144   char c;
 145   char *p=(char*)self->block;
 146   if(!PyArg_ParseTuple(arg,"s#c|ii",&str,&n,&c,&s,&e)) return NULL;
 147   if(s<0||e>self->length||s>e)
 148   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 149     return NULL;
 150   }
 151   m=e-s;
 152   if(n>m) n=m;
 153   memcpy(p+s,str,n);memset(p+s+n,c,m-n);
 154   Py_INCREF(Py_None);return Py_None;
 155 }
 156
 157 static PyObject *PyBlock_BitSet(PyBlockObject *self,PyObject *arg)
 158 { int i,x,y;
 159   int *p=(int*)self->block;
 160   if(!PyArg_ParseTuple(arg,"iii",&i,&x,&y)) return NULL;
 161   if(i<0||i>=self->length/4)
 162   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 163     return NULL;
 164   }
 165   p[i]=(p[i]&y)^x;
 166   Py_INCREF(Py_None);return Py_None;
 167 }
 168
 169 static PyObject *PyBlock_Resize(PyBlockObject *self,PyObject *arg)
 170 { int n;
 171   if(!PyArg_ParseTuple(arg,"i",&n)) return NULL;
 172   if(n<1) n=1;
 173   if(self->heap)
 174   { void *v=realloc(self->block,4*n);
 175     if (!v) return PyErr_NoMemory();
 176     self->block=v;
 177   }
 178   self->length=4*n;
 179   Py_INCREF(Py_None);return Py_None;
 180 }
 181
 182 static PyObject *PyBlock_ToFile(PyBlockObject *self,PyObject *arg)
 183 { int s=0,e=self->length/4;
 184   PyObject *f;
 185   FILE *fp;
 186   if(!PyArg_ParseTuple(arg,"O|ii",&f,&s,&e)) return NULL;
 187   fp=PyFile_AsFile(f);
 188   if (!fp)
 189   { PyErr_SetString(PyExc_TypeError, "arg must be open file");
 190     return NULL;
 191   }
 192   fwrite((int*)(self->block)+s,4,e-s,fp);
 193   Py_INCREF(Py_None);return Py_None;
 194 }
 195
 196 static struct PyMethodDef PyBlock_Methods[]=
 197 { { "tostring",(PyCFunction)PyBlock_ToString,1},
 198   { "padstring",(PyCFunction)PyBlock_PadString,1},
 199   { "nullstring",(PyCFunction)PyBlock_NullString,1},
 200   { "ctrlstring",(PyCFunction)PyBlock_CtrlString,1},
 201   { "bitset",(PyCFunction)PyBlock_BitSet,1},
 202   { "resize",(PyCFunction)PyBlock_Resize,1},
 203   { "tofile",(PyCFunction)PyBlock_ToFile,1},
 204   { NULL,NULL}          /* sentinel */
 205 };
 206
 207 static int block_len(PyBlockObject *b)
 208 { return b->length/4;
 209 }
 210
 211 static PyObject *block_concat(PyBlockObject *b,PyBlockObject *c)
 212 { PyErr_SetString(PyExc_IndexError,"block concatenation not implemented");
 213   return NULL;
 214 }
 215
 216 static PyObject *block_repeat(PyBlockObject *b,int i)
 217 { PyErr_SetString(PyExc_IndexError,"block repetition not implemented");
 218   return NULL;
 219 }
 220
 221 static PyObject *block_item(PyBlockObject *b,int i)
 222 { if(i<0||4*i>=b->length)
 223   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 224     return NULL;
 225   }
 226   return PyInt_FromLong(((long*)(b->block))[i]);
 227 }
 228
 229 static PyObject *block_slice(PyBlockObject *b,int i,int j)
 230 { int n,k;
 231   long *p=b->block;
 232   PyObject *result;
 233   if(j>b->length/4) j=b->length/4;
 234   if(i<0||i>j)
 235   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 236     return NULL;
 237   }
 238   n=j-i;
 239   result=PyList_New(n);
 240   for(k=0;k<n;k++) PyList_SetItem(result,k,PyInt_FromLong(p[i+k]));
 241   return result;
 242 }
 243
 244 static int block_ass_item(PyBlockObject *b,int i,PyObject *v)
 245 { if(i<0||i>=b->length/4)
 246   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 247     return -1;
 248   }
 249   if(!PyInt_Check(v))
 250   { PyErr_SetString(PyExc_TypeError,"block item must be integer");
 251     return -1;
 252   }
 253   ((long*)(b->block))[i]=PyInt_AsLong(v);
 254   return 0;
 255 }
 256
 257 static int block_ass_slice(PyBlockObject *b,int i,int j,PyObject *v)
 258 { int n,k;
 259   long *p=b->block;
 260   if(j>b->length/4) j=b->length/4;
 261   if(i<0||i>j)
 262   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 263     return -1;
 264   }
 265   if(!PyList_Check(v)) goto fail;
 266   n=PyList_Size(v);
 267   if(n>j-i) n=j-i;
 268   for(k=0;k<n;k++)
 269   { PyObject *q=PyList_GetItem(v,k);
 270     if(!PyInt_Check(q)) goto fail;
 271     p[i+k]=PyInt_AsLong(q);
 272   }
 273   for(;k<j-i;k++) p[i+k]=0;
 274   return 0;
 275   fail:PyErr_SetString(PyExc_TypeError,"block slice must be integer list");
 276   return -1;
 277 }
 278
 279 static PySequenceMethods block_as_sequence=
 280 { (inquiry)block_len,           /*sq_length*/
 281   (binaryfunc)block_concat,             /*sq_concat*/
 282   (intargfunc)block_repeat,             /*sq_repeat*/
 283   (intargfunc)block_item,               /*sq_item*/
 284   (intintargfunc)block_slice,           /*sq_slice*/
 285   (intobjargproc)block_ass_item,        /*sq_ass_item*/
 286   (intintobjargproc)block_ass_slice,    /*sq_ass_slice*/
 287 };
 288
 289 static PyObject *PyBlock_GetAttr(PyBlockObject *s,char *name)
 290 {
 291   if (!strcmp(name, "length")) return PyInt_FromLong((long)s->length);
 292   if (!strcmp(name, "start")) return PyInt_FromLong((long)s->block);
 293   if (!strcmp(name,"end")) return PyInt_FromLong(((long)(s->block)+s->length));
 294   if (!strcmp(name, "__members__"))
 295   { PyObject *list = PyList_New(3);
 296     if (list)
 297     { PyList_SetItem(list, 0, PyString_FromString("length"));
 298       PyList_SetItem(list, 1, PyString_FromString("start"));
 299       PyList_SetItem(list, 2, PyString_FromString("end"));
 300       if (PyErr_Occurred()) { Py_DECREF(list);list = NULL;}
 301     }
 302     return list;
 303   }
 304   return Py_FindMethod(PyBlock_Methods, (PyObject*) s,name);
 305 }
 306
 307 static void PyBlock_Dealloc(PyBlockObject *b)
 308 {
 309     if(b->heap) {
 310         if (b->heap)
 311             ;
 312         else
 313             PyMem_DEL(b->block);
 314     }
 315   PyMem_DEL(b);
 316 }
 317
 318 static PyTypeObject PyBlockType=
 319 { PyObject_HEAD_INIT(&PyType_Type)
 320   0,                            /*ob_size*/
 321   "block",                      /*tp_name*/
 322   sizeof(PyBlockObject),        /*tp_size*/
 323   0,                            /*tp_itemsize*/
 324         /* methods */
 325   (destructor)PyBlock_Dealloc,  /*tp_dealloc*/
 326   0,                            /*tp_print*/
 327   (getattrfunc)PyBlock_GetAttr, /*tp_getattr*/
 328   0,                            /*tp_setattr*/
 329   0,                            /*tp_compare*/
 330   0,                            /*tp_repr*/
 331   0,                            /*tp_as_number*/
 332   &block_as_sequence,           /*tp_as_sequence*/
 333   0,                            /*tp_as_mapping*/
 334   0,                            /*tp_hash*/
 335 };
 336
 337 /* swi commands */
 338
 339 static PyObject *swi_swi(PyObject *self,PyObject *args)
 340 { PyObject *name,*format,*result,*v;
 341   int swino,carry,rno=0,j,n;
 342   char *swiname,*fmt,*outfmt;
 343   _kernel_swi_regs r;
 344   PyBlockObject *ao;
 345   if(args==NULL||!PyTuple_Check(args)||(n=PyTuple_Size(args))<2)
 346   { PyErr_BadArgument(); return NULL;}
 347   name=PyTuple_GetItem(args,0);
 348   if(!PyArg_Parse(name,"i",&swino))
 349   { PyErr_Clear();
 350     if(!PyArg_Parse(name,"s",&swiname)) return NULL;
 351     e=xos_swi_number_from_string(swiname,&swino);
 352     if(e) return swi_oserror();
 353   }
 354   format=PyTuple_GetItem(args,1);
 355   if(!PyArg_Parse(format,"s",&fmt)) return NULL;
 356   j=2;
 357   for(;;fmt++)
 358   { switch(*fmt)
 359     { case '.': rno++;continue;
 360       case ';':case 0: goto swicall;
 361       case '0':case '1':case '2':case '3':case '4':
 362       case '5':case '6':case '7':case '8':case '9':
 363         r.r[rno++]=*fmt-'0';continue;
 364       case '-':r.r[rno++]=-1;continue;
 365     }
 366     if(j>=n) return swi_error("Too few arguments");
 367     v=PyTuple_GetItem(args,j++);
 368     switch(*fmt)
 369     { case 'i':if(!PyArg_Parse(v,"i",&r.r[rno])) return NULL;
 370                break;
 371       case 's':if(!PyArg_Parse(v,"s",(char**)(&r.r[rno]))) return NULL;
 372                break;
 373       case 'b':if(!PyArg_Parse(v,"O",(PyObject**)&ao)) return NULL;
 374                if(!PyBlock_Check(v)) return swi_error("Not a block");
 375                r.r[rno]=(int)(ao->block);
 376                break;
 377       case 'e':if(!PyArg_Parse(v,"O",(PyObject**)&ao)) return NULL;
 378                if(!PyBlock_Check(v)) return swi_error("Not a block");
 379                r.r[rno]=(int)(ao->block)+ao->length;
 380                break;
 381       default:return swi_error("Odd format character");
 382     }
 383     rno++;
 384   }
 385   swicall:e=(os_error*)_kernel_swi_c(swino,&r,&r,&carry);
 386   if(e) return swi_oserror();
 387   if(*fmt==0) { Py_INCREF(Py_None);return Py_None;}
 388   n=0;
 389   for(outfmt=++fmt;*outfmt;outfmt++)  switch(*outfmt)
 390   { case 'i':case 's':case '*':n++;break;
 391     case '.':break;
 392     default:return swi_error("Odd format character");
 393   }
 394   if(n==0) { Py_INCREF(Py_None);return Py_None;}
 395   if(n!=1)
 396   { result=PyTuple_New(n);
 397     if(!result) return NULL;
 398   }
 399   rno=0;j=0;
 400   for(;*fmt;fmt++)
 401   {  switch(*fmt)
 402     { case 'i':v=PyInt_FromLong((long)r.r[rno++]); break;
 403       case 's':v=PyString_FromString((char*)(r.r[rno++])); break;
 404       case '.':rno++; continue;
 405       case '*':v=PyInt_FromLong((long)carry); break;
 406     }
 407     if(!v) goto fail;
 408     if(n==1) return v;
 409     PyTuple_SetItem(result,j,v);
 410     j++;
 411   }
 412   return result;
 413   fail:Py_DECREF(result);return 0;
 414 }
 415
 416 static PyMethodDef SwiMethods[]=
 417 { { "swi",swi_swi,1},
 418   { "block",PyBlock_New,1},
 419   { "register",PyRegister,1},
 420   { NULL,NULL}           /* Sentinel */
 421 };
 422
 423 void initswi()
 424 { PyObject *m, *d;
 425   m = Py_InitModule("swi", SwiMethods);
 426   d = PyModule_GetDict(m);
 427   SwiError=PyErr_NewException("swi.error", NULL, NULL);
 428   PyDict_SetItemString(d,"error",SwiError);
 429   ArgError=PyErr_NewException("swi.ArgError", NULL, NULL);
 430   PyDict_SetItemString(d,"ArgError",ArgError);
 431 }