vectorarray.c
Go to the documentation of this file.
1 /****************************************************************/
2 /* EUSLISP vector and array functions
3 /*
4 /* 1987-Sep-24
5 /* 1996-Jan Bignum return
6 /* Copyright Toshihiro MATSUI,Electrotechinical Laboratory,1988.
7 /****************************************************************/
8 static char *rcsid="@(#)$Id$";
9 
10 #include "../c/eus.h"
11 
12 pointer MKVECTOR(ctx,n,argv)
13 register context *ctx;
14 register int n;
15 register pointer argv[];
16 { register pointer v;
17  register int i;
18  v=makevector(C_VECTOR,n);
19  for (i=0; i<n; i++) v->c.vec.v[i]=argv[i];
20 #ifdef SAFETY
21  take_care(v);
22 #endif
23  return(v);}
24 
25 pointer MKINTVECTOR(ctx,n,argv)
26 register context *ctx;
27 register int n;
28 register pointer argv[];
29 { register pointer v;
30  register int i;
31  v=makevector(C_INTVECTOR,n);
32  for (i=0; i<n; i++) v->c.ivec.iv[i]=bigintval(argv[i]);
33 #ifdef SAFETY
34  take_care(v);
35 #endif
36  return(v);}
37 
38 pointer vref(a,n)
39  /*simple but not general vector (one dimensional) reference*/
40 register pointer a;
41 register int n;
42 { register eusinteger_t x;
43  numunion nu;
44  if (n<0 || vecsize(a)<=n ) error(E_ARRAYINDEX);
45  switch(elmtypeof(a)) {
46  case ELM_FIXED: error(E_NOVECTOR);
47  case ELM_CHAR:
48  case ELM_BYTE: return(makeint(a->c.str.chars[n]));
49  case ELM_FLOAT: return(makeflt(a->c.fvec.fv[n]));
50  case ELM_INT: x=a->c.ivec.iv[n]; return(mkbigint(x));
51 #if (WORD_SIZE == 64)
52  /*
53  hanai: 32 was hard coded.
54  This size must be equal to that of eusinteger_t.
55  Constant 1 must be written as 1L.
56  Otherwise 1 << 32 becomes 1, meaning 0x00000001.
57  */
58  case ELM_BIT: x=1L<<(n % 64);
59  if (a->c.ivec.iv[n/64] & x) return(makeint(1));
60  else return(makeint(0));
61 #else
62  case ELM_BIT: x=1<<(n % 32);
63  if (a->c.ivec.iv[n/32] & x) return(makeint(1));
64  else return(makeint(0));
65 #endif
66  case ELM_FOREIGN: return(makeint(((byte *)(a->c.ivec.iv[0]))[n]));
67  case ELM_POINTER:
68  default: return(a->c.vec.v[n]);}}
69 
70 pointer SVREF(ctx,n,argv)
71 register context *ctx;
72 int n;
73 register pointer argv[];
74 { register pointer a=argv[0];
75  ckarg(2);
76  n=ckintval(argv[1]);
77  if (n<0) error(E_ARRAYINDEX);
78  if (isvector(a)) {
79  if (elmtypeof(a)==ELM_POINTER) {
80  if (vecsize(a)<=n) error(E_ARRAYINDEX);
81  return(a->c.vec.v[n]);}
82  else error(E_NOVECTOR);}
83  else if (isnum(a)) error(E_NOVECTOR);
84  else if (objsize(a)<=n) error(E_ARRAYINDEX);
85  a=a->c.obj.iv[n];
86  if (a==UNBOUND) return(QUNBOUND);
87  return(a);}
88 
89 pointer vset(a,n,newval)
90 register pointer a;
91 register int n;
92 pointer newval;
93 { register int x,y;
94  numunion nu;
95  extern eusinteger_t coerceintval(pointer);
96 
97  if (n<0 || vecsize(a)<=n) error(E_ARRAYINDEX);
98  switch(elmtypeof(a)) {
99 #if (WORD_SIZE == 64)
100  case ELM_BIT:
101  x=1L<<(n % 64);
102  y=(ckintval(newval) & 1L)<<(n % 64);
103  a->c.ivec.iv[n/64]=(a->c.ivec.iv[n/64] & (~ x)) | y;
104  return(newval);
105 #else
106  case ELM_BIT:
107  x=1<<(n % 32);
108  y=(ckintval(newval) & 1)<<(n % 32);
109  a->c.ivec.iv[n/32]=a->c.ivec.iv[n/32] & (~ x) | y;
110  return(newval);
111 #endif
112  case ELM_BYTE: case ELM_CHAR:
113  a->c.str.chars[n]=ckintval(newval); return(newval);
114  case ELM_INT:
115  a->c.ivec.iv[n]=coerceintval(newval);
116  return(newval);
117  case ELM_FLOAT:
118  a->c.fvec.fv[n]=ckfltval(newval); return(newval);
119  case ELM_FOREIGN:
120  ((byte *)(a->c.ivec.iv[0]))[n]=ckintval(newval);
121  return(newval);
122  case ELM_POINTER:
123  pointer_update(a->c.vec.v[n],newval);
124  return(newval);} }
125 
126 pointer SVSET(ctx,n,argv)
127 register context *ctx;
128 register int n;
129 register pointer argv[];
130 { register pointer a=argv[0],newval=argv[2];
131  ckarg(3);
132  n=ckintval(argv[1]);
133  if (n<0) error(E_ARRAYINDEX);
134  if (isvector(a)) {
135  if (elmtypeof(a)==ELM_POINTER) {
136  if (vecsize(a)<=n) error(E_ARRAYINDEX);
137  pointer_update(a->c.vec.v[n],newval);
138  return(newval);}
139  else error(E_NOVECTOR);}
140  else if (isnum(a)) error(E_NOVECTOR);
141  else if (objsize(a)<=n) error(E_ARRAYINDEX);
142  pointer_update(a->c.obj.iv[n],newval);
143  return(newval);}
144 
145 
146 /****************************************************************/
147 /* A R R A Y
148 /****************************************************************/
149 
150 int arrayindex(a,n,indices)
151 register pointer a;
152 register int n;
153 register pointer *indices;
154 { register int index=0,i1,i2;
155  register pointer *dim=a->c.ary.dim,p1,p2;
156 
157  if (n!=intval(a->c.ary.rank)) error(E_ARRAYDIMENSION);
158  while (n-- >0) {
159  p1= *indices++;
160  p2= *dim++;
161  i1= ckintval(p1);
162  i2= intval(p2);
163  if (i1>=i2) error(E_ARRAYINDEX);
164  index=index*i2 + i1; }
165  return(index+intval(a->c.ary.offset));}
166 
167 pointer AREF(ctx,n,argv)
168 register context *ctx;
169 register int n;
170 register pointer argv[];
171 { register pointer a=argv[0];
172  register int i;
173  if (n<2) error(E_MISMATCHARG);
174  i=ckintval(argv[1]);
175 #if 0
176  printf("aref %d\n", i);
177 #endif
178  if (isvector(a)){ return(vref(a,i));}
179 #if 0
180  printf("aref ok\n");
181 #endif
182  if (!isarray(a)) error(E_NOARRAY);
183  else return((pointer)vref(a->c.ary.entity,arrayindex(a,n-1,&argv[1])));}
184 
185 pointer ASET(ctx,n,argv)
186 register context *ctx;
187 register int n;
188 register pointer argv[];
189 { register pointer a=argv[0];
190  register pointer val=argv[n-1];
191 
192  if (n<3) error(E_MISMATCHARG);
193  if (isvector(a)) return(vset(a,ckintval(argv[1]),val));
194  if (!isarray(a)) error(E_NOARRAY);
195  return(vset(a->c.ary.entity,arrayindex(a,n-2,&argv[1]),val));}
196 
197 pointer ARRAYP(ctx,n,argv)
198 register context *ctx;
199 int n;
200 register pointer argv[];
201 { ckarg(1);
202  if (isnum(argv[0])) return(NIL);
203  else if (isarray(argv[0])) return(T);
204  else if (isvector(argv[0])) return(T);
205  else return(NIL);}
206 
207 pointer VECTORPOP(ctx,n,argv)
208 register context *ctx;
209 int n;
210 pointer argv[];
211 { register pointer a=argv[0],r;
212  register int fp;
213 
214  ckarg(1);
215  printf("vectorpop\n");
216  if (!isarray(a)) error(E_NOARRAY);
217  if (intval(a->c.ary.rank)!=1) error(E_ARRAYDIMENSION);
218  fp=intval(a->c.ary.fillpointer);
219  if (fp==0) error(E_ARRAYINDEX);
220  fp--;
221  r=(pointer)vref(a->c.ary.entity,fp+intval(a->c.ary.offset));
222  a->c.ary.fillpointer=makeint(fp);
223  return(r);}
224 
225 pointer VECTORPUSH(ctx,n,argv)
226 register context *ctx;
227 int n;
228 pointer argv[];
229 { register pointer a=argv[1];
230  register int fp;
231 
232  ckarg(2);
233  if (!isarray(a)) error(E_NOARRAY);
234  if (intval(a->c.ary.rank)!=1) error(E_ARRAYDIMENSION);
235  fp=ckintval(a->c.ary.fillpointer);
236  vset(a->c.ary.entity,fp+intval(a->c.ary.offset),argv[0]);
237  a->c.ary.fillpointer=makeint(fp+1);
238  return(argv[0]);}
239 
240 pointer VECTOREXPUSH(ctx,n,argv) /*vector-push-extend*/
241 register context *ctx;
242 int n;
243 pointer argv[];
244 { register pointer a=argv[1],entity,new;
245  register int i,fp,vsize;
246 
247  ckarg(2);
248  if (!isarray(a)) error(E_NOARRAY);
249  if (intval(a->c.ary.rank)!=1) error(E_ARRAYDIMENSION);
250  fp=ckintval(a->c.ary.fillpointer);
251  entity=a->c.ary.entity;
252  vsize=vecsize(entity);
253  if (fp>=vsize) { /*extend vector*/
254  new=makevector(classof(entity),fp*2);
255  switch(elmtypeof(entity)) {
256  case ELM_BIT: n=(vsize+WORD_SIZE-1)/WORD_SIZE; break;
257  case ELM_CHAR: case ELM_BYTE: n=(vsize+sizeof(eusinteger_t))/sizeof(eusinteger_t); break;
258  default: n=vsize;}
259  for (i=0; i<n; i++) pointer_update(new->c.vec.v[i],entity->c.vec.v[i]);
260  entity=new;
261  pointer_update(a->c.ary.entity,entity);
262  a->c.ary.dim[0]=makeint(fp*2);}
263  vset(entity,fp,argv[0]);
264  a->c.ary.fillpointer=makeint(fp+1);
265  return(argv[0]);}
266 
267 pointer VECTORP(ctx,n,argv)
268 register context *ctx;
269 int n;
270 pointer argv[];
271 { register pointer a=argv[0];
272  ckarg(1);
273  if (ispointer(a)) return(elmtypeof(a)?T:NIL);
274  else return(NIL);}
275 
276 /****************************************************************/
277 /* bit vector
278 /****************************************************************/
279 
280 #define isbitvector(p) (isvector(p) && (elmtypeof(p)==ELM_BIT))
281 
282 pointer BIT(ctx,n,argv)
283 register context *ctx;
284 int n;
285 pointer argv[];
286 { pointer a=argv[0];
287  eusinteger_t x;
288  ckarg(2);
289  n=ckintval(argv[1]);
290 #if (WORD_SIZE == 64)
291  if (isbitvector(a)) {
292  if (n<0 || vecsize(a)<=n) error(E_ARRAYINDEX);
293  x=(a->c.ivec.iv[n/64]) & (1L<<(n % 64));
294  return(makeint(x?1L:0L));}
295 #else
296  if (isbitvector(a)) {
297  if (n<0 || vecsize(a)<=n) error(E_ARRAYINDEX);
298  x=(a->c.ivec.iv[n/32]) & (1<<(n % 32));
299  return(makeint(x?1:0));}
300 #endif
301  else error(E_BITVECTOR);}
302 
303 pointer SETBIT(ctx,n,argv)
304 register context *ctx;
305 int n;
306 pointer argv[];
307 { pointer a=argv[0];
308  int val;
309  ckarg(3);
310  n=ckintval(argv[1]);
311  val=ckintval(argv[2]) & 1;
312 #if (WORD_SIZE == 64)
313  if (isbitvector(a)) {
314  if (n<0 || vecsize(a)<=n) error(E_ARRAYINDEX);
315  if (val) a->c.ivec.iv[n/64]|= (1L<<(n%64));
316  else a->c.ivec.iv[n/64]&= ~(1L<<(n%64));
317  return(makeint(val));}
318 #else
319  if (isbitvector(a)) {
320  if (n<0 || vecsize(a)<=n) error(E_ARRAYINDEX);
321  if (val) a->c.ivec.iv[n/32]|= (1<<(n%32));
322  else a->c.ivec.iv[n/32]&= ~(1<<(n%32));
323  return(makeint(val));}
324 #endif
325  else error(E_BITVECTOR);}
326 
327 pointer BITAND(ctx,n,argv)
328 register context *ctx;
329 register int n;
330 register pointer argv[];
331 { pointer result;
332  register eusinteger_t *bv1, *bv2, *rbv, s; register long i=0;
333  ckarg2(2,3);
334  if (!isbitvector(argv[0]) || !isbitvector(argv[1])) error(E_BITVECTOR);
335  s=vecsize(argv[0]);
336  if (s!=vecsize(argv[1])) error(E_ARRAYINDEX);
337  if (n==3) {
338  result=argv[2];
339  if (!isbitvector(result)) error(E_BITVECTOR);
340  if (s!=vecsize(result)) error(E_ARRAYINDEX);}
341  else result=makevector(C_BITVECTOR,s);
342  bv1=argv[0]->c.ivec.iv; bv2=argv[1]->c.ivec.iv; rbv=result->c.ivec.iv;
343  while (i<(s+WORD_SIZE-1)/WORD_SIZE) { rbv[i]=bv1[i] & bv2[i]; i++;}
344  return(result);}
345 
346 pointer BITIOR(ctx,n,argv)
347 register context *ctx;
348 register int n;
349 register pointer argv[];
350 { pointer result;
351  register eusinteger_t *bv1, *bv2, *rbv, s; register long i=0;
352  ckarg2(2,3);
353  if (!isbitvector(argv[0]) || !isbitvector(argv[1])) error(E_BITVECTOR);
354  s=vecsize(argv[0]);
355  if (s!=vecsize(argv[1])) error(E_ARRAYINDEX);
356  if (n==3) {
357  result=argv[2];
358  if (!isbitvector(result)) error(E_BITVECTOR);
359  if (s!=vecsize(result)) error(E_ARRAYINDEX);}
360  else result=makevector(C_BITVECTOR,s);
361  bv1=argv[0]->c.ivec.iv; bv2=argv[1]->c.ivec.iv; rbv=result->c.ivec.iv;
362  while (i<(s+WORD_SIZE-1)/WORD_SIZE) { rbv[i]=bv1[i] | bv2[i]; i++;}
363  return(result);}
364 
365 pointer BITXOR(ctx,n,argv)
366 register context *ctx;
367 register int n;
368 register pointer argv[];
369 { pointer result;
370  register eusinteger_t *bv1, *bv2, *rbv, s; register long i=0;
371  ckarg2(2,3);
372  if (!isbitvector(argv[0]) || !isbitvector(argv[1])) error(E_BITVECTOR);
373  s=vecsize(argv[0]);
374  if (s!=vecsize(argv[1])) error(E_ARRAYINDEX);
375  if (n==3) {
376  result=argv[2];
377  if (!isbitvector(result)) error(E_BITVECTOR);
378  if (s!=vecsize(result)) error(E_ARRAYINDEX);}
379  else result=makevector(C_BITVECTOR,s);
380  bv1=argv[0]->c.ivec.iv; bv2=argv[1]->c.ivec.iv; rbv=result->c.ivec.iv;
381  while (i<(s+WORD_SIZE-1)/WORD_SIZE) { rbv[i]=bv1[i] ^ bv2[i]; i++;}
382  return(result);}
383 
384 pointer BITEQV(ctx,n,argv)
385 register context *ctx;
386 register int n;
387 register pointer argv[];
388 { pointer result;
389  register eusinteger_t *bv1, *bv2, *rbv, s; register long i=0;
390  ckarg2(2,3);
391  if (!isbitvector(argv[0]) || !isbitvector(argv[1])) error(E_BITVECTOR);
392  s=vecsize(argv[0]);
393  if (s!=vecsize(argv[1])) error(E_ARRAYINDEX);
394  if (n==3) {
395  result=argv[2];
396  if (!isbitvector(result)) error(E_BITVECTOR);
397  if (s!=vecsize(result)) error(E_ARRAYINDEX);}
398  else result=makevector(C_BITVECTOR,s);
399  bv1=argv[0]->c.ivec.iv; bv2=argv[1]->c.ivec.iv; rbv=result->c.ivec.iv;
400  while (i<(s+WORD_SIZE-1)/WORD_SIZE) { rbv[i]= ~(bv1[i] ^ bv2[i]); i++;}
401  return(result);}
402 
403 pointer BITNAND(ctx,n,argv)
404 register context *ctx;
405 register int n;
406 register pointer argv[];
407 { pointer result;
408  register eusinteger_t *bv1, *bv2, *rbv, s; register long i=0;
409  ckarg2(2,3);
410  if (!isbitvector(argv[0]) || !isbitvector(argv[1])) error(E_BITVECTOR);
411  s=vecsize(argv[0]);
412  if (s!=vecsize(argv[1])) error(E_ARRAYINDEX);
413  if (n==3) {
414  result=argv[2];
415  if (!isbitvector(result)) error(E_BITVECTOR);
416  if (s!=vecsize(result)) error(E_ARRAYINDEX);}
417  else result=makevector(C_BITVECTOR,s);
418  bv1=argv[0]->c.ivec.iv; bv2=argv[1]->c.ivec.iv; rbv=result->c.ivec.iv;
419  while (i<(s+WORD_SIZE-1)/WORD_SIZE) { rbv[i]= ~(bv1[i] & bv2[i]); i++;}
420  return(result);}
421 
422 pointer BITNOR(ctx,n,argv)
423 register context *ctx;
424 register int n;
425 register pointer argv[];
426 { pointer result;
427  register eusinteger_t *bv1, *bv2, *rbv, s; register long i=0;
428  ckarg2(2,3);
429  if (!isbitvector(argv[0]) || !isbitvector(argv[1])) error(E_BITVECTOR);
430  s=vecsize(argv[0]);
431  if (s!=vecsize(argv[1])) error(E_ARRAYINDEX);
432  if (n==3) {
433  result=argv[2];
434  if (!isbitvector(result)) error(E_BITVECTOR);
435  if (s!=vecsize(result)) error(E_ARRAYINDEX);}
436  else result=makevector(C_BITVECTOR,s);
437  bv1=argv[0]->c.ivec.iv; bv2=argv[1]->c.ivec.iv; rbv=result->c.ivec.iv;
438  while (i<(s+WORD_SIZE-1)/WORD_SIZE) { rbv[i]= ~(bv1[i] | bv2[i]); i++;}
439  return(result);}
440 
441 pointer BITNOT(ctx,n,argv)
442 register context *ctx;
443 register int n;
444 register pointer argv[];
445 { pointer result;
446  register eusinteger_t *bv1, *rbv, s; register long i=0;
447  ckarg2(1,2);
448  if (!isbitvector(argv[0])) error(E_BITVECTOR);
449  s=vecsize(argv[0]);
450  if (n==2) {
451  result=argv[1];
452  if (!isbitvector(result)) error(E_BITVECTOR);
453  if (s!=vecsize(result)) error(E_ARRAYINDEX);}
454  else result=makevector(C_BITVECTOR,s);
455  bv1=argv[0]->c.ivec.iv; rbv=result->c.ivec.iv;
456  while (i<(s+WORD_SIZE-1)/WORD_SIZE) { rbv[i]= ~bv1[i]; i++;}
457  return(result);}
458 
459 void vectorarray(ctx,mod)
460 register context *ctx;
461 pointer mod;
462 {
463  defun(ctx,"AREF",mod,AREF,NULL);
464  defun(ctx,"ASET",mod,ASET,NULL);
465  defun(ctx,"VECTOR-POP",mod,VECTORPOP,NULL);
466  defun(ctx,"VECTOR-PUSH",mod,VECTORPUSH,NULL);
467  defun(ctx,"VECTOR-PUSH-EXTEND",mod,VECTOREXPUSH,NULL);
468  defun(ctx,"ARRAYP",mod,ARRAYP,NULL);
469  defun(ctx,"SVREF",mod,SVREF,NULL);
470  defun(ctx,"SVSET",mod,SVSET,NULL);
471  defun(ctx,"VECTOR",mod,MKVECTOR,NULL);
472  defun(ctx,"VECTORP",mod,VECTORP,NULL);
473  defun(ctx,"INTEGER-VECTOR",mod,MKINTVECTOR,NULL);
474  defun(ctx,"BIT",mod,BIT,NULL);
475  defun(ctx,"SBIT",mod,BIT,NULL);
476  defun(ctx,"SETBIT",mod,SETBIT,NULL);
477  defun(ctx,"BIT-AND",mod,BITAND,NULL);
478  defun(ctx,"BIT-IOR",mod,BITIOR,NULL);
479  defun(ctx,"BIT-XOR",mod,BITXOR,NULL);
480  defun(ctx,"BIT-EQV",mod,BITEQV,NULL);
481  defun(ctx,"BIT-NAND",mod,BITNAND,NULL);
482  defun(ctx,"BIT-NOR",mod,BITNOR,NULL);
483  defun(ctx,"BIT-NOT",mod,BITNOT,NULL);
484  }
vectorarray
void vectorarray(context *ctx, pointer mod)
Definition: vectorarray.c:459
numunion
Definition: eus.h:428
SVSET
pointer SVSET(context *ctx, int n, argv)
Definition: vectorarray.c:126
arrayindex
int arrayindex(pointer a, int n, pointer *indices)
Definition: vectorarray.c:150
NIL
pointer NIL
Definition: eus.c:110
QUNBOUND
pointer QUNBOUND
Definition: eus.c:123
defun
defun("ADR_TO_STRING", mod, ADR_TO_STRING)
VECTORP
pointer VECTORP(context *ctx, int n, argv)
Definition: vectorarray.c:267
makeint
#define makeint(v)
Definition: sfttest.c:2
context
Definition: eus.h:524
s
short s
Definition: structsize.c:2
BITNAND
pointer BITNAND(context *ctx, int n, argv)
Definition: vectorarray.c:403
AREF
pointer AREF(context *ctx, int n, argv)
Definition: vectorarray.c:167
BITNOR
pointer BITNOR(context *ctx, int n, argv)
Definition: vectorarray.c:422
makevector
pointer makevector(pointer, int)
Definition: makes.c:417
intval
#define intval(p)
Definition: sfttest.c:1
E_ARRAYDIMENSION
@ E_ARRAYDIMENSION
Definition: eus.h:996
ckfltval
float ckfltval()
T
pointer T
Definition: eus.c:110
pointer
struct cell * pointer
Definition: eus.h:165
E_MISMATCHARG
@ E_MISMATCHARG
Definition: eus.h:942
C_VECTOR
pointer C_VECTOR
Definition: eus.c:144
SVREF
pointer SVREF(context *ctx, int n, argv)
Definition: vectorarray.c:70
BIT
pointer BIT(context *ctx, int n, argv)
Definition: vectorarray.c:282
cell::cellunion::ivec
struct intvector ivec
Definition: eus.h:416
MKINTVECTOR
pointer MKINTVECTOR(context *ctx, int n, argv)
Definition: vectorarray.c:25
SETBIT
pointer SETBIT(context *ctx, int n, argv)
Definition: vectorarray.c:303
coerceintval
eusinteger_t coerceintval(pointer)
Definition: sequence.c:55
cell::c
union cell::cellunion c
E_ARRAYINDEX
@ E_ARRAYINDEX
Definition: eus.h:967
vset
pointer vset(pointer a, int n, pointer newval)
Definition: vectorarray.c:89
VECTOREXPUSH
pointer VECTOREXPUSH(context *ctx, int n, argv)
Definition: vectorarray.c:240
NULL
#define NULL
Definition: transargv.c:8
BITNOT
pointer BITNOT(context *ctx, int n, argv)
Definition: vectorarray.c:441
VECTORPOP
pointer VECTORPOP(context *ctx, int n, argv)
Definition: vectorarray.c:207
E_NOVECTOR
@ E_NOVECTOR
Definition: eus.h:963
rcsid
static char * rcsid
Definition: vectorarray.c:8
makeflt
pointer makeflt()
error
pointer error(enum errorcode ec,...) pointer error(va_alist) va_dcl
Definition: eus.c:297
BITEQV
pointer BITEQV(context *ctx, int n, argv)
Definition: vectorarray.c:384
C_BITVECTOR
pointer C_BITVECTOR
Definition: eus.c:146
E_NOARRAY
@ E_NOARRAY
Definition: eus.h:995
MKVECTOR
pointer MKVECTOR(context *ctx, int n, argv)
Definition: vectorarray.c:12
E_BITVECTOR
@ E_BITVECTOR
Definition: eus.h:1001
BITXOR
pointer BITXOR(context *ctx, int n, argv)
Definition: vectorarray.c:365
cell
Definition: eus.h:381
eusinteger_t
long eusinteger_t
Definition: eus.h:19
ARRAYP
pointer ARRAYP(context *ctx, int n, argv)
Definition: vectorarray.c:197
ASET
pointer ASET(context *ctx, int n, argv)
Definition: vectorarray.c:185
index
char * index(char *sp, char c)
Definition: eustags.c:1669
vref
pointer vref(pointer a, int n)
Definition: vectorarray.c:38
BITIOR
pointer BITIOR(context *ctx, int n, argv)
Definition: vectorarray.c:346
C_INTVECTOR
pointer C_INTVECTOR
Definition: eus.c:146
BITAND
pointer BITAND(context *ctx, int n, argv)
Definition: vectorarray.c:327
intvector::iv
eusinteger_t iv[1]
Definition: eus.h:305
a
char a[26]
Definition: freq.c:4
VECTORPUSH
pointer VECTORPUSH(context *ctx, int n, argv)
Definition: vectorarray.c:225
n
GLfloat n[6][3]
Definition: cube.c:15
v
GLfloat v[8][3]
Definition: cube.c:21
ckarg
ckarg(2)

euslisp
Author(s): Toshihiro Matsui
autogenerated on Thu Jun 15 2023 02:06:43