Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20090521102731

Diff

Diff from 1.90 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/mip/common.c

Annotated File View

ragge
1.90
1 /*      $Id: common.c,v 1.90 2009/05/21 10:27:31 ragge Exp $    */
ragge
1.29
2 /*
3  * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 /*
28  * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
29  *
30  * Redistribution and use in source and binary forms, with or without
31  * modification, are permitted provided that the following conditions
32  * are met:
33  *
34  * Redistributions of source code and documentation must retain the above
35  * copyright notice, this list of conditions and the following disclaimer.
36  * Redistributions in binary form must reproduce the above copyright
37  * notice, this list of conditionsand the following disclaimer in the
38  * documentation and/or other materials provided with the distribution.
39  * All advertising materials mentioning features or use of this software
40  * must display the following acknowledgement:
41  *      This product includes software developed or owned by Caldera
42  *      International, Inc.
43  * Neither the name of Caldera International, Inc. nor the names of other
44  * contributors may be used to endorse or promote products derived from
45  * this software without specific prior written permission.
46  *
47  * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
48  * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
49  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
50  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
51  * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
52  * FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55  * HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
56  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
57  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
58  * POSSIBILITY OF SUCH DAMAGE.
59  */
ragge
1.1
60
ragge
1.2
61 #include <stdarg.h>
62 #include <stdlib.h>
ragge
1.10
63 #include <stdio.h>
pj
1.54
64 #include <string.h>
ragge
1.2
65
ragge
1.32
66 #include "pass2.h"
ragge
1.1
67
68 # ifndef EXIT
69 # define EXIT exit
70 # endif
71
72 int nerrors = 0;  /* number of errors */
ragge
1.37
73 char *ftitle;
74 int lineno;
ragge
1.1
75
gmcgarry
1.76
76 int warniserr = 0;
77
ragge
1.10
78 #ifndef WHERE
79 #define WHERE(ch) fprintf(stderr, "%s, line %d: ", ftitle, lineno);
80 #endif
ragge
1.1
81
stefan
1.79
82 static void
83 incerr(void)
84 {
85         if (++nerrors > 30)
86                 cerror("too many errors");
87 }
88
ragge
1.2
89 /*
90  * nonfatal error message
91  * the routine where is different for pass 1 and pass 2;
92  * it tells where the error took place
93  */
94 void
95 uerror(char *s, ...)
96 {
97         va_list ap;
ragge
1.1
98
ragge
1.2
99         va_start(aps);
ragge
1.10
100         WHERE('u');
ragge
1.2
101         vfprintf(stderrsap);
102         fprintf(stderr"\n");
103         va_end(ap);
stefan
1.79
104         incerr();
ragge
1.2
105 }
106
107 /*
108  * compiler error: die
109  */
110 void
111 cerror(char *s, ...)
112 {
113         va_list ap;
ragge
1.1
114
ragge
1.2
115         va_start(aps);
ragge
1.10
116         WHERE('c');
ragge
1.2
117
118         /* give the compiler the benefit of the doubt */
119         if (nerrors && nerrors <= 30) {
120                 fprintf(stderr,
121                     "cannot recover from earlier errors: goodbye!\n");
122         } else {
123                 fprintf(stderr"compiler error: ");
124                 vfprintf(stderrsap);
125                 fprintf(stderr"\n");
126         }
127         va_end(ap);
ragge
1.1
128         EXIT(1);
ragge
1.2
129 }
ragge
1.1
130
ragge
1.2
131 /*
132  * warning
133  */
134 void
135 werror(char *s, ...)
136 {
137         va_list ap;
138
139         va_start(aps);
ragge
1.10
140         WHERE('w');
ragge
1.2
141         fprintf(stderr"warning: ");
142         vfprintf(stderrsap);
143         fprintf(stderr"\n");
ragge
1.70
144         va_end(ap);
stefan
1.79
145         if (warniserr)
146                 incerr();
ragge
1.2
147 }
ragge
1.1
148
ragge
1.37
149 #ifndef MKEXT
ragge
1.22
150 static NODE *freelink;
ragge
1.24
151 static int usednodes;
ragge
1.22
152
ragge
1.77
153 #ifndef LANG_F77
ragge
1.1
154 NODE *
ragge
1.2
155 talloc()
156 {
ragge
1.24
157         register NODE *p;
158
ragge
1.63
159         usednodes++;
ragge
1.1
160
ragge
1.22
161         if (freelink != NULL) {
162                 p = freelink;
163                 freelink = p->next;
164                 if (p->n_op != FREE)
ragge
1.23
165                         cerror("node not FREE: %p"p);
166                 if (nflag)
167                         printf("alloc node %p from freelist\n"p);
ragge
1.22
168                 return p;
169         }
170
ragge
1.24
171         p = permalloc(sizeof(NODE));
172         p->n_op = FREE;
173         if (nflag)
174                 printf("alloc node %p from memory\n"p);
175         return p;
ragge
1.2
176 }
ragge
1.77
177 #endif
ragge
1.47
178
179 /*
180  * make a fresh copy of p
181  */
182 NODE *
183 tcopy(NODE *p)
184 {
185         NODE *q;
186
187         q = talloc();
188         *q = *p;
189
190         switch (optype(q->n_op)) {
191         case BITYPE:
192                 q->n_right = tcopy(p->n_right);
193         case UTYPE:
194                 q->n_left = tcopy(p->n_left);
195         }
196
197         return(q);
198 }
199
ragge
1.77
200 #ifndef LANG_F77
ragge
1.2
201 /*
202  * ensure that all nodes have been freed
203  */
204 void
205 tcheck()
206 {
ragge
1.24
207         extern int inlnodecnt;
ragge
1.1
208
ragge
1.24
209         if (nerrors)
210                 return;
211
212         if ((usednodes - inlnodecnt) != 0)
213                 cerror("usednodes == %d, inlnodecnt %d"usednodesinlnodecnt);
ragge
1.2
214 }
ragge
1.77
215 #endif
ragge
1.1
216
ragge
1.2
217 /*
218  * free the tree p
219  */
220 void
221 tfree(NODE *p)
222 {
ragge
1.12
223         if (p->n_op != FREE)
ragge
1.83
224                 walkf(p, (void (*)(NODE *, void *))nfree0);
ragge
1.2
225 }
ragge
1.1
226
ragge
1.51
227 /*
228  * Free a node, and return its left descendant.
229  * It is up to the caller to know whether the return value is usable.
230  */
231 NODE *
ragge
1.22
232 nfree(NODE *p)
ragge
1.2
233 {
ragge
1.51
234         NODE *l;
ragge
1.38
235 #ifdef PCC_DEBUG_NODES
ragge
1.31
236         NODE *q;
ragge
1.36
237 #endif
ragge
1.22
238
ragge
1.51
239         if (p == NULL)
240                 cerror("freeing blank node!");
241                 
242         l = p->n_left;
243         if (p->n_op == FREE)
244                 cerror("freeing FREE node"p);
ragge
1.38
245 #ifdef PCC_DEBUG_NODES
ragge
1.51
246         q = freelink;
247         while (q != NULL) {
248                 if (q == p)
249                         cerror("freeing free node %p"p);
250                 q = q->next;
251         }
ragge
1.36
252 #endif
ragge
1.22
253
ragge
1.51
254         if (nflag)
255                 printf("freeing node %p\n"p);
256         p->n_op = FREE;
257         p->next = freelink;
258         freelink = p;
259         usednodes--;
260         return l;
ragge
1.2
261 }
ragge
1.37
262 #endif
263
ragge
1.77
264 #ifdef LANG_F77
265 #define OPTYPE(x) optype(x)
266 #else
267 #define OPTYPE(x) coptype(x)
268 #endif
269
ragge
1.37
270 #ifdef MKEXT
271 #define coptype(o)      (dope[o]&TYFLG)
272 #else
ragge
1.34
273 int cdope(int);
ragge
1.37
274 #define coptype(o)      (cdope(o)&TYFLG)
275 #endif
ragge
1.34
276
ragge
1.2
277 void
ragge
1.60
278 fwalk(NODE *tvoid (*f)(NODE *, intint *, int *), int down)
ragge
1.2
279 {
ragge
1.1
280
281         int down1down2;
282
283         more:
284         down1 = down2 = 0;
285
ragge
1.2
286         (*f)(tdown, &down1, &down2);
ragge
1.1
287
ragge
1.77
288         switch (OPTYPEt->n_op )) {
ragge
1.1
289
290         case BITYPE:
ragge
1.12
291                 fwalkt->n_leftfdown1 );
292                 t = t->n_right;
ragge
1.1
293                 down = down2;
294                 goto more;
295
296         case UTYPE:
ragge
1.12
297                 t = t->n_left;
ragge
1.1
298                 down = down1;
299                 goto more;
300
301         }
ragge
1.2
302 }
ragge
1.1
303
ragge
1.2
304 void
ragge
1.83
305 walkf(NODE *tvoid (*f)(NODE *, void *), void *arg)
ragge
1.2
306 {
307         int opty;
ragge
1.1
308
ragge
1.77
309
310         opty = OPTYPE(t->n_op);
ragge
1.1
311
ragge
1.2
312         if (opty != LTYPE)
ragge
1.83
313                 walkft->n_leftfarg );
ragge
1.2
314         if (opty == BITYPE)
ragge
1.83
315                 walkft->n_rightfarg );
316         (*f)(targ);
ragge
1.2
317 }
ragge
1.1
318
ragge
1.11
319 int dope[DSIZE];
ragge
1.1
320 char *opst[DSIZE];
321
ragge
1.2
322 struct dopest {
323         int dopeop;
324         char opst[8];
325         int dopeval;
326 indope[] = {
327         { NAME"NAME"LTYPE, },
328         { REG"REG"LTYPE, },
329         { OREG"OREG"LTYPE, },
ragge
1.52
330         { TEMP"TEMP"LTYPE, },
ragge
1.2
331         { ICON"ICON"LTYPE, },
332         { FCON"FCON"LTYPE, },
333         { CCODES"CCODES"LTYPE, },
ragge
1.41
334         { UMINUS"U-"UTYPE, },
335         { UMUL"U*"UTYPE, },
ragge
1.44
336         { FUNARG"FUNARG"UTYPE, },
ragge
1.42
337         { UCALL"UCALL"UTYPE|CALLFLG, },
338         { UFORTCALL"UFCALL"UTYPE|CALLFLG, },
ragge
1.2
339         { COMPL"~"UTYPE, },
340         { FORCE"FORCE"UTYPE, },
ragge
1.75
341         { XARG"XARG"UTYPE, },
342         { XASM"XASM"BITYPE, },
ragge
1.2
343         { SCONV"SCONV"UTYPE, },
344         { PCONV"PCONV"UTYPE, },
345         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
346         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
347         { MUL"*"BITYPE|FLOFLG|MULFLG, },
348         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
349         { CM","BITYPE, },
350         { ASSIGN"="BITYPE|ASGFLG, },
351         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
352         { MOD"%"BITYPE|DIVFLG, },
353         { LS"<<"BITYPE|SHFFLG, },
354         { RS">>"BITYPE|SHFFLG, },
355         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
356         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
357         { STREF"->"BITYPE, },
358         { CALL"CALL"BITYPE|CALLFLG, },
359         { FORTCALL"FCALL"BITYPE|CALLFLG, },
360         { EQ"=="BITYPE|LOGFLG, },
361         { NE"!="BITYPE|LOGFLG, },
362         { LE"<="BITYPE|LOGFLG, },
363         { LT"<"BITYPE|LOGFLG, },
ragge
1.50
364         { GE">="BITYPE|LOGFLG, },
ragge
1.2
365         { GT">"BITYPE|LOGFLG, },
366         { UGT"UGT"BITYPE|LOGFLG, },
367         { UGE"UGE"BITYPE|LOGFLG, },
368         { ULT"ULT"BITYPE|LOGFLG, },
369         { ULE"ULE"BITYPE|LOGFLG, },
370         { CBRANCH"CBRANCH"BITYPE, },
371         { FLD"FLD"UTYPE, },
372         { PMCONV"PMCONV"BITYPE, },
373         { PVCONV"PVCONV"BITYPE, },
374         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
375         { GOTO"GOTO"UTYPE, },
376         { STASG"STASG"BITYPE|ASGFLG, },
377         { STARG"STARG"UTYPE, },
378         { STCALL"STCALL"BITYPE|CALLFLG, },
ragge
1.42
379         { USTCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.48
380         { ADDROF"U&"UTYPE, },
ragge
1.1
381
ragge
1.2
382         { -1,   "",     0 },
ragge
1.1
383 };
384
ragge
1.2
385 void
386 mkdope()
387 {
388         struct dopest *q;
ragge
1.1
389
390         forq = indopeq->dopeop >= 0; ++q ){
391                 dope[q->dopeop] = q->dopeval;
392                 opst[q->dopeop] = q->opst;
393         }
ragge
1.2
394 }
395
396 /*
397  * output a nice description of the type of t
398  */
399 void
ragge
1.45
400 tprint(FILE *fpTWORD tTWORD q)
ragge
1.2
401 {
ragge
1.1
402         static char * tnames[] = {
403                 "undef",
404                 "farg",
405                 "char",
ragge
1.29
406                 "uchar",
ragge
1.1
407                 "short",
ragge
1.29
408                 "ushort",
ragge
1.1
409                 "int",
ragge
1.29
410                 "unsigned",
ragge
1.1
411                 "long",
ragge
1.29
412                 "ulong",
ragge
1.9
413                 "longlong",
ragge
1.29
414                 "ulonglong",
ragge
1.1
415                 "float",
416                 "double",
ragge
1.29
417                 "ldouble",
ragge
1.1
418                 "strty",
419                 "unionty",
420                 "enumty",
421                 "moety",
ragge
1.29
422                 "void",
ragge
1.66
423                 "signed"/* pass1 */
424                 "bool"/* pass1 */
ragge
1.90
425                 "fimag"/* pass1 */
426                 "dimag"/* pass1 */
427                 "limag"/* pass1 */
ragge
1.80
428                 "fcomplex"/* pass1 */
429                 "dcomplex"/* pass1 */
430                 "lcomplex"/* pass1 */
ragge
1.88
431                 "enumty"/* pass1 */
ragge
1.1
432                 "?""?"
433                 };
434
ragge
1.35
435         for(;; t = DECREF(t), q = DECREF(q)) {
436                 if (ISCON(q))
ragge
1.45
437                         fputc('C'fp);
ragge
1.35
438                 if (ISVOL(q))
ragge
1.45
439                         fputc('V'fp);
ragge
1.1
440
ragge
1.2
441                 if (ISPTR(t))
ragge
1.45
442                         fprintf(fp"PTR ");
ragge
1.2
443                 else if (ISFTN(t))
ragge
1.45
444                         fprintf(fp"FTN ");
ragge
1.2
445                 else if (ISARY(t))
ragge
1.45
446                         fprintf(fp"ARY ");
ragge
1.1
447                 else {
ragge
1.45
448                         fprintf(fp"%s%s%s"ISCON(q << TSHIFT) ? "const " : "",
ragge
1.35
449                             ISVOL(q << TSHIFT) ? "volatile " : ""tnames[t]);
ragge
1.1
450                         return;
451                 }
452         }
ragge
1.2
453 }
ragge
1.13
454
ragge
1.14
455 /*
ragge
1.13
456  * Memory allocation routines.
457  * Memory are allocated from the system in MEMCHUNKSZ blocks.
458  * permalloc() returns a bunch of memory that is never freed.
459  * Memory allocated through tmpalloc() will be released the
460  * next time a function is ended (via tmpfree()).
461  */
462
463 #define MEMCHUNKSZ 8192 /* 8k per allocation */
ragge
1.85
464 struct balloc {
ragge
1.67
465         char a1;
466         union {
467                 long long l;
468                 long double d;
469         } a2;
470 };
471
ragge
1.85
472 #define ALIGNMENT ((long)&((struct balloc *)0)->a2)
ragge
1.72
473 #define ROUNDUP(x) (((x) + ((ALIGNMENT)-1)) & ~((ALIGNMENT)-1))
ragge
1.13
474
475 static char *allocpole;
476 static int allocleft;
ragge
1.18
477 int permallocsizetmpallocsizelostmem;
ragge
1.13
478
479 void *
480 permalloc(int size)
481 {
482         void *rv;
483
ragge
1.85
484         if (size > MEMCHUNKSZ) {
485                 if ((rv = malloc(size)) == NULL)
486                         cerror("permalloc: missing %d bytes"size);
487                 return rv;
488         }
ragge
1.20
489         if (size <= 0)
490                 cerror("permalloc2");
ragge
1.18
491         if (allocleft < size) {
ragge
1.13
492                 /* looses unused bytes */
ragge
1.18
493                 lostmem += allocleft;
ragge
1.13
494                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
495                         cerror("permalloc: out of memory");
496                 allocleft = MEMCHUNKSZ;
497         }
ragge
1.16
498         size = ROUNDUP(size);
ragge
1.13
499         rv = &allocpole[MEMCHUNKSZ-allocleft];
500         allocleft -= size;
ragge
1.17
501         permallocsize += size;
ragge
1.13
502         return rv;
503 }
504
505 void *
pj
1.54
506 tmpcalloc(int size)
507 {
508         void *rv;
509
510         rv = tmpalloc(size);
511         memset(rv0size);
512         return rv;
513 }
514
ragge
1.85
515 /*
516  * Duplicate a string onto the temporary heap.
517  */
518 char *
519 tmpstrdup(char *str)
520 {
521         int len;
522
523         len = strlen(str) + 1;
524         return memcpy(tmpalloc(len), strlen);
525 }
526
527 /*
528  * Allocation routines for temporary memory.
529  */
530 #if 0
531 #define ALLDEBUG(x)     printf x
532 #else
533 #define ALLDEBUG(x)
534 #endif
535
536 #define NELEM   ((MEMCHUNKSZ-ROUNDUP(sizeof(struct xalloc *)))/ALIGNMENT)
537 #define ELEMSZ  (ALIGNMENT)
538 #define MAXSZ   (NELEM*ELEMSZ)
539 struct xalloc {
540         struct xalloc *next;
541         union {
542                 struct balloc b/* for initial alignment */
543                 char elm[MAXSZ];
544         } u;
545 } *tapole, *tmpole;
546 int uselem = NELEM/* next unused element */
547
pj
1.54
548 void *
ragge
1.13
549 tmpalloc(int size)
550 {
ragge
1.85
551         struct xalloc *xp;
ragge
1.17
552         void *rv;
ragge
1.85
553         size_t nelem;
ragge
1.17
554
ragge
1.85
555         nelem = ROUNDUP(size)/ELEMSZ;
556         ALLDEBUG(("tmpalloc(%ld,%ld) %d (%zd) "ELEMSZNELEMsizenelem));
557         if (nelem > NELEM/2) {
558                 xp = malloc(size + ROUNDUP(sizeof(struct xalloc *)));
559                 if (xp == NULL)
560                         cerror("out of memory");
561                 ALLDEBUG(("XMEM! (%ld,%p) ",
562                     size + ROUNDUP(sizeof(struct xalloc *)), xp));
563                 xp->next = tmpole;
564                 tmpole = xp;
565                 ALLDEBUG(("rv %p\n", &xp->u.elm[0]));
566                 return &xp->u.elm[0];
567         }
568         if (nelem + uselem >= NELEM) {
569                 ALLDEBUG(("MOREMEM! "));
570                 /* alloc more */
571                 if ((xp = malloc(sizeof(struct xalloc))) == NULL)
572                         cerror("out of memory");
573                 xp->next = tapole;
574                 tapole = xp;
575                 uselem = 0;
576         } else
577                 xp = tapole;
578         rv = &xp->u.elm[uselem * ELEMSZ];
579         ALLDEBUG(("elemno %d "uselem));
580         uselem += nelem;
581         ALLDEBUG(("new %d rv %p\n"uselemrv));
ragge
1.17
582         return rv;
ragge
1.13
583 }
584
ragge
1.85
585 void
586 tmpfree()
ragge
1.61
587 {
ragge
1.85
588         struct xalloc *x1;
ragge
1.61
589
ragge
1.85
590         while (tmpole) {
591                 x1 = tmpole;
592                 tmpole = tmpole->next;
593                 ALLDEBUG(("XMEM! free %p\n"x1));
594                 free(x1);
595         }
596         while (tapole && tapole->next) {
597                 x1 = tapole;
598                 tapole = tapole->next;
599                 ALLDEBUG(("MOREMEM! free %p\n"x1));
600                 free(x1);
ragge
1.61
601         }
ragge
1.85
602         if (tapole)
603                 uselem = 0;
ragge
1.61
604 }
ragge
1.62
605
606 /*
607  * Print and pack vararg string on heap.
608  */
609 char *tmpvsprintf(char *fmtva_list ap);
610 char *
611 tmpvsprintf(char *fmtva_list ap)
612 {
ragge
1.85
613         int lenasz;
ragge
1.62
614         char *tmp;
615
ragge
1.85
616         if (uselem == NELEM)
ragge
1.62
617                 (void)tmpalloc(1); /* XXX ugly */
ragge
1.85
618         tmp = &tapole->u.elm[uselem * ELEMSZ];
619         asz = (NELEM-uselem) * ELEMSZ;
gmcgarry
1.89
620 #if 0
621         printf("tmpvsprintf: uselem %d asz %d "uselemasz);
622 #endif
ragge
1.85
623         if ((len = vsnprintf(tmpaszfmtap)) >= asz) {
624                 (void)tmpalloc(asz+1); /* ugly */
625                 tmp = &tapole->u.elm[uselem * ELEMSZ];
626                 asz = (NELEM-uselem) * ELEMSZ;
gmcgarry
1.89
627 #if 0
628                 printf("len %d uselem %d \n"lenuselem);
629 #endif
ragge
1.85
630                 if ((len = vsnprintf(tmpaszfmtap)) >= asz)
ragge
1.62
631                         cerror("bad tmpsprintf len");
632         }
gmcgarry
1.89
633 #if 0
634         else printf("\n");
635 #endif
ragge
1.87
636         uselem += (ROUNDUP(len+1)/ELEMSZ);
gmcgarry
1.89
637 #if 0
638         printf("len %d asz %d strlen(tmp) %ld\n"lenaszstrlen(tmp));
639 #endif
ragge
1.62
640         return tmp;
641 }
ragge
1.61
642
ragge
1.81
643 /*
ragge
1.85
644  * Set a mark for later removal from the temp heap.
ragge
1.81
645  */
ragge
1.85
646 void
647 markset(struct mark *m)
ragge
1.81
648 {
ragge
1.85
649         m->tmsav = tmpole;
650         m->tasav = tapole;
651         m->elem = uselem;
ragge
1.81
652 }
653
ragge
1.85
654 /*
655  * Remove everything on tmp heap from a mark.
656  */
ragge
1.13
657 void
ragge
1.85
658 markfree(struct mark *m)
ragge
1.13
659 {
ragge
1.85
660         struct xalloc *x1;
ragge
1.18
661
ragge
1.85
662         while (tmpole != m->tmsav) {
663                 x1 = tmpole;
664                 tmpole = tmpole->next;
665                 free(x1);
666         }
667         while (tapole != m->tasav) {
668                 x1 = tapole;
669                 tapole = tapole->next;
670                 free(x1);
ragge
1.19
671         }
ragge
1.85
672         uselem = m->elem;
ragge
1.16
673 }
674
675 /*
676  * Allocate space on the permanent stack for a string of length len+1
677  * and copy it there.
678  * Return the new address.
679  */
680 char *
681 newstring(char *sint len)
682 {
683         char *u, *c;
684
685         len++;
686         if (allocleft < len) {
687                 u = c = permalloc(len);
688         } else {
689                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
690                 allocleft -= ROUNDUP(len+1);
691         }
692         while (len--)
693                 *c++ = *s++;
694         return u;
ragge
1.13
695 }
ragge
1.80
696
697 /*
698  * Do a preorder walk of the CM list p and apply function f on each element.
699  */
700 void
701 flist(NODE *pvoid (*f)(NODE *, void *), void *arg)
702 {
703         if (p->n_op == CM) {
704                 (*f)(p->n_rightarg);
705                 flist(p->n_leftfarg);
706         } else
707                 (*f)(parg);
708 }
709
710 /*
711  * The same as flist but postorder.
712  */
713 void
714 listf(NODE *pvoid (*f)(NODE *))
715 {
716         if (p->n_op == CM) {
717                 listf(p->n_leftf);
718                 (*f)(p->n_right);
719         } else
720                 (*f)(p);
721 }
722
723 /*
724  * Get list argument number n from list, or NIL if out of list.
725  */
726 NODE *
727 listarg(NODE *pint nint *cnt)
728 {
729         NODE *r;
730
731         if (p->n_op == CM) {
732                 r = listarg(p->n_leftncnt);
733                 if (n == ++(*cnt))
734                         r = p->n_right;
735         } else {
736                 *cnt = 0;
737                 r = n == 0 ? p : NIL;
738         }
739         return r;
740 }
FishEye: Open Source License registered to PCC.
Your maintenance has expired. You can renew your license at http://www.atlassian.com/fisheye/renew
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-09-02 11:21 +0200