![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / parse|
Return to util.c CVS log | Up to [local] / OpenXM_contrib2 / asir2000 / parse |
1.2 noro 1: /*
2: * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
3: * All rights reserved.
4: *
5: * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
6: * non-exclusive and royalty-free license to use, copy, modify and
7: * redistribute, solely for non-commercial and non-profit purposes, the
8: * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
9: * conditions of this Agreement. For the avoidance of doubt, you acquire
10: * only a limited right to use the SOFTWARE hereunder, and FLL or any
11: * third party developer retains all rights, including but not limited to
12: * copyrights, in and to the SOFTWARE.
13: *
14: * (1) FLL does not grant you a license in any way for commercial
15: * purposes. You may use the SOFTWARE only for non-commercial and
16: * non-profit purposes only, such as academic, research and internal
17: * business use.
18: * (2) The SOFTWARE is protected by the Copyright Law of Japan and
19: * international copyright treaties. If you make copies of the SOFTWARE,
20: * with or without modification, as permitted hereunder, you shall affix
21: * to all such copies of the SOFTWARE the above copyright notice.
22: * (3) An explicit reference to this SOFTWARE and its copyright owner
23: * shall be made on your publication or presentation in any form of the
24: * results obtained by use of the SOFTWARE.
25: * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
1.3 noro 26: * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
1.2 noro 27: * for such modification or the source code of the modified part of the
28: * SOFTWARE.
29: *
30: * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
31: * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
32: * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
33: * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
34: * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
35: * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
36: * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
37: * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
38: * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
39: * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
40: * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
41: * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
42: * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
43: * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
44: * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
45: * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
46: * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
47: *
1.11 ! noro 48: * $OpenXM: OpenXM_contrib2/asir2000/parse/util.c,v 1.10 2003/08/23 01:42:53 noro Exp $
1.2 noro 49: */
1.1 noro 50: #include "ca.h"
51: #include "base.h"
52: #include "parse.h"
1.10 noro 53: #if defined(__GNUC__) || defined(VISUAL) || (defined(__MACH__) && defined(__ppc__)) || defined(__FreeBSD__)
1.1 noro 54: #include <stdarg.h>
55: #else
56: #include <varargs.h>
57: #endif
58: #include <ctype.h>
59:
60: int length(n)
61: NODE n;
62: {
63: int i;
64:
65: for ( i = 0; n; n = NEXT(n), i++ );
66: return i;
67: }
68:
69: int argc(a)
70: NODE a;
71: {
72: int i;
73:
74: for ( i = 0; a; i++, a = NEXT(a) );
75: return ( i );
76: }
77:
78: void stoarg(s,acp,av)
79: char *s;
80: int *acp;
81: char **av;
82: {
83: int i;
84:
85: for ( i = 0; ; i++ ) {
86: for ( ; *s && isspace(*s); s++ );
87: if ( *s ) {
88: for ( av[i] = s; *s && !isspace(*s); s++ );
89: if ( *s )
90: *s++ = 0;
91: } else {
92: *acp = i;
93: return;
94: }
95: }
96: }
97:
98: #if 0
99: unsigned int ator(addr,r)
100: unsigned int addr;
101: Obj *r;
102: {
103: N n;
104: Q q;
105:
106: if ( !addr )
107: q = 0;
108: if ( addr < BASE )
109: STOQ(addr,q);
110: else {
111: n = NALLOC(2); PL(n) = 2;
112: BD(n)[0] = addr-BASE; BD(n)[1] = addr>>BSH; NTOQ(n,1,q);
113: }
114: *r = (Obj)q;
115: }
116: #endif
117:
118: void getarray(a,ind,vp)
119: pointer a;
120: NODE ind;
121: pointer *vp;
122: {
123: Obj len,row,col;
1.8 noro 124: int i;
1.1 noro 125: NODE n,n0;
126: VECT v;
1.4 noro 127: Q q;
1.1 noro 128:
1.4 noro 129: if ( a && OID(a) == O_BYTEARRAY ) {
130: len = (Obj)BDY(ind);
131: if ( !rangecheck(len,((BYTEARRAY)a)->len) )
132: error("getarray : Out of range");
133: else if ( NEXT(ind) )
134: error("getarray : invalid index");
135: else {
136: i = (int)BDY((BYTEARRAY)a)[QTOS((Q)len)];
137: STOQ(i,q);
138: *vp = (pointer)q;
139: }
140: return;
141: }
1.1 noro 142: for ( ; ind; ind = NEXT(ind) ) {
143: if ( !a )
144: error("getarray : array or list expected");
145: switch ( OID(a) ) {
146: case O_VECT:
147: len = (Obj)BDY(ind);
148: if ( !rangecheck(len,((VECT)a)->len) )
149: error("getarray : Out of range");
150: else
151: a = (pointer)(BDY((VECT)a)[QTOS((Q)len)]);
152: break;
153: case O_MAT:
154: row = (Obj)BDY(ind);
155: if ( !rangecheck(row,((MAT)a)->row) )
156: error("getarray : Out of range");
157: else if ( NEXT(ind) ) {
158: ind = NEXT(ind);
159: col = (Obj)BDY(ind);
160: if ( !rangecheck(col,((MAT)a)->col) )
161: error("getarray : Out of range");
162: else
163: a = (pointer)(BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)]);
164: } else {
165: NEWVECT(v); v->len = ((MAT)a)->col;
166: v->body = (pointer *)BDY((MAT)a)[QTOS((Q)row)];
167: a = (pointer)v;
168: }
169: break;
170: case O_LIST:
171: n0 = BDY((LIST)a); i = QTOS((Q)BDY(ind));
1.6 noro 172: if ( i < 0 )
1.1 noro 173: error("getarray : Out of range");
1.6 noro 174: for ( n = n0; i > 0 && n; n = NEXT(n), i-- );
175: if ( i || !n )
176: error("getarray : Out of range");
177: else
1.1 noro 178: a = (pointer)BDY(n);
179: break;
180: default:
181: error("getarray : array or list expected");
182: break;
183: }
184: }
185: *vp = a;
186: }
187:
188: void putarray(a,ind,b)
189: pointer a;
190: NODE ind;
191: pointer b;
192: {
193: Obj len,row,col;
1.8 noro 194: int i;
1.1 noro 195: NODE n,n0;
196:
1.4 noro 197: if ( a && OID(a) == O_BYTEARRAY ) {
198: len = (Obj)BDY(ind);
199: if ( !rangecheck(len,((BYTEARRAY)a)->len) )
200: error("putarray : Out of range");
201: else if ( NEXT(ind) )
202: error("putarray : invalid index");
203: else
204: BDY((BYTEARRAY)a)[QTOS((Q)len)] = (unsigned char)QTOS((Q)b);
205: return;
206: }
1.1 noro 207: for ( ; ind; ind = NEXT(ind) ) {
208: if ( !a )
209: error("putarray : array expected");
210: switch ( OID(a) ) {
211: case O_VECT:
212: len = (Obj)BDY(ind);
213: if ( !rangecheck(len,((VECT)a)->len) )
214: error("putarray : Out of range");
215: else if ( NEXT(ind) )
216: a = BDY((VECT)a)[QTOS((Q)len)];
217: else
218: BDY((VECT)a)[QTOS((Q)len)] = b;
219: break;
220: case O_MAT:
221: row = (Obj)BDY(ind);
222: if ( !rangecheck(row,((MAT)a)->row) )
223: error("putarray : Out of range");
224: else if ( NEXT(ind) ) {
225: ind = NEXT(ind);
226: col = (Obj)BDY(ind);
227: if ( !rangecheck(col,((MAT)a)->col) )
228: error("putarray : Out of range");
229: else if ( NEXT(ind) )
230: a = BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)];
231: else
232: BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)] = b;
233: } else
234: error("putarray : invalid assignment");
235: break;
236: case O_LIST:
237: if ( NEXT(ind) ) {
238: n0 = BDY((LIST)a); i = QTOS((Q)BDY(ind));
1.6 noro 239: if ( i < 0 )
1.1 noro 240: error("putarray : Out of range");
1.6 noro 241: for ( n = n0; i > 0 && n; n = NEXT(n), i-- );
242: if ( i || !n )
243: error("puarray : Out of range");
244: else
1.1 noro 245: a = (pointer)BDY(n);
246: } else
247: error("putarray : invalid assignment");
248: break;
249: default:
250: error("putarray : array expected");
251: break;
252: }
253: }
254: }
255:
256: int rangecheck(a,n)
257: Obj a;
258: int n;
259: {
260: N m;
261:
262: if ( !a )
263: return 1;
264: if ( OID(a) != O_N || !RATN(a) || !INT(a) || SGN((Q)a) < 0 )
265: return 0;
266: m = NM((Q)a);
267: if ( PL(m) > 1 || BD(m)[0] >= (unsigned int)n )
268: return 0;
269: return 1;
270: }
271:
272: int zp(p)
273: P p;
274: {
275: int r;
276: DCP dc;
277:
278: if ( !p )
279: r = 1;
280: else if ( NUM(p) )
281: r = INT((Q)p)?1:0;
282: else
283: for ( dc = DC(p), r = 1; dc && r; dc = NEXT(dc) )
284: r &= zp(COEF(dc));
285: return ( r );
286: }
287:
1.10 noro 288: #if defined(__GNUC__) || defined(VISUAL) || (defined(__MACH__) && defined(__ppc__)) || defined(__FreeBSD__)
1.1 noro 289: NODE mknode(int ac,...)
290: {
291: va_list ap;
292: int i;
293: NODE n0,n;
294:
295: va_start(ap,ac);
296: for ( i = 0, n0 = 0; i < ac; i++ ) {
297: NEXTNODE(n0,n);
298: BDY(n)=va_arg(ap, pointer);
299: }
300: va_end(ap);
301: if ( n0 )
302: NEXT(n)=0;
303: return n0;
304: }
305:
306: FNODE mkfnode(int ac,fid id,...)
307: {
308: va_list ap;
309: int i;
310: FNODE r;
311:
312: va_start(ap,id);
313: NEWFNODE(r,ac); ID(r) = id;
314: for ( i = 0; i < ac; i++ )
315: r->arg[i] = va_arg(ap, pointer);
316: va_end(ap);
317: return r;
318: }
319:
320: SNODE mksnode(int ac,sid id,...)
321: {
322: va_list ap;
323: int i;
324: SNODE r;
325:
326: va_start(ap,id);
327: NEWSNODE(r,ac); ID(r) = id;
328: for ( i = 0; i < ac; i++ )
329: r->arg[i] = va_arg(ap, pointer);
330: va_end(ap);
331: return r;
332: }
333: #else
334: NODE mknode(va_alist)
335: va_dcl
336: {
337: va_list ap;
338: int ac,i;
339: NODE n0,n;
340:
341: va_start(ap);
342: ac = va_arg(ap,int);
343: for ( i = 0, n0 = 0; i < ac; i++ ) {
344: NEXTNODE(n0,n);
345: BDY(n)=va_arg(ap, pointer);
346: }
347: va_end(ap);
348: if ( n0 )
349: NEXT(n)=0;
350: return n0;
351: }
352:
353: FNODE mkfnode(va_alist)
354: va_dcl
355: {
356: va_list ap;
357: int ac,i;
358: FNODE r;
359:
360: va_start(ap);
361: ac = va_arg(ap, int);
362: NEWFNODE(r,ac); ID(r) = va_arg(ap, fid);
363: for ( i = 0; i < ac; i++ )
364: r->arg[i] = va_arg(ap, pointer);
365: va_end(ap);
366: return r;
367: }
368:
369: SNODE mksnode(va_alist)
370: va_dcl
371: {
372: va_list ap;
373: int ac,i;
374: SNODE r;
375:
376: va_start(ap);
377: ac = va_arg(ap, int);
378: NEWSNODE(r,ac); ID(r) = va_arg(ap, sid);
379: for ( i = 0; i < ac; i++ )
380: r->arg[i] = va_arg(ap, pointer);
381: va_end(ap);
382: return r;
383: }
384: #endif
385:
386: void makevar(str,p)
387: char *str;
388: P *p;
389: {
390: VL vl;
391: V v;
392: P t;
393:
394: for ( vl = CO; ; )
395: if ( NAME(VR(vl)) && !strcmp(NAME(VR(vl)),str) ) {
396: MKV(VR(vl),t); *p = t;
397: return;
398: } else if ( !NEXT(vl) ) {
399: NEWV(v); v->attr = (pointer)V_IND;
400: NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));
401: strcpy(NAME(v),str);
402: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
403: MKV(v,t); *p = t;
404: return;
405: } else
406: vl = NEXT(vl);
407: }
408:
409: void makesrvar(f,p)
410: FUNC f;
411: P *p;
412: {
413: VL vl;
414: V v;
415: P t;
416: char *str;
417:
1.11 ! noro 418: for ( vl = CO, str = f->fullname; ; )
1.1 noro 419: if ( NAME(VR(vl)) && !strcmp(NAME(VR(vl)),str) ) {
420: VR(vl)->attr = (pointer)V_SR; VR(vl)->priv = (pointer)f;
421: MKV(VR(vl),t); *p = t;
422: return;
423: } else if ( !NEXT(vl) ) {
424: NEWV(v); v->attr = (pointer)V_SR; v->priv = (pointer)f;
425: NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));
426: strcpy(NAME(v),str);
427: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
428: MKV(v,t); *p = t;
429: return;
430: } else
431: vl = NEXT(vl);
432: }
433:
434: void appendtonode(n,a,nrp)
435: NODE n;
436: pointer a;
437: NODE *nrp;
438: {
439: NODE tn;
440:
441: if ( !n )
442: MKNODE(*nrp,a,0);
443: else {
444: for ( tn = n; NEXT(tn); tn = NEXT(tn) );
445: MKNODE(NEXT(tn),a,0); *nrp = n;
446: }
447: }
448:
449: void appendtonode2(n,a,b,nrp)
450: NODE2 n;
451: pointer a,b;
452: NODE2 *nrp;
453: {
454: NODE2 tn;
455:
456: if ( !n )
457: MKNODE2(*nrp,a,b,0);
458: else {
459: for ( tn = n; NEXT(tn); tn = NEXT(tn) );
460: MKNODE2(NEXT(tn),a,b,0); *nrp = n;
461: }
462: }
463:
464: void appendvar(vl,v)
465: VL vl;
466: V v;
467: {
468: while (1)
469: if ( vl->v == v )
470: return;
471: else if ( !NEXT(vl) ) {
472: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
473: return;
474: } else
475: vl = NEXT(vl);
476: }
477:
478: void reallocarray(arrayp,sizep,indexp,esize)
479: char **arrayp;
480: int *sizep,*indexp;
481: int esize;
482: {
483: char *new;
484:
485: if ( *arrayp ) {
486: *sizep *= 2;
487: new = (char *)MALLOC((*sizep)*esize);
488: bcopy(*arrayp,new,*indexp*esize);
489: *arrayp = new;
490: } else {
491: *sizep = DEFSIZE; *indexp = 0;
492: new = (char *)MALLOC((*sizep)*esize);
493: bzero(new,DEFSIZE*esize);
494: *arrayp = new;
495: }
496: }