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 }