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  1.02  03 March 2002 Dietmar Schwertberger
  16    * Added string, integer, integers, tuple and tuples
  17 */
  18
  19 #include "oslib/os.h"
  20 #include <kernel.h>
  21 #include "Python.h"
  22
  23
  24 #define PyBlock_Check(op) ((op)->ob_type == &PyBlockType)
  25
  26
  27 static PyObject *SwiError; /* Exception swi.error */
  28 static PyObject *ArgError; /* Exception swi.ArgError */
  29 static os_error *e;
  30
  31 static PyObject *swi_oserror(void)
  32 { PyErr_SetString(SwiError,e->errmess);
  33   PyObject_SetAttrString(PyErr_Occurred(), "errnum", PyInt_FromLong(e->errnum));
  34   return 0;
  35 }
  36
  37 static PyObject *swi_error(char *s)
  38 { PyErr_SetString(ArgError,s);
  39   return 0;
  40 }
  41
  42 typedef struct
  43 { PyObject_HEAD
  44   void *block;
  45   int length; /*length in bytes*/
  46   int heap;
  47 } PyBlockObject;
  48
  49 static PyTypeObject PyBlockType;
  50
  51 /* block commands */
  52
  53 static PyObject *PyBlock_New(PyObject *self,PyObject *args)
  54 { int size;
  55   PyBlockObject *b;
  56   PyObject *init=0;
  57   if(!PyArg_ParseTuple(args,"i|O",&size,&init)) return NULL;
  58   if(size<1) size=1;
  59   b=PyObject_NEW(PyBlockObject,&PyBlockType);
  60   if(!b) return NULL;
  61   b->block=malloc(4*size);
  62   if(!b->block)
  63   { Py_DECREF(b);
  64     return PyErr_NoMemory();
  65   }
  66   b->length=4*size;
  67   b->heap=1;
  68   if(init)
  69   { if(PyString_Check(init))
  70     { int n=PyString_Size(init);
  71       if (n>4*size) n=4*size;
  72       memcpy(b->block,PyString_AsString(init),n);
  73       memset((char*)b->block+n,0,4*size-n);
  74     }
  75     else
  76     { int n,k;
  77       long *p=(long*)b->block;
  78       if(!PyList_Check(init)) goto fail;
  79       n=PyList_Size(init);
  80       if (n>size) n=size;
  81       for(k=0;k<n;k++)
  82       { PyObject *q=PyList_GetItem(init,k);
  83         if(!PyInt_Check(q)) goto fail;
  84         p[k]=PyInt_AsLong(q);
  85       }
  86       for(;k<size;k++) p[k]=0;
  87     }
  88   }
  89   return (PyObject *)b;
  90   fail:PyErr_SetString(PyExc_TypeError,
  91      "block initialiser must be string or list of integers");
  92   Py_DECREF(b);
  93   return NULL;
  94 }
  95
  96 static PyObject *PyRegister(PyObject *self,PyObject *args)
  97 { int size,ptr;
  98   PyBlockObject *b;
  99   if(!PyArg_ParseTuple(args,"ii",&size,&ptr)) return NULL;
 100   if(size<1) size=1;
 101   b=PyObject_NEW(PyBlockObject,&PyBlockType);
 102   if(!b) return NULL;
 103   b->block=(void*)ptr;
 104   b->length=4*size;
 105   b->heap=0;
 106   return (PyObject *)b;
 107 }
 108
 109 static PyObject *PyBlock_ToString(PyBlockObject *self,PyObject *arg)
 110 { int s=0,e=self->length;
 111   if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL;
 112   if(s<0||e>self->length||s>e)
 113   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 114     return NULL;
 115   }
 116   return PyString_FromStringAndSize((char*)self->block+s,e-s);
 117 }
 118
 119 static PyObject *PyBlock_NullString(PyBlockObject *self,PyObject *arg)
 120 { int s=0,e=self->length,i;
 121   char *p=(char*)self->block;
 122   if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL;
 123   if(s<0||e>self->length||s>e)
 124   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 125     return NULL;
 126   }
 127   for(i=s;i<e;i++) if(p[i]==0) break;
 128   return PyString_FromStringAndSize((char*)self->block+s,i-s);
 129 }
 130
 131 static PyObject *PyBlock_CtrlString(PyBlockObject *self,PyObject *arg)
 132 { int s=0,e=self->length,i;
 133   char *p=(char*)self->block;
 134   if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL;
 135   if(s<0||e>self->length||s>e)
 136   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 137     return NULL;
 138   }
 139   for(i=s;i<e;i++) if(p[i]<32) break;
 140   return PyString_FromStringAndSize((char*)self->block+s,i-s);
 141 }
 142
 143 static PyObject *PyBlock_PadString(PyBlockObject *self,PyObject *arg)
 144 { int s=0,e=self->length,n,m;
 145   char *str;
 146   char c;
 147   char *p=(char*)self->block;
 148   if(!PyArg_ParseTuple(arg,"s#c|ii",&str,&n,&c,&s,&e)) return NULL;
 149   if(s<0||e>self->length||s>e)
 150   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 151     return NULL;
 152   }
 153   m=e-s;
 154   if(n>m) n=m;
 155   memcpy(p+s,str,n);memset(p+s+n,c,m-n);
 156   Py_INCREF(Py_None);return Py_None;
 157 }
 158
 159 static PyObject *PyBlock_BitSet(PyBlockObject *self,PyObject *arg)
 160 { int i,x,y;
 161   int *p=(int*)self->block;
 162   if(!PyArg_ParseTuple(arg,"iii",&i,&x,&y)) return NULL;
 163   if(i<0||i>=self->length/4)
 164   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 165     return NULL;
 166   }
 167   p[i]=(p[i]&y)^x;
 168   Py_INCREF(Py_None);return Py_None;
 169 }
 170
 171 static PyObject *PyBlock_Resize(PyBlockObject *self,PyObject *arg)
 172 { int n;
 173   if(!PyArg_ParseTuple(arg,"i",&n)) return NULL;
 174   if(n<1) n=1;
 175   if(self->heap)
 176   { void *v=realloc(self->block,4*n);
 177     if (!v) return PyErr_NoMemory();
 178     self->block=v;
 179   }
 180   self->length=4*n;
 181   Py_INCREF(Py_None);return Py_None;
 182 }
 183
 184 static PyObject *PyBlock_ToFile(PyBlockObject *self,PyObject *arg)
 185 { int s=0,e=self->length/4;
 186   PyObject *f;
 187   FILE *fp;
 188   if(!PyArg_ParseTuple(arg,"O|ii",&f,&s,&e)) return NULL;
 189   fp=PyFile_AsFile(f);
 190   if (!fp)
 191   { PyErr_SetString(PyExc_TypeError, "arg must be open file");
 192     return NULL;
 193   }
 194   fwrite((int*)(self->block)+s,4,e-s,fp);
 195   Py_INCREF(Py_None);return Py_None;
 196 }
 197
 198 static struct PyMethodDef PyBlock_Methods[]=
 199 { { "tostring",(PyCFunction)PyBlock_ToString,1},
 200   { "padstring",(PyCFunction)PyBlock_PadString,1},
 201   { "nullstring",(PyCFunction)PyBlock_NullString,1},
 202   { "ctrlstring",(PyCFunction)PyBlock_CtrlString,1},
 203   { "bitset",(PyCFunction)PyBlock_BitSet,1},
 204   { "resize",(PyCFunction)PyBlock_Resize,1},
 205   { "tofile",(PyCFunction)PyBlock_ToFile,1},
 206   { NULL,NULL}          /* sentinel */
 207 };
 208
 209 static int block_len(PyBlockObject *b)
 210 { return b->length/4;
 211 }
 212
 213 static PyObject *block_concat(PyBlockObject *b,PyBlockObject *c)
 214 { PyErr_SetString(PyExc_IndexError,"block concatenation not implemented");
 215   return NULL;
 216 }
 217
 218 static PyObject *block_repeat(PyBlockObject *b,Py_ssize_t i)
 219 { PyErr_SetString(PyExc_IndexError,"block repetition not implemented");
 220   return NULL;
 221 }
 222
 223 static PyObject *block_item(PyBlockObject *b,Py_ssize_t i)
 224 { if(i<0||4*i>=b->length)
 225   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 226     return NULL;
 227   }
 228   return PyInt_FromLong(((long*)(b->block))[i]);
 229 }
 230
 231 static PyObject *block_slice(PyBlockObject *b,Py_ssize_t i,Py_ssize_t j)
 232 { Py_ssize_t n,k;
 233   long *p=b->block;
 234   PyObject *result;
 235   if(j>b->length/4) j=b->length/4;
 236   if(i<0||i>j)
 237   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 238     return NULL;
 239   }
 240   n=j-i;
 241   result=PyList_New(n);
 242   for(k=0;k<n;k++) PyList_SetItem(result,k,PyInt_FromSsize_t(p[i+k]));
 243   return result;
 244 }
 245
 246 static int block_ass_item(PyBlockObject *b,Py_ssize_t i,PyObject *v)
 247 { if(i<0||i>=b->length/4)
 248   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 249     return -1;
 250   }
 251   if(!PyInt_Check(v))
 252   { PyErr_SetString(PyExc_TypeError,"block item must be integer");
 253     return -1;
 254   }
 255   ((long*)(b->block))[i]=PyInt_AsLong(v);
 256   return 0;
 257 }
 258
 259 static int block_ass_slice(PyBlockObject *b,Py_ssize_t i,Py_ssize_t j,PyObject *v)
 260 { Py_ssize_t n,k;
 261   long *p=b->block;
 262   if(j>b->length/4) j=b->length/4;
 263   if(i<0||i>j)
 264   { PyErr_SetString(PyExc_IndexError,"block index out of range");
 265     return -1;
 266   }
 267   if(!PyList_Check(v)) goto fail;
 268   n=PyList_Size(v);
 269   if(n>j-i) n=j-i;
 270   for(k=0;k<n;k++)
 271   { PyObject *q=PyList_GetItem(v,k);
 272     if(!PyInt_Check(q)) goto fail;
 273     p[i+k]=PyInt_AsLong(q);
 274   }
 275   for(;k<j-i;k++) p[i+k]=0;
 276   return 0;
 277   fail:PyErr_SetString(PyExc_TypeError,"block slice must be integer list");
 278   return -1;
 279 }
 280
 281 static PySequenceMethods block_as_sequence=
 282 { (inquiry)block_len,           /*sq_length*/
 283   (binaryfunc)block_concat,             /*sq_concat*/
 284   (ssizeargfunc)block_repeat,           /*sq_repeat*/
 285   (ssizeargfunc)block_item,             /*sq_item*/
 286   (ssizessizeargfunc)block_slice,               /*sq_slice*/
 287   (ssizeobjargproc)block_ass_item,      /*sq_ass_item*/
 288   (ssizessizeobjargproc)block_ass_slice,        /*sq_ass_slice*/
 289 };
 290
 291 static PyObject *PyBlock_GetAttr(PyBlockObject *s,char *name)
 292 {
 293   if (!strcmp(name, "length")) return PyInt_FromLong((long)s->length);
 294   if (!strcmp(name, "start")) return PyInt_FromLong((long)s->block);
 295   if (!strcmp(name,"end")) return PyInt_FromLong(((long)(s->block)+s->length));
 296   if (!strcmp(name, "__members__"))
 297   { PyObject *list = PyList_New(3);
 298     if (list)
 299     { PyList_SetItem(list, 0, PyString_FromString("length"));
 300       PyList_SetItem(list, 1, PyString_FromString("start"));
 301       PyList_SetItem(list, 2, PyString_FromString("end"));
 302       if (PyErr_Occurred()) { Py_DECREF(list);list = NULL;}
 303     }
 304     return list;
 305   }
 306   return Py_FindMethod(PyBlock_Methods, (PyObject*) s,name);
 307 }
 308
 309 static void PyBlock_Dealloc(PyBlockObject *b)
 310 {
 311     if(b->heap) {
 312         if (b->heap)
 313             ;
 314         else
 315             PyMem_DEL(b->block);
 316     }
 317   PyMem_DEL(b);
 318 }
 319
 320 static PyTypeObject PyBlockType=
 321 { PyObject_HEAD_INIT(&PyType_Type)
 322   0,                            /*ob_size*/
 323   "block",                      /*tp_name*/
 324   sizeof(PyBlockObject),        /*tp_size*/
 325   0,                            /*tp_itemsize*/
 326         /* methods */
 327   (destructor)PyBlock_Dealloc,  /*tp_dealloc*/
 328   0,                            /*tp_print*/
 329   (getattrfunc)PyBlock_GetAttr, /*tp_getattr*/
 330   0,                            /*tp_setattr*/
 331   0,                            /*tp_compare*/
 332   0,                            /*tp_repr*/
 333   0,                            /*tp_as_number*/
 334   &block_as_sequence,           /*tp_as_sequence*/
 335   0,                            /*tp_as_mapping*/
 336   0,                            /*tp_hash*/
 337 };
 338
 339 /* swi commands */
 340
 341 static PyObject *swi_swi(PyObject *self,PyObject *args)
 342 { PyObject *name,*format,*result,*v;
 343   int swino,carry,rno=0,j,n;
 344   char *swiname,*fmt,*outfmt;
 345   _kernel_swi_regs r;
 346   PyBlockObject *ao;
 347   if(args==NULL||!PyTuple_Check(args)||(n=PyTuple_Size(args))<2)
 348   { PyErr_BadArgument(); return NULL;}
 349   name=PyTuple_GetItem(args,0);
 350   if(!PyArg_Parse(name,"i",&swino))
 351   { PyErr_Clear();
 352     if(!PyArg_Parse(name,"s",&swiname)) return NULL;
 353     e=xos_swi_number_from_string(swiname,&swino);
 354     if(e) return swi_oserror();
 355   }
 356   format=PyTuple_GetItem(args,1);
 357   if(!PyArg_Parse(format,"s",&fmt)) return NULL;
 358   j=2;
 359   for(;;fmt++)
 360   { switch(*fmt)
 361     { case '.': rno++;continue;
 362       case ';':case 0: goto swicall;
 363       case '0':case '1':case '2':case '3':case '4':
 364       case '5':case '6':case '7':case '8':case '9':
 365         r.r[rno++]=*fmt-'0';continue;
 366       case '-':r.r[rno++]=-1;continue;
 367     }
 368     if(j>=n) return swi_error("Too few arguments");
 369     v=PyTuple_GetItem(args,j++);
 370     switch(*fmt)
 371     { case 'i':if(!PyArg_Parse(v,"i",&r.r[rno])) return NULL;
 372                break;
 373       case 's':if(!PyArg_Parse(v,"s",(char**)(&r.r[rno]))) return NULL;
 374                break;
 375       case 'b':if(!PyArg_Parse(v,"O",(PyObject**)&ao)) return NULL;
 376                if(!PyBlock_Check(v)) return swi_error("Not a block");
 377                r.r[rno]=(int)(ao->block);
 378                break;
 379       case 'e':if(!PyArg_Parse(v,"O",(PyObject**)&ao)) return NULL;
 380                if(!PyBlock_Check(v)) return swi_error("Not a block");
 381                r.r[rno]=(int)(ao->block)+ao->length;
 382                break;
 383       default:return swi_error("Odd format character");
 384     }
 385     rno++;
 386   }
 387   swicall:e=(os_error*)_kernel_swi_c(swino,&r,&r,&carry);
 388   if(e) return swi_oserror();
 389   if(*fmt==0) { Py_INCREF(Py_None);return Py_None;}
 390   n=0;
 391   for(outfmt=++fmt;*outfmt;outfmt++)  switch(*outfmt)
 392   { case 'i':case 's':case '*':n++;break;
 393     case '.':break;
 394     default:return swi_error("Odd format character");
 395   }
 396   if(n==0) { Py_INCREF(Py_None);return Py_None;}
 397   if(n!=1)
 398   { result=PyTuple_New(n);
 399     if(!result) return NULL;
 400   }
 401   rno=0;j=0;
 402   for(;*fmt;fmt++)
 403   {  switch(*fmt)
 404     { case 'i':v=PyInt_FromLong((long)r.r[rno++]); break;
 405       case 's':v=PyString_FromString((char*)(r.r[rno++])); break;
 406       case '.':rno++; continue;
 407       case '*':v=PyInt_FromLong((long)carry); break;
 408     }
 409     if(!v) goto fail;
 410     if(n==1) return v;
 411     PyTuple_SetItem(result,j,v);
 412     j++;
 413   }
 414   return result;
 415   fail:Py_DECREF(result);return 0;
 416 }
 417
 418 static PyObject *swi_string(PyObject *self, PyObject *arg)
 419 { char *s;
 420   int l=-1;
 421   if(!PyArg_ParseTuple(arg,"i|i",(unsigned int *)&s, &l)) return NULL;
 422   if (l==-1)
 423     l = strlen(s);
 424   return PyString_FromStringAndSize((char*)s, l);
 425 }
 426
 427 static char swi_string__doc__[] =
 428 "string(address[, length]) -> string\n\
 429 Read a null terminated string from the given address.";
 430
 431
 432 static PyObject *swi_integer(PyObject *self, PyObject *arg)
 433 { int *i;
 434
 435   if(!PyArg_ParseTuple(arg,"i",(unsigned int *)&i))
 436     return NULL;
 437   return PyInt_FromLong(*i);
 438 }
 439
 440 static char swi_integer__doc__[] =
 441 "integer(address) -> string\n\
 442 Read an integer from the given address.";
 443
 444
 445 static PyObject *swi_integers(PyObject *self, PyObject *arg)
 446 { int *i;
 447   int c=-1;
 448   PyObject *result, *result1;
 449
 450   if(!PyArg_ParseTuple(arg,"i|i",(unsigned int *)&i, &c)) return NULL;
 451   result=PyList_New(0);
 452   if (result) {
 453     while ( c>0 || (c==-1 && *i) ) {
 454       result1 = PyInt_FromLong((long)*i);
 455       if (!result1) {
 456         Py_DECREF(result);
 457         return NULL;
 458       }
 459       if (PyList_Append(result, result1)!=0) {
 460         Py_DECREF(result);
 461         Py_DECREF(result1);
 462         return NULL;
 463       };
 464       i++;
 465       if (c!=-1)
 466         c--;
 467     }
 468   }
 469   return result;
 470 }
 471
 472 static char swi_integers__doc__[] =
 473 "integers(address[, count]) -> string\n\
 474 Either read a null terminated list of integers or\n\
 475 a list of given length from the given address.";
 476
 477
 478 static PyObject *swi_tuples(PyObject *self, PyObject *arg)
 479 {
 480   unsigned char *i;         /* points to current */
 481   int c=-1, l=4, j, zero;         /* count, length, index */
 482   PyObject *result, *result1, *result11;
 483
 484   if(!PyArg_ParseTuple(arg,"i|ii",(unsigned int *)&i, &l, &c)) return NULL;
 485   result=PyList_New(0);
 486   if (result) {
 487     while (c) {
 488       result1 = PyTuple_New(l);
 489       if (!result1) {
 490         Py_DECREF(result);
 491         return NULL;
 492       }
 493       zero = (c==-1); /* check for zeros? */
 494       for(j=0;j<l;j++) {
 495         if (zero && *i)
 496           zero = 0;   /* non-zero found */
 497         result11 = PyInt_FromLong((long)(*i));
 498         if (!result11) {
 499           Py_DECREF(result);
 500           return NULL;
 501         }
 502         PyTuple_SetItem(result1, j, result11);
 503         i++;
 504       }
 505       if (c==-1 && zero) {
 506         Py_DECREF(result1);
 507         c = 0;
 508         break;
 509       }
 510       if (PyList_Append(result, result1)!=0) {
 511         Py_DECREF(result1);
 512         Py_DECREF(result);
 513         return NULL;
 514       }
 515       if (c!=-1)
 516         c--;
 517     }
 518   }
 519   return result;
 520 }
 521
 522 static char swi_tuples__doc__[] =
 523 "tuples(address[, length=4[, count]]) -> string\n\
 524 Either read a null terminated list of byte tuples or\n\
 525 a list of given length from the given address.";
 526
 527
 528 static PyObject *swi_tuple(PyObject *self, PyObject *arg)
 529 {
 530   unsigned char *i;         /* points to current */
 531   int c=1, j;
 532   PyObject *result, *result1;
 533
 534   if(!PyArg_ParseTuple(arg,"i|i",(unsigned int *)&i, &c)) return NULL;
 535   result = PyTuple_New(c);
 536   if (!result)
 537     return NULL;
 538   for(j=0;j<c;j++) {
 539     result1 = PyInt_FromLong((long)(i[j]));
 540     if (!result1) {
 541       Py_DECREF(result);
 542       return NULL;
 543     }
 544     PyTuple_SetItem(result, j, result1);
 545   }
 546   return result;
 547 }
 548
 549 static char swi_tuple__doc__[] =
 550 "tuple(address[, count=1]]) -> tuple\n\
 551 Read count bytes from given address.";
 552
 553
 554 static PyMethodDef SwiMethods[]=
 555 { { "swi", swi_swi, METH_VARARGS},
 556   { "block", PyBlock_New, METH_VARARGS},
 557   { "register", PyRegister, METH_VARARGS},
 558   { "string", swi_string, METH_VARARGS, swi_string__doc__},
 559   { "integer", swi_integer, METH_VARARGS, swi_integer__doc__},
 560   { "integers", swi_integers, METH_VARARGS, swi_integers__doc__},
 561   { "tuples", swi_tuples, METH_VARARGS, swi_tuples__doc__},
 562   { "tuple", swi_tuple, METH_VARARGS, swi_tuple__doc__},
 563   { NULL,NULL,0,NULL}            /* Sentinel */
 564 };
 565
 566
 567 void initswi()
 568 { PyObject *m, *d;
 569   m = Py_InitModule("swi", SwiMethods);
 570   d = PyModule_GetDict(m);
 571   SwiError=PyErr_NewException("swi.error", NULL, NULL);
 572   PyDict_SetItemString(d,"error",SwiError);
 573   ArgError=PyErr_NewException("swi.ArgError", NULL, NULL);
 574   PyDict_SetItemString(d,"ArgError",ArgError);
 575 }