Modules/cstubs

   1 /*
   2 Input used to generate the Python module "glmodule.c".
   3 The stub generator is a Python script called "cgen.py".
   4
   5 Each definition must be contained on one line:
   6
   7 <returntype> <name> <type> <arg> <type> <arg>
   8
   9 <returntype> can be: void, short, long (XXX maybe others?)
  10
  11 <type> can be: char, string, short, float, long, or double
  12         string indicates a null terminated string;
  13         if <type> is char and <arg> begins with a *, the * is stripped
  14         and <type> is changed into string
  15
  16 <arg> has the form <mode> or <mode>[<subscript>]
  17         where <mode> can be
  18                 s: arg is sent
  19                 r: arg is received              (arg is a pointer)
  20         and <subscript> can be (N and I are numbers):
  21                 N
  22                 argI
  23                 retval
  24                 N*argI
  25                 N*I
  26                 N*retval
  27         In the case where the subscript consists of two parts
  28         separated by *, the first part is the width of the matrix, and
  29         the second part is the length of the matrix.  This order is
  30         opposite from the order used in C to declare a two-dimensional
  31         matrix.
  32 */
  33
  34 /*
  35  * An attempt has been made to make this module switch threads on qread
  36  * calls. It is far from safe, though.
  37  */
  38
  39 #include <gl.h>
  40 #include <device.h>
  41
  42 #include "allobjects.h"
  43 #include "import.h"
  44 #include "modsupport.h"
  45 #include "cgensupport.h"
  46 #include "ceval.h"
  47
  48 /*
  49 Some stubs are too complicated for the stub generator.
  50 We can include manually written versions of them here.
  51 A line starting with '%' gives the name of the function so the stub
  52 generator can include it in the table of functions.
  53 */
  54
  55 % qread
  56
  57 static object *
  58 gl_qread(self, args)
  59         object *self;
  60         object *args;
  61 {
  62         long retval;
  63         short arg1 ;
  64         BGN_SAVE
  65         retval = qread( & arg1 );
  66         END_SAVE
  67         { object *v = newtupleobject( 2 );
  68           if (v == NULL) return NULL;
  69           settupleitem(v, 0, mknewlongobject(retval));
  70           settupleitem(v, 1, mknewshortobject(arg1));
  71           return v;
  72         }
  73 }
  74
  75
  76 /*
  77 varray -- an array of v.. calls.
  78 The argument is an array (maybe list or tuple) of points.
  79 Each point must be a tuple or list of coordinates (x, y, z).
  80 The points may be 2- or 3-dimensional but must all have the
  81 same dimension.  Float and int values may be mixed however.
  82 The points are always converted to 3D double precision points
  83 by assuming z=0.0 if necessary (as indicated in the man page),
  84 and for each point v3d() is called.
  85 */
  86
  87 % varray
  88
  89 static object *
  90 gl_varray(self, args)
  91         object *self;
  92         object *args;
  93 {
  94         object *v, *w;
  95         int i, n, width;
  96         double vec[3];
  97         object * (*getitem) FPROTO((object *, int));
  98
  99         if (!getiobjectarg(args, 1, 0, &v))
 100                 return NULL;
 101
 102         if (is_listobject(v)) {
 103                 n = getlistsize(v);
 104                 getitem = getlistitem;
 105         }
 106         else if (is_tupleobject(v)) {
 107                 n = gettuplesize(v);
 108                 getitem = gettupleitem;
 109         }
 110         else {
 111                 err_badarg();
 112                 return NULL;
 113         }
 114
 115         if (n == 0) {
 116                 INCREF(None);
 117                 return None;
 118         }
 119         if (n > 0)
 120                 w = (*getitem)(v, 0);
 121
 122         width = 0;
 123         if (w == NULL) {
 124         }
 125         else if (is_listobject(w)) {
 126                 width = getlistsize(w);
 127         }
 128         else if (is_tupleobject(w)) {
 129                 width = gettuplesize(w);
 130         }
 131
 132         switch (width) {
 133         case 2:
 134                 vec[2] = 0.0;
 135                 /* Fall through */
 136         case 3:
 137                 break;
 138         default:
 139                 err_badarg();
 140                 return NULL;
 141         }
 142
 143         for (i = 0; i < n; i++) {
 144                 w = (*getitem)(v, i);
 145                 if (!getidoublearray(w, 1, 0, width, vec))
 146                         return NULL;
 147                 v3d(vec);
 148         }
 149
 150         INCREF(None);
 151         return None;
 152 }
 153
 154 /*
 155 vnarray, nvarray -- an array of n3f and v3f calls.
 156 The argument is an array (list or tuple) of pairs of points and normals.
 157 Each pair is a tuple (NOT a list) of a point and a normal for that point.
 158 Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z).
 159 Three coordinates must be given.  Float and int values may be mixed.
 160 For each pair, n3f() is called for the normal, and then v3f() is called
 161 for the vector.
 162
 163 vnarray and nvarray differ only in the order of the vector and normal in
 164 the pair: vnarray expects (v, n) while nvarray expects (n, v).
 165 */
 166
 167 static object *gen_nvarray(); /* Forward */
 168
 169 % nvarray
 170
 171 static object *
 172 gl_nvarray(self, args)
 173         object *self;
 174         object *args;
 175 {
 176         return gen_nvarray(args, 0);
 177 }
 178
 179 % vnarray
 180
 181 static object *
 182 gl_vnarray(self, args)
 183         object *self;
 184         object *args;
 185 {
 186         return gen_nvarray(args, 1);
 187 }
 188
 189 /* Generic, internal version of {nv,nv}array: inorm indicates the
 190    argument order, 0: normal first, 1: vector first. */
 191
 192 static object *
 193 gen_nvarray(args, inorm)
 194         object *args;
 195         int inorm;
 196 {
 197         object *v, *w, *wnorm, *wvec;
 198         int i, n;
 199         float norm[3], vec[3];
 200         object * (*getitem) FPROTO((object *, int));
 201
 202         if (!getiobjectarg(args, 1, 0, &v))
 203                 return NULL;
 204
 205         if (is_listobject(v)) {
 206                 n = getlistsize(v);
 207                 getitem = getlistitem;
 208         }
 209         else if (is_tupleobject(v)) {
 210                 n = gettuplesize(v);
 211                 getitem = gettupleitem;
 212         }
 213         else {
 214                 err_badarg();
 215                 return NULL;
 216         }
 217
 218         for (i = 0; i < n; i++) {
 219                 w = (*getitem)(v, i);
 220                 if (!is_tupleobject(w) || gettuplesize(w) != 2) {
 221                         err_badarg();
 222                         return NULL;
 223                 }
 224                 wnorm = gettupleitem(w, inorm);
 225                 wvec = gettupleitem(w, 1 - inorm);
 226                 if (!getifloatarray(wnorm, 1, 0, 3, norm) ||
 227                         !getifloatarray(wvec, 1, 0, 3, vec))
 228                         return NULL;
 229                 n3f(norm);
 230                 v3f(vec);
 231         }
 232
 233         INCREF(None);
 234         return None;
 235 }
 236
 237 /* nurbssurface(s_knots[], t_knots[], ctl[][], s_order, t_order, type).
 238    The dimensions of ctl[] are computed as follows:
 239    [len(s_knots) - s_order], [len(t_knots) - t_order]
 240 */
 241
 242 % nurbssurface
 243
 244 static object *
 245 gl_nurbssurface(self, args)
 246         object *self;
 247         object *args;
 248 {
 249         long arg1 ;
 250         double * arg2 ;
 251         long arg3 ;
 252         double * arg4 ;
 253         double *arg5 ;
 254         long arg6 ;
 255         long arg7 ;
 256         long arg8 ;
 257         long ncoords;
 258         long s_byte_stride, t_byte_stride;
 259         long s_nctl, t_nctl;
 260         long s, t;
 261         object *v, *w, *pt;
 262         double *pnext;
 263         if (!getilongarraysize(args, 6, 0, &arg1))
 264                 return NULL;
 265         if ((arg2 = NEW(double, arg1 )) == NULL) {
 266                 return err_nomem();
 267         }
 268         if (!getidoublearray(args, 6, 0, arg1 , arg2))
 269                 return NULL;
 270         if (!getilongarraysize(args, 6, 1, &arg3))
 271                 return NULL;
 272         if ((arg4 = NEW(double, arg3 )) == NULL) {
 273                 return err_nomem();
 274         }
 275         if (!getidoublearray(args, 6, 1, arg3 , arg4))
 276                 return NULL;
 277         if (!getilongarg(args, 6, 3, &arg6))
 278                 return NULL;
 279         if (!getilongarg(args, 6, 4, &arg7))
 280                 return NULL;
 281         if (!getilongarg(args, 6, 5, &arg8))
 282                 return NULL;
 283         if (arg8 == N_XYZ)
 284                 ncoords = 3;
 285         else if (arg8 == N_XYZW)
 286                 ncoords = 4;
 287         else {
 288                 err_badarg();
 289                 return NULL;
 290         }
 291         s_nctl = arg1 - arg6;
 292         t_nctl = arg3 - arg7;
 293         if (!getiobjectarg(args, 6, 2, &v))
 294                 return NULL;
 295         if (!is_listobject(v) || getlistsize(v) != s_nctl) {
 296                 err_badarg();
 297                 return NULL;
 298         }
 299         if ((arg5 = NEW(double, s_nctl*t_nctl*ncoords )) == NULL) {
 300                 return err_nomem();
 301         }
 302         pnext = arg5;
 303         for (s = 0; s < s_nctl; s++) {
 304                 w = getlistitem(v, s);
 305                 if (w == NULL || !is_listobject(w) ||
 306                                         getlistsize(w) != t_nctl) {
 307                         err_badarg();
 308                         return NULL;
 309                 }
 310                 for (t = 0; t < t_nctl; t++) {
 311                         pt = getlistitem(w, t);
 312                         if (!getidoublearray(pt, 1, 0, ncoords, pnext))
 313                                 return NULL;
 314                         pnext += ncoords;
 315                 }
 316         }
 317         s_byte_stride = sizeof(double) * ncoords;
 318         t_byte_stride = s_byte_stride * s_nctl;
 319         nurbssurface( arg1 , arg2 , arg3 , arg4 ,
 320                 s_byte_stride , t_byte_stride , arg5 , arg6 , arg7 , arg8 );
 321         DEL(arg2);
 322         DEL(arg4);
 323         DEL(arg5);
 324         INCREF(None);
 325         return None;
 326 }
 327
 328 /* nurbscurve(knots, ctlpoints, order, type).
 329    The length of ctlpoints is len(knots)-order. */
 330
 331 %nurbscurve
 332
 333 static object *
 334 gl_nurbscurve(self, args)
 335         object *self;
 336         object *args;
 337 {
 338         long arg1 ;
 339         double * arg2 ;
 340         long arg3 ;
 341         double * arg4 ;
 342         long arg5 ;
 343         long arg6 ;
 344         int ncoords, npoints;
 345         int i;
 346         object *v;
 347         double *pnext;
 348         if (!getilongarraysize(args, 4, 0, &arg1))
 349                 return NULL;
 350         if ((arg2 = NEW(double, arg1 )) == NULL) {
 351                 return err_nomem();
 352         }
 353         if (!getidoublearray(args, 4, 0, arg1 , arg2))
 354                 return NULL;
 355         if (!getilongarg(args, 4, 2, &arg5))
 356                 return NULL;
 357         if (!getilongarg(args, 4, 3, &arg6))
 358                 return NULL;
 359         if (arg6 == N_ST)
 360                 ncoords = 2;
 361         else if (arg6 == N_STW)
 362                 ncoords = 3;
 363         else {
 364                 err_badarg();
 365                 return NULL;
 366         }
 367         npoints = arg1 - arg5;
 368         if (!getiobjectarg(args, 4, 1, &v))
 369                 return NULL;
 370         if (!is_listobject(v) || getlistsize(v) != npoints) {
 371                 err_badarg();
 372                 return NULL;
 373         }
 374         if ((arg4 = NEW(double, npoints*ncoords )) == NULL) {
 375                 return err_nomem();
 376         }
 377         pnext = arg4;
 378         for (i = 0; i < npoints; i++) {
 379                 if (!getidoublearray(getlistitem(v, i), 1, 0, ncoords, pnext))
 380                         return NULL;
 381                 pnext += ncoords;
 382         }
 383         arg3 = (sizeof(double)) * ncoords;
 384         nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
 385         DEL(arg2);
 386         DEL(arg4);
 387         INCREF(None);
 388         return None;
 389 }
 390
 391 /* pwlcurve(points, type).
 392    Points is a list of points. Type must be N_ST. */
 393
 394 %pwlcurve
 395
 396 static object *
 397 gl_pwlcurve(self, args)
 398         object *self;
 399         object *args;
 400 {
 401         object *v;
 402         long type;
 403         double *data, *pnext;
 404         long npoints, ncoords;
 405         int i;
 406         if (!getiobjectarg(args, 2, 0, &v))
 407                 return NULL;
 408         if (!getilongarg(args, 2, 1, &type))
 409                 return NULL;
 410         if (!is_listobject(v)) {
 411                 err_badarg();
 412                 return NULL;
 413         }
 414         npoints = getlistsize(v);
 415         if (type == N_ST)
 416                 ncoords = 2;
 417         else {
 418                 err_badarg();
 419                 return NULL;
 420         }
 421         if ((data = NEW(double, npoints*ncoords)) == NULL) {
 422                 return err_nomem();
 423         }
 424         pnext = data;
 425         for (i = 0; i < npoints; i++) {
 426                 if (!getidoublearray(getlistitem(v, i), 1, 0, ncoords, pnext))
 427                         return NULL;
 428                 pnext += ncoords;
 429         }
 430         pwlcurve(npoints, data, sizeof(double)*ncoords, type);
 431         DEL(data);
 432         INCREF(None);
 433         return None;
 434 }
 435
 436
 437 /* Picking and Selecting */
 438
 439 static short *pickbuffer = NULL;
 440 static long pickbuffersize;
 441
 442 static object *
 443 pick_select(args, func)
 444         object *args;
 445         void (*func)();
 446 {
 447         if (!getilongarg(args, 1, 0, &pickbuffersize))
 448                 return NULL;
 449         if (pickbuffer != NULL) {
 450                 err_setstr(RuntimeError,
 451                         "pick/gselect: already picking/selecting");
 452                 return NULL;
 453         }
 454         if ((pickbuffer = NEW(short, pickbuffersize)) == NULL) {
 455                 return err_nomem();
 456         }
 457         (*func)(pickbuffer, pickbuffersize);
 458         INCREF(None);
 459         return None;
 460 }
 461
 462 static object *
 463 endpick_select(args, func)
 464         object *args;
 465         long (*func)();
 466 {
 467         object *v, *w;
 468         int i, nhits, n;
 469         if (!getnoarg(args))
 470                 return NULL;
 471         if (pickbuffer == NULL) {
 472                 err_setstr(RuntimeError,
 473                         "endpick/endselect: not in pick/select mode");
 474                 return NULL;
 475         }
 476         nhits = (*func)(pickbuffer);
 477         if (nhits < 0) {
 478                 nhits = -nhits; /* How to report buffer overflow otherwise? */
 479         }
 480         /* Scan the buffer to see how many integers */
 481         n = 0;
 482         for (; nhits > 0; nhits--) {
 483                 n += 1 + pickbuffer[n];
 484         }
 485         v = newlistobject(n);
 486         if (v == NULL)
 487                 return NULL;
 488         /* XXX Could do it nicer and interpret the data structure here,
 489            returning a list of lists. But this can be done in Python... */
 490         for (i = 0; i < n; i++) {
 491                 w = newintobject((long)pickbuffer[i]);
 492                 if (w == NULL) {
 493                         DECREF(v);
 494                         return NULL;
 495                 }
 496                 setlistitem(v, i, w);
 497         }
 498         DEL(pickbuffer);
 499         pickbuffer = NULL;
 500         return v;
 501 }
 502
 503 extern void pick(), gselect();
 504 extern long endpick(), endselect();
 505
 506 %pick
 507 static object *gl_pick(self, args) object *self, *args; {
 508         return pick_select(args, pick);
 509 }
 510
 511 %endpick
 512 static object *gl_endpick(self, args) object *self, *args; {
 513         return endpick_select(args, endpick);
 514 }
 515
 516 %gselect
 517 static object *gl_gselect(self, args) object *self, *args; {
 518         return pick_select(args, gselect);
 519 }
 520
 521 %endselect
 522 static object *gl_endselect(self, args) object *self, *args; {
 523         return endpick_select(args, endselect);
 524 }
 525
 526
 527 /* XXX The generator botches this one.  Here's a quick hack to fix it. */
 528
 529 /* XXX The generator botches this one.  Here's a quick hack to fix it. */
 530
 531 % getmatrix float r[16]
 532
 533 static object *
 534 gl_getmatrix(self, args)
 535         object *self;
 536         object *args;
 537 {
 538         Matrix arg1;
 539         object *v, *w;
 540         int i, j;
 541         getmatrix( arg1 );
 542         v = newlistobject(16);
 543         if (v == NULL) {
 544                 return err_nomem();
 545         }
 546         for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {
 547                 w = mknewfloatobject(arg1[i][j]);
 548                 if (w == NULL) {
 549                         DECREF(v);
 550                         return NULL;
 551                 }
 552                 setlistitem(v, i*4+j, w);
 553         }
 554         return v;
 555 }
 556
 557 /* Here's an alternate version that returns a 4x4 matrix instead of
 558    a vector.  Unfortunately it is incompatible with loadmatrix and
 559    multmatrix... */
 560
 561 % altgetmatrix float r[4][4]
 562
 563 static object *
 564 gl_altgetmatrix(self, args)
 565         object *self;
 566         object *args;
 567 {
 568         Matrix arg1;
 569         object *v, *w;
 570         int i, j;
 571         getmatrix( arg1 );
 572         v = newlistobject(4);
 573         if (v == NULL) {
 574                 return NULL;
 575         }
 576         for (i = 0; i < 4; i++) {
 577                 w = newlistobject(4);
 578                 if (w == NULL) {
 579                         DECREF(v);
 580                         return NULL;
 581                 }
 582                 setlistitem(v, i, w);
 583         }
 584         for (i = 0; i < 4; i++) {
 585                 for (j = 0; j < 4; j++) {
 586                         w = mknewfloatobject(arg1[i][j]);
 587                         if (w == NULL) {
 588                                 DECREF(v);
 589                                 return NULL;
 590                         }
 591                         setlistitem(getlistitem(v, i), j, w);
 592                 }
 593         }
 594         return v;
 595 }
 596
 597 % lrectwrite
 598
 599 static object *
 600 gl_lrectwrite(self, args)
 601         object *self;
 602         object *args;
 603 {
 604         short x1 ;
 605         short y1 ;
 606         short x2 ;
 607         short y2 ;
 608         string parray ;
 609         object *s;
 610         int pixcount;
 611         if (!getishortarg(args, 5, 0, &x1))
 612                 return NULL;
 613         if (!getishortarg(args, 5, 1, &y1))
 614                 return NULL;
 615         if (!getishortarg(args, 5, 2, &x2))
 616                 return NULL;
 617         if (!getishortarg(args, 5, 3, &y2))
 618                 return NULL;
 619         if (!getistringarg(args, 5, 4, &parray))
 620                 return NULL;
 621         if (!getiobjectarg(args, 5, 4, &s))
 622                 return NULL;
 623 #if 0
 624 /* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
 625         pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
 626         if (!is_stringobject(s) || getstringsize(s) != pixcount*sizeof(long)) {
 627                 err_setstr(RuntimeError,
 628                            "string arg to lrectwrite has wrong size");
 629                 return NULL;
 630         }
 631 #endif
 632         lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray );
 633         INCREF(None);
 634         return None;
 635 }
 636
 637 % lrectread
 638
 639 static object *
 640 gl_lrectread(self, args)
 641         object *self;
 642         object *args;
 643 {
 644         short x1 ;
 645         short y1 ;
 646         short x2 ;
 647         short y2 ;
 648         object *parray;
 649         int pixcount;
 650         if (!getishortarg(args, 4, 0, &x1))
 651                 return NULL;
 652         if (!getishortarg(args, 4, 1, &y1))
 653                 return NULL;
 654         if (!getishortarg(args, 4, 2, &x2))
 655                 return NULL;
 656         if (!getishortarg(args, 4, 3, &y2))
 657                 return NULL;
 658         pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
 659         parray = newsizedstringobject((char *)NULL, pixcount*sizeof(long));
 660         if (parray == NULL)
 661                 return NULL; /* No memory */
 662         lrectread(x1, y1, x2, y2, (unsigned long *) getstringvalue(parray));
 663         return parray;
 664 }
 665
 666 % readdisplay
 667
 668 static object *
 669 gl_readdisplay(self, args)
 670         object *self;
 671         object *args;
 672 {
 673         short x1, y1, x2, y2;
 674         unsigned long *parray, hints;
 675         long size, size_ret;
 676         object *rv;
 677
 678         if ( !getargs(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
 679           return 0;
 680         size = (long)(x2+1-x1) * (long)(y2+1-y1);
 681         rv = newsizedstringobject((char *)NULL, size*sizeof(long));
 682         if ( rv == NULL )
 683           return NULL;
 684         parray = (unsigned long *)getstringvalue(rv);
 685         size_ret = readdisplay(x1, y1, x2, y2, parray, hints);
 686         if ( size_ret != size ) {
 687             printf("gl_readdisplay: got %d pixels, expected %d\n",
 688                    size_ret, size);
 689             err_setstr(RuntimeError, "readdisplay returned unexpected length");
 690             return NULL;
 691         }
 692         return rv;
 693 }
 694
 695 /* Desperately needed, here are tools to compress and decompress
 696    the data manipulated by lrectread/lrectwrite.
 697
 698    gl.packrect(width, height, packfactor, bigdata) --> smalldata
 699                 makes 'bigdata' 4*(packfactor**2) times smaller by:
 700                 - turning it into B/W (a factor 4)
 701                 - replacing squares of size pacfactor by one
 702                   representative
 703
 704    gl.unpackrect(width, height, packfactor, smalldata) --> bigdata
 705                 is the inverse; the numeric arguments must be *the same*.
 706
 707    Both work best if width and height are multiples of packfactor
 708    (in fact unpackrect will leave garbage bytes).
 709 */
 710
 711 % packrect
 712
 713 static object *
 714 gl_packrect(self, args)
 715         object *self;
 716         object *args;
 717 {
 718         long width, height, packfactor;
 719         char *s;
 720         object *unpacked, *packed;
 721         int pixcount, packedcount, x, y, r, g, b;
 722         unsigned long pixel;
 723         unsigned char *p;
 724         unsigned long *parray;
 725         if (!getilongarg(args, 4, 0, &width))
 726                 return NULL;
 727         if (!getilongarg(args, 4, 1, &height))
 728                 return NULL;
 729         if (!getilongarg(args, 4, 2, &packfactor))
 730                 return NULL;
 731         if (!getistringarg(args, 4, 3, &s)) /* For type checking only */
 732                 return NULL;
 733         if (!getiobjectarg(args, 4, 3, &unpacked))
 734                 return NULL;
 735         if (width <= 0 || height <= 0 || packfactor <= 0) {
 736                 err_setstr(RuntimeError, "packrect args must be > 0");
 737                 return NULL;
 738         }
 739         pixcount = width*height;
 740         packedcount = ((width+packfactor-1)/packfactor) *
 741                 ((height+packfactor-1)/packfactor);
 742         if (getstringsize(unpacked) != pixcount*sizeof(long)) {
 743                 err_setstr(RuntimeError,
 744                            "string arg to packrect has wrong size");
 745                 return NULL;
 746         }
 747         packed = newsizedstringobject((char *)NULL, packedcount);
 748         if (packed == NULL)
 749                 return NULL;
 750         parray = (unsigned long *) getstringvalue(unpacked);
 751         p = (unsigned char *) getstringvalue(packed);
 752         for (y = 0; y < height; y += packfactor, parray += packfactor*width) {
 753                 for (x = 0; x < width; x += packfactor) {
 754                         pixel = parray[x];
 755                         r = pixel & 0xff;
 756                         g = (pixel >> 8) & 0xff;
 757                         b = (pixel >> 16) & 0xff;
 758                         *p++ = (30*r+59*g+11*b) / 100;
 759                 }
 760         }
 761         return packed;
 762 }
 763
 764 % unpackrect
 765
 766 static unsigned long unpacktab[256];
 767 static int unpacktab_inited = 0;
 768
 769 static object *
 770 gl_unpackrect(self, args)
 771         object *self;
 772         object *args;
 773 {
 774         long width, height, packfactor;
 775         char *s;
 776         object *unpacked, *packed;
 777         int pixcount, packedcount, y;
 778         register unsigned char *p;
 779         register unsigned long *parray;
 780         if (!unpacktab_inited) {
 781                 register int white;
 782                 for (white = 256; --white >= 0; )
 783                         unpacktab[white] = white * 0x010101L;
 784                 unpacktab_inited++;
 785         }
 786         if (!getilongarg(args, 4, 0, &width))
 787                 return NULL;
 788         if (!getilongarg(args, 4, 1, &height))
 789                 return NULL;
 790         if (!getilongarg(args, 4, 2, &packfactor))
 791                 return NULL;
 792         if (!getistringarg(args, 4, 3, &s)) /* For type checking only */
 793                 return NULL;
 794         if (!getiobjectarg(args, 4, 3, &packed))
 795                 return NULL;
 796         if (width <= 0 || height <= 0 || packfactor <= 0) {
 797                 err_setstr(RuntimeError, "packrect args must be > 0");
 798                 return NULL;
 799         }
 800         pixcount = width*height;
 801         packedcount = ((width+packfactor-1)/packfactor) *
 802                 ((height+packfactor-1)/packfactor);
 803         if (getstringsize(packed) != packedcount) {
 804                 err_setstr(RuntimeError,
 805                            "string arg to unpackrect has wrong size");
 806                 return NULL;
 807         }
 808         unpacked = newsizedstringobject((char *)NULL, pixcount*sizeof(long));
 809         if (unpacked == NULL)
 810                 return NULL;
 811         parray = (unsigned long *) getstringvalue(unpacked);
 812         p = (unsigned char *) getstringvalue(packed);
 813         if (packfactor == 1 && width*height > 0) {
 814                 /* Just expand bytes to longs */
 815                 register int x = width * height;
 816                 do {
 817                         *parray++ = unpacktab[*p++];
 818                 } while (--x >= 0);
 819         }
 820         else {
 821                 register int y;
 822                 for (y = 0; y < height-packfactor+1;
 823                      y += packfactor, parray += packfactor*width) {
 824                         register int x;
 825                         for (x = 0; x < width-packfactor+1; x += packfactor) {
 826                                 register unsigned long pixel = unpacktab[*p++];
 827                                 register int i;
 828                                 for (i = packfactor*width; (i-=width) >= 0;) {
 829                                         register int j;
 830                                         for (j = packfactor; --j >= 0; )
 831                                                 parray[i+x+j] = pixel;
 832                                 }
 833                         }
 834                 }
 835         }
 836         return unpacked;
 837 }
 838
 839 % gversion
 840 static object *
 841 gl_gversion(self, args)
 842         object *self;
 843         object *args;
 844 {
 845         char buf[20];
 846         gversion(buf);
 847         return newstringobject(buf);
 848 }
 849
 850
 851 /* End of manually written stubs */
 852
 853 %%
 854
 855 long    getshade
 856 if !solaris     void    devport         short s long s
 857 void    rdr2i           long s long s
 858 void    rectfs          short s short s short s short s
 859 void    rects           short s short s short s short s
 860 void    rmv2i           long s long s
 861 void    noport
 862 void    popviewport
 863 void    clear
 864 void    clearhitcode
 865 void    closeobj
 866 void    cursoff
 867 void    curson
 868 void    doublebuffer
 869 void    finish
 870 void    gconfig
 871 void    ginit
 872 void    greset
 873 void    multimap
 874 void    onemap
 875 void    popattributes
 876 void    popmatrix
 877 void    pushattributes
 878 void    pushmatrix
 879 void    pushviewport
 880 void    qreset
 881 void    RGBmode
 882 void    singlebuffer
 883 void    swapbuffers
 884 void    gsync
 885 void    gflush
 886 void    tpon
 887 void    tpoff
 888 void    clkon
 889 void    clkoff
 890 void    ringbell
 891 #void   callfunc
 892 void    gbegin
 893 void    textinit
 894 void    initnames
 895 void    pclos
 896 void    popname
 897 if !solaris     void    spclos
 898 void    zclear
 899 void    screenspace
 900 void    reshapeviewport
 901 void    winpush
 902 void    winpop
 903 void    foreground
 904 void    endfullscrn
 905 if !solaris     void    endpupmode
 906 void    fullscrn
 907 if !solaris     void    pupmode
 908 void    winconstraints
 909 void    pagecolor       short s
 910 void    textcolor       short s
 911 void    color           short s
 912 void    curveit         short s
 913 void    font            short s
 914 void    linewidth       short s
 915 void    setlinestyle    short s
 916 void    setmap          short s
 917 void    swapinterval    short s
 918 void    writemask       short s
 919 if !solaris     void    textwritemask   short s
 920 void    qdevice         short s
 921 void    unqdevice       short s
 922 void    curvebasis      short s
 923 void    curveprecision  short s
 924 void    loadname        short s
 925 void    passthrough     short s
 926 void    pushname        short s
 927 void    setmonitor      short s
 928 if !solaris     void    setshade        short s
 929 void    setpattern      short s
 930 if !solaris     void    pagewritemask   short s
 931 #
 932 void    callobj         long s
 933 void    delobj          long s
 934 void    editobj         long s
 935 void    makeobj         long s
 936 void    maketag         long s
 937 void    chunksize       long s
 938 void    compactify      long s
 939 void    deltag          long s
 940 void    lsrepeat        long s
 941 void    objinsert       long s
 942 void    objreplace      long s
 943 void    winclose        long s
 944 void    blanktime       long s
 945 void    freepup         long s
 946 # This is not in the library!?
 947 ###void pupcolor        long s
 948 #
 949 void    backbuffer      long s
 950 void    frontbuffer     long s
 951 if !solaris     void    lsbackup        long s
 952 void    resetls         long s
 953 void    lampon          long s
 954 void    lampoff         long s
 955 void    setbell         long s
 956 void    blankscreen     long s
 957 void    depthcue        long s
 958 void    zbuffer         long s
 959 void    backface        long s
 960 #
 961 void    cmov2i          long s long s
 962 void    draw2i          long s long s
 963 void    move2i          long s long s
 964 void    pnt2i           long s long s
 965 void    patchbasis      long s long s
 966 void    patchprecision  long s long s
 967 void    pdr2i           long s long s
 968 void    pmv2i           long s long s
 969 void    rpdr2i          long s long s
 970 void    rpmv2i          long s long s
 971 void    xfpt2i          long s long s
 972 void    objdelete       long s long s
 973 void    patchcurves     long s long s
 974 void    minsize         long s long s
 975 void    maxsize         long s long s
 976 void    keepaspect      long s long s
 977 void    prefsize        long s long s
 978 void    stepunit        long s long s
 979 void    fudge           long s long s
 980 void    winmove         long s long s
 981 #
 982 void    attachcursor    short s short s
 983 void    deflinestyle    short s short s
 984 void    noise           short s short s
 985 void    picksize        short s short s
 986 void    qenter          short s short s
 987 void    setdepth        short s short s
 988 void    cmov2s          short s short s
 989 void    draw2s          short s short s
 990 void    move2s          short s short s
 991 void    pdr2s           short s short s
 992 void    pmv2s           short s short s
 993 void    pnt2s           short s short s
 994 void    rdr2s           short s short s
 995 void    rmv2s           short s short s
 996 void    rpdr2s          short s short s
 997 void    rpmv2s          short s short s
 998 void    xfpt2s          short s short s
 999 #
1000 void cmov2              float s float s
1001 void draw2              float s float s
1002 void move2              float s float s
1003 void pnt2               float s float s
1004 void pdr2               float s float s
1005 void pmv2               float s float s
1006 void rdr2               float s float s
1007 void rmv2               float s float s
1008 void rpdr2              float s float s
1009 void rpmv2              float s float s
1010 void xfpt2              float s float s
1011 #
1012 void loadmatrix         float s[4*4]
1013 # Really [4][4]
1014 void multmatrix         float s[4*4]
1015 # Really [4][4]
1016 void crv                        float s[3*4]
1017 # Really [4][3]
1018 void rcrv                       float s[4*4]
1019 # Really [4][4]
1020 #
1021 # Methods that have strings.
1022 #
1023 void addtopup           long s char *s long s
1024 void charstr            char *s
1025 void getport            char *s
1026 long strwidth           char *s
1027 long winopen            char *s
1028 void wintitle           char *s
1029 #
1030 # Methods that have 1 long (# of elements) and an array
1031 #
1032 void polf               long s float s[3*arg1]
1033 void polf2              long s float s[2*arg1]
1034 void poly               long s float s[3*arg1]
1035 void poly2              long s float s[2*arg1]
1036 void crvn               long s float s[3*arg1]
1037 void rcrvn              long s float s[4*arg1]
1038 #
1039 void polf2i             long s long s[2*arg1]
1040 void polfi              long s long s[3*arg1]
1041 void poly2i             long s long s[2*arg1]
1042 void polyi              long s long s[3*arg1]
1043 #
1044 void polf2s             long s short s[2*arg1]
1045 void polfs              long s short s[3*arg1]
1046 void polys              long s short s[3*arg1]
1047 void poly2s             long s short s[2*arg1]
1048 #
1049 void defcursor          short s u_short s[128]
1050 # Is this useful?
1051 void writepixels        short s u_short s[arg1]
1052 # Should be unsigned short...
1053 void defbasis           long s float s[4*4]
1054 if !solaris     void gewrite            short s short s[arg1]
1055 #
1056 void rotate             short s char s
1057 # This is not in the library!?
1058 ###void setbutton               short s char s
1059 void rot                float s char s
1060 #
1061 void circfi             long s long s long s
1062 void circi              long s long s long s
1063 void cmovi              long s long s long s
1064 void drawi              long s long s long s
1065 void movei              long s long s long s
1066 void pnti               long s long s long s
1067 void newtag             long s long s long s
1068 void pdri               long s long s long s
1069 void pmvi               long s long s long s
1070 void rdri               long s long s long s
1071 void rmvi               long s long s long s
1072 void rpdri              long s long s long s
1073 void rpmvi              long s long s long s
1074 void xfpti              long s long s long s
1075 #
1076 void circ               float s float s float s
1077 void circf              float s float s float s
1078 void cmov               float s float s float s
1079 void draw               float s float s float s
1080 void move               float s float s float s
1081 void pnt                float s float s float s
1082 void scale              float s float s float s
1083 void translate          float s float s float s
1084 void pdr                float s float s float s
1085 void pmv                float s float s float s
1086 void rdr                float s float s float s
1087 void rmv                float s float s float s
1088 void rpdr               float s float s float s
1089 void rpmv               float s float s float s
1090 void xfpt               float s float s float s
1091 #
1092 void RGBcolor           short s short s short s
1093 void RGBwritemask       short s short s short s
1094 void setcursor          short s short s short s
1095 void tie                short s short s short s
1096 void circfs             short s short s short s
1097 void circs              short s short s short s
1098 void cmovs              short s short s short s
1099 void draws              short s short s short s
1100 void moves              short s short s short s
1101 void pdrs               short s short s short s
1102 void pmvs               short s short s short s
1103 void pnts               short s short s short s
1104 void rdrs               short s short s short s
1105 void rmvs               short s short s short s
1106 void rpdrs              short s short s short s
1107 void rpmvs              short s short s short s
1108 void xfpts              short s short s short s
1109 void curorigin          short s short s short s
1110 void cyclemap           short s short s short s
1111 #
1112 void patch              float s[4*4] float s[4*4] float s[4*4]
1113 void splf               long s float s[3*arg1] u_short s[arg1]
1114 void splf2              long s float s[2*arg1] u_short s[arg1]
1115 void splfi              long s long s[3*arg1] u_short s[arg1]
1116 void splf2i             long s long s[2*arg1] u_short s[arg1]
1117 void splfs              long s short s[3*arg1] u_short s[arg1]
1118 void splf2s             long s short s[2*arg1] u_short s[arg1]
1119 ###void defpattern              short s short s u_short s[arg2*arg2/16]
1120 #
1121 void rpatch             float s[4*4] float s[4*4] float s[4*4] float s[4*4]
1122 #
1123 # routines that send 4 floats
1124 #
1125 void ortho2             float s float s float s float s
1126 void rect               float s float s float s float s
1127 void rectf              float s float s float s float s
1128 void xfpt4              float s float s float s float s
1129 #
1130 void textport           short s short s short s short s
1131 void mapcolor           short s short s short s short s
1132 void scrmask            short s short s short s short s
1133 void setvaluator        short s short s short s short s
1134 void viewport           short s short s short s short s
1135 void shaderange         short s short s short s short s
1136 void xfpt4s             short s short s short s short s
1137 void rectfi             long s long s long s long s
1138 void recti              long s long s long s long s
1139 void xfpt4i             long s long s long s long s
1140 void prefposition       long s long s long s long s
1141 #
1142 void arc                float s float s float s short s short s
1143 void arcf               float s float s float s short s short s
1144 void arcfi              long s long s long s short s short s
1145 void arci               long s long s long s short s short s
1146 #
1147 void bbox2              short s short s float s float s float s float s
1148 void bbox2i             short s short s long s long s long s long s
1149 void bbox2s             short s short s short s short s short s short s
1150 void blink              short s short s short s short s short s
1151 void ortho              float s float s float s float s float s float s
1152 void window             float s float s float s float s float s float s
1153 void lookat             float s float s float s float s float s float s short s
1154 #
1155 void perspective        short s float s float s float s
1156 void polarview          float s short s short s short s
1157 # XXX getichararray not supported
1158 #void writeRGB          short s char s[arg1] char s[arg1] char s[arg1]
1159 #
1160 void arcfs              short s short s short s short s short s
1161 void arcs               short s short s short s short s short s
1162 void rectcopy           short s short s short s short s short s short s
1163 if !solaris     void RGBcursor          short s short s short s short s short s short s short s
1164 #
1165 long getbutton          short s
1166 long getcmmode
1167 long getlsbackup
1168 long getresetls
1169 long getdcm
1170 long getzbuffer
1171 long ismex
1172 long isobj              long s
1173 long isqueued           short s
1174 long istag              long s
1175 #
1176 long genobj
1177 long gentag
1178 long getbuffer
1179 long getcolor
1180 long getdisplaymode
1181 long getfont
1182 long getheight
1183 long gethitcode
1184 long getlstyle
1185 long getlwidth
1186 long getmap
1187 long getplanes
1188 long getwritemask
1189 long qtest
1190 long getlsrepeat
1191 long getmonitor
1192 long getopenobj
1193 long getpattern
1194 long winget
1195 long winattach
1196 long getothermonitor
1197 long newpup
1198 #
1199 long getvaluator        short s
1200 void winset             long s
1201 long dopup              long s
1202 void getdepth           short r short r
1203 void getcpos            short r short r
1204 void getsize            long r long r
1205 void getorigin          long r long r
1206 void getviewport        short r short r short r short r
1207 if !solaris     void gettp              short r short r short r short r
1208 void getgpos            float r float r float r float r
1209 void winposition        long s long s long s long s
1210 void gRGBcolor          short r short r short r
1211 void gRGBmask           short r short r short r
1212 void getscrmask short r short r short r short r
1213 ###void gRGBcursor      short r short r short r short r short r short r short r short r
1214 void getmcolor          short s short r short r short r
1215 void mapw               long s short s short s float r float r float r float r float r float r
1216 void mapw2              long s short s short s float r float r
1217 ###void defrasterfont   short s short s short s Fontchar s[arg3] short s short s[4*arg5]
1218 ###long qread           short r
1219 void getcursor          short r u_short r u_short r long r
1220 #
1221 #   For these we receive arrays of stuff
1222 #
1223 ###void getdev          long s short s[arg1] short r[arg1]
1224 #XXX not generated correctly yet
1225 #void getmatrix         float r[16]
1226 ###long readpixels              short s short r[retval]
1227 ###long readRGB         short s char r[retval] char r[retval] char r[retval]
1228 ###long blkqread                short s short r[arg1]
1229 #
1230 #   New 4D routines
1231 #
1232 void cmode
1233 void concave            long s
1234 void curstype           long s
1235 void drawmode           long s
1236 void gammaramp          short s[256] short s[256] short s[256]
1237 long getbackface
1238 long getdescender
1239 long getdrawmode
1240 long getmmode
1241 long getsm
1242 long getvideo           long s
1243 void imakebackground
1244 void lmbind             short s short s
1245 void lmdef              long s long s long s float s[arg3]
1246 void mmode              long s
1247 void normal             float s[3]
1248 void overlay            long s
1249 void RGBrange           short s short s short s short s short s short s short s short s
1250 if !solaris     void setvideo           long s long s
1251 void shademodel         long s
1252 void underlay           long s
1253 #
1254 # New Personal Iris/GT Routines
1255 #
1256 void bgnclosedline
1257 void bgnline
1258 void bgnpoint
1259 void bgnpolygon
1260 void bgnsurface
1261 void bgntmesh
1262 void bgntrim
1263 void endclosedline
1264 void endline
1265 void endpoint
1266 void endpolygon
1267 void endsurface
1268 void endtmesh
1269 void endtrim
1270 void blendfunction      long s long s
1271 void c3f                float s[3]
1272 void c3i                long  s[3]
1273 void c3s                short s[3]
1274 void c4f                float s[4]
1275 void c4i                long  s[4]
1276 void c4s                short s[4]
1277 void colorf             float s
1278 void cpack              long s
1279 void czclear            long s long s
1280 void dglclose           long s
1281 long dglopen            char *s long s
1282 long getgdesc           long s
1283 void getnurbsproperty   long s float r
1284 void glcompat           long s long s
1285 void iconsize           long s long s
1286 void icontitle          char *s
1287 void lRGBrange          short s short s short s short s short s short s long s long s
1288 void linesmooth         long s
1289 void lmcolor            long s
1290 void logicop            long s
1291 ###long lrectread               short s short s short s short s long r[retval]
1292 ###void lrectwrite              short s short s short s short s long s[(arg2-arg1+1)*(arg4-arg3+1)]
1293 ### Now manual, with string last arg
1294 ###long rectread                short s short s short s short s short r[retval]
1295 ###void rectwrite               short s short s short s short s short s[(arg2-arg1+1)*(arg4-arg3+1)]
1296 void lsetdepth          long s long s
1297 void lshaderange        short s short s long s long s
1298 void n3f                float s[3]
1299 void noborder
1300 void pntsmooth          long s
1301 void readsource         long s
1302 void rectzoom           float s float s
1303 void sbox               float s float s float s float s
1304 void sboxi              long s long s long s long s
1305 void sboxs              short s short s short s short s
1306 void sboxf              float s float s float s float s
1307 void sboxfi             long s long s long s long s
1308 void sboxfs             short s short s short s short s
1309 void setnurbsproperty   long s float s
1310 void setpup             long s long s long s
1311 void smoothline         long s
1312 void subpixel           long s
1313 void swaptmesh
1314 long swinopen           long s
1315 void v2f                float s[2]
1316 void v2i                long  s[2]
1317 void v2s                short s[2]
1318 void v3f                float s[3]
1319 void v3i                long  s[3]
1320 void v3s                short s[3]
1321 void v4f                float s[4]
1322 void v4i                long  s[4]
1323 void v4s                short s[4]
1324 void videocmd           long s
1325 long windepth           long s
1326 void wmpack             long s
1327 void zdraw              long s
1328 void zfunction          long s
1329 void zsource            long s
1330 void zwritemask         long s
1331 #
1332 #   uses doubles
1333 #
1334 void v2d                double s[2]
1335 void v3d                double s[3]
1336 void v4d                double s[4]
1337 #
1338 # Why isn't this here?
1339 #
1340 void pixmode            long s long s
1341 #
1342 # New in IRIX 4.0
1343 #
1344 long qgetfd
1345 void dither             long s