Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:plunky:20110820215433

Diff

Diff from 1.98 to:

Annotations

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

Annotated File View

plunky
1.98
1 /*      $Id: common.c,v 1.98 2011/08/20 21:54:33 plunky 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>
plunky
1.98
62 #include <stddef.h>
ragge
1.2
63 #include <stdlib.h>
ragge
1.10
64 #include <stdio.h>
pj
1.54
65 #include <string.h>
ragge
1.2
66
ragge
1.32
67 #include "pass2.h"
ragge
1.1
68
69 # ifndef EXIT
70 # define EXIT exit
71 # endif
72
73 int nerrors = 0;  /* number of errors */
mickey
1.92
74 extern char *ftitle;
ragge
1.37
75 int lineno;
ragge
1.1
76
gmcgarry
1.76
77 int warniserr = 0;
78
ragge
1.10
79 #ifndef WHERE
80 #define WHERE(ch) fprintf(stderr, "%s, line %d: ", ftitle, lineno);
81 #endif
ragge
1.1
82
stefan
1.79
83 static void
84 incerr(void)
85 {
86         if (++nerrors > 30)
87                 cerror("too many errors");
88 }
89
ragge
1.2
90 /*
91  * nonfatal error message
92  * the routine where is different for pass 1 and pass 2;
93  * it tells where the error took place
94  */
95 void
96 uerror(char *s, ...)
97 {
98         va_list ap;
ragge
1.1
99
ragge
1.2
100         va_start(aps);
ragge
1.10
101         WHERE('u');
ragge
1.2
102         vfprintf(stderrsap);
103         fprintf(stderr"\n");
104         va_end(ap);
stefan
1.79
105         incerr();
ragge
1.2
106 }
107
108 /*
109  * compiler error: die
110  */
111 void
112 cerror(char *s, ...)
113 {
114         va_list ap;
ragge
1.1
115
ragge
1.2
116         va_start(aps);
ragge
1.10
117         WHERE('c');
ragge
1.2
118
119         /* give the compiler the benefit of the doubt */
120         if (nerrors && nerrors <= 30) {
121                 fprintf(stderr,
122                     "cannot recover from earlier errors: goodbye!\n");
123         } else {
124                 fprintf(stderr"compiler error: ");
125                 vfprintf(stderrsap);
126                 fprintf(stderr"\n");
127         }
128         va_end(ap);
ragge
1.1
129         EXIT(1);
ragge
1.2
130 }
ragge
1.1
131
ragge
1.2
132 /*
133  * warning
134  */
135 void
136 werror(char *s, ...)
137 {
138         va_list ap;
139
140         va_start(aps);
ragge
1.10
141         WHERE('w');
ragge
1.2
142         fprintf(stderr"warning: ");
143         vfprintf(stderrsap);
144         fprintf(stderr"\n");
ragge
1.70
145         va_end(ap);
stefan
1.79
146         if (warniserr)
147                 incerr();
ragge
1.2
148 }
ragge
1.1
149
ragge
1.37
150 #ifndef MKEXT
ragge
1.93
151
152 bittype warnary[(NUMW/NUMBITS)+1], werrary[(NUMW/NUMBITS)+1];
153
154 static char *warntxt[] = {
plunky
1.97
155         "conversion from '%s' to '%s' may alter its value"/* Wtruncate */
ragge
1.93
156         "function declaration isn't a prototype"/* Wstrict_prototypes */
157         "no previous prototype for `%s'"/* Wmissing_prototypes */
158         "return type defaults to `int'"/* Wimplicit_int */
159                  /* Wimplicit_function_declaration */
160         "implicit declaration of function '%s'",
161         "declaration of '%s' shadows a %s declaration"/* Wshadow */
162         "illegal pointer combination"/* Wpointer_sign */
163         "comparison between signed and unsigned"/* Wsign_compare */
164         "ignoring #pragma %s %s"/* Wunknown_pragmas */
165         "statement not reached"/* Wunreachable_code */
166 };
167
168 char *flagstr[] = {
169         "truncate""strict-prototypes""missing-prototypes"
170         "implicit-int""implicit-function-declaration""shadow"
171         "pointer-sign""sign-compare""unknown-pragmas"
172         "unreachable-code"
173 };
174
175 /*
176  * "emulate" the gcc warning flags.
177  */
178 void
179 Wflags(char *str)
180 {
181         int iflagval;
182
183         if (strncmp("no-"str3) == 0) {
184                 str += 3;
185                 flagval = 0;
186         } else
187                 flagval = 1;
188         if (strcmp(str"error") == 0) {
189                 /* special */
190                 for (i = 0i < NUMWi++)
191                         BITSET(werraryi);
192                 return;
193         }
194         for (i = 0i < NUMWi++) {
195                 if (strcmp(flagstr[i], str) != 0)
196                         continue;
197                 if (flagval)
198                         BITSET(warnaryi);
199                 else
200                         BITCLEAR(warnaryi);
201                 return;
202         }
203         fprintf(stderr"unrecognised warning option '%s'\n"str);
204 }
205
206 /*
207  * Deal with gcc warnings.
208  */
209 void
210 warner(int type, ...)
211 {
212         va_list ap;
213         char *w;
214
215         if (TESTBIT(warnarytype) == 0)
216                 return/* no warning */
217         if (TESTBIT(werrarytype)) {
218                 w = "error";
219                 incerr();
220         } else
221                 w = "warning";
222
223         va_start(aptype);
224         fprintf(stderr"%s:%d: %s: "ftitlelinenow);
225         vfprintf(stderrwarntxt[type], ap);
226         fprintf(stderr"\n");
227         va_end(ap);
228 }
229 #endif /* MKEXT */
230
231 #ifndef MKEXT
ragge
1.22
232 static NODE *freelink;
ragge
1.24
233 static int usednodes;
ragge
1.22
234
ragge
1.77
235 #ifndef LANG_F77
ragge
1.1
236 NODE *
ragge
1.2
237 talloc()
238 {
ragge
1.24
239         register NODE *p;
240
ragge
1.63
241         usednodes++;
ragge
1.1
242
ragge
1.22
243         if (freelink != NULL) {
244                 p = freelink;
245                 freelink = p->next;
246                 if (p->n_op != FREE)
ragge
1.23
247                         cerror("node not FREE: %p"p);
248                 if (nflag)
249                         printf("alloc node %p from freelist\n"p);
ragge
1.22
250                 return p;
251         }
252
ragge
1.24
253         p = permalloc(sizeof(NODE));
254         p->n_op = FREE;
255         if (nflag)
256                 printf("alloc node %p from memory\n"p);
257         return p;
ragge
1.2
258 }
ragge
1.77
259 #endif
ragge
1.47
260
261 /*
262  * make a fresh copy of p
263  */
264 NODE *
265 tcopy(NODE *p)
266 {
267         NODE *q;
268
269         q = talloc();
270         *q = *p;
271
272         switch (optype(q->n_op)) {
273         case BITYPE:
274                 q->n_right = tcopy(p->n_right);
275         case UTYPE:
276                 q->n_left = tcopy(p->n_left);
277         }
278
279         return(q);
280 }
281
ragge
1.77
282 #ifndef LANG_F77
ragge
1.2
283 /*
284  * ensure that all nodes have been freed
285  */
286 void
287 tcheck()
288 {
ragge
1.24
289         extern int inlnodecnt;
ragge
1.1
290
ragge
1.24
291         if (nerrors)
292                 return;
293
294         if ((usednodes - inlnodecnt) != 0)
295                 cerror("usednodes == %d, inlnodecnt %d"usednodesinlnodecnt);
ragge
1.2
296 }
ragge
1.77
297 #endif
ragge
1.1
298
ragge
1.2
299 /*
300  * free the tree p
301  */
302 void
303 tfree(NODE *p)
304 {
ragge
1.12
305         if (p->n_op != FREE)
ragge
1.83
306                 walkf(p, (void (*)(NODE *, void *))nfree0);
ragge
1.2
307 }
ragge
1.1
308
ragge
1.51
309 /*
310  * Free a node, and return its left descendant.
311  * It is up to the caller to know whether the return value is usable.
312  */
313 NODE *
ragge
1.22
314 nfree(NODE *p)
ragge
1.2
315 {
ragge
1.51
316         NODE *l;
ragge
1.38
317 #ifdef PCC_DEBUG_NODES
ragge
1.31
318         NODE *q;
ragge
1.36
319 #endif
ragge
1.22
320
ragge
1.51
321         if (p == NULL)
322                 cerror("freeing blank node!");
323                 
324         l = p->n_left;
325         if (p->n_op == FREE)
326                 cerror("freeing FREE node"p);
ragge
1.38
327 #ifdef PCC_DEBUG_NODES
ragge
1.51
328         q = freelink;
329         while (q != NULL) {
330                 if (q == p)
331                         cerror("freeing free node %p"p);
332                 q = q->next;
333         }
ragge
1.36
334 #endif
ragge
1.22
335
ragge
1.51
336         if (nflag)
337                 printf("freeing node %p\n"p);
338         p->n_op = FREE;
339         p->next = freelink;
340         freelink = p;
341         usednodes--;
342         return l;
ragge
1.2
343 }
ragge
1.37
344 #endif
345
ragge
1.77
346 #ifdef LANG_F77
347 #define OPTYPE(x) optype(x)
348 #else
349 #define OPTYPE(x) coptype(x)
350 #endif
351
ragge
1.37
352 #ifdef MKEXT
353 #define coptype(o)      (dope[o]&TYFLG)
354 #else
ragge
1.34
355 int cdope(int);
ragge
1.37
356 #define coptype(o)      (cdope(o)&TYFLG)
357 #endif
ragge
1.34
358
ragge
1.2
359 void
ragge
1.60
360 fwalk(NODE *tvoid (*f)(NODE *, intint *, int *), int down)
ragge
1.2
361 {
ragge
1.1
362
363         int down1down2;
364
365         more:
366         down1 = down2 = 0;
367
ragge
1.2
368         (*f)(tdown, &down1, &down2);
ragge
1.1
369
ragge
1.77
370         switch (OPTYPEt->n_op )) {
ragge
1.1
371
372         case BITYPE:
ragge
1.12
373                 fwalkt->n_leftfdown1 );
374                 t = t->n_right;
ragge
1.1
375                 down = down2;
376                 goto more;
377
378         case UTYPE:
ragge
1.12
379                 t = t->n_left;
ragge
1.1
380                 down = down1;
381                 goto more;
382
383         }
ragge
1.2
384 }
ragge
1.1
385
ragge
1.2
386 void
ragge
1.83
387 walkf(NODE *tvoid (*f)(NODE *, void *), void *arg)
ragge
1.2
388 {
389         int opty;
ragge
1.1
390
ragge
1.77
391
392         opty = OPTYPE(t->n_op);
ragge
1.1
393
ragge
1.2
394         if (opty != LTYPE)
ragge
1.83
395                 walkft->n_leftfarg );
ragge
1.2
396         if (opty == BITYPE)
ragge
1.83
397                 walkft->n_rightfarg );
398         (*f)(targ);
ragge
1.2
399 }
ragge
1.1
400
ragge
1.11
401 int dope[DSIZE];
ragge
1.1
402 char *opst[DSIZE];
403
ragge
1.2
404 struct dopest {
405         int dopeop;
406         char opst[8];
407         int dopeval;
408 indope[] = {
409         { NAME"NAME"LTYPE, },
410         { REG"REG"LTYPE, },
411         { OREG"OREG"LTYPE, },
ragge
1.52
412         { TEMP"TEMP"LTYPE, },
ragge
1.2
413         { ICON"ICON"LTYPE, },
414         { FCON"FCON"LTYPE, },
415         { CCODES"CCODES"LTYPE, },
ragge
1.41
416         { UMINUS"U-"UTYPE, },
417         { UMUL"U*"UTYPE, },
ragge
1.44
418         { FUNARG"FUNARG"UTYPE, },
ragge
1.42
419         { UCALL"UCALL"UTYPE|CALLFLG, },
420         { UFORTCALL"UFCALL"UTYPE|CALLFLG, },
ragge
1.2
421         { COMPL"~"UTYPE, },
422         { FORCE"FORCE"UTYPE, },
ragge
1.75
423         { XARG"XARG"UTYPE, },
424         { XASM"XASM"BITYPE, },
ragge
1.2
425         { SCONV"SCONV"UTYPE, },
426         { PCONV"PCONV"UTYPE, },
427         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
428         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
429         { MUL"*"BITYPE|FLOFLG|MULFLG, },
430         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
431         { CM","BITYPE, },
432         { ASSIGN"="BITYPE|ASGFLG, },
433         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
434         { MOD"%"BITYPE|DIVFLG, },
435         { LS"<<"BITYPE|SHFFLG, },
436         { RS">>"BITYPE|SHFFLG, },
437         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
438         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
439         { STREF"->"BITYPE, },
440         { CALL"CALL"BITYPE|CALLFLG, },
441         { FORTCALL"FCALL"BITYPE|CALLFLG, },
442         { EQ"=="BITYPE|LOGFLG, },
443         { NE"!="BITYPE|LOGFLG, },
444         { LE"<="BITYPE|LOGFLG, },
445         { LT"<"BITYPE|LOGFLG, },
ragge
1.50
446         { GE">="BITYPE|LOGFLG, },
ragge
1.2
447         { GT">"BITYPE|LOGFLG, },
448         { UGT"UGT"BITYPE|LOGFLG, },
449         { UGE"UGE"BITYPE|LOGFLG, },
450         { ULT"ULT"BITYPE|LOGFLG, },
451         { ULE"ULE"BITYPE|LOGFLG, },
452         { CBRANCH"CBRANCH"BITYPE, },
453         { FLD"FLD"UTYPE, },
454         { PMCONV"PMCONV"BITYPE, },
455         { PVCONV"PVCONV"BITYPE, },
456         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
457         { GOTO"GOTO"UTYPE, },
458         { STASG"STASG"BITYPE|ASGFLG, },
459         { STARG"STARG"UTYPE, },
460         { STCALL"STCALL"BITYPE|CALLFLG, },
ragge
1.42
461         { USTCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.48
462         { ADDROF"U&"UTYPE, },
ragge
1.1
463
ragge
1.2
464         { -1,   "",     0 },
ragge
1.1
465 };
466
ragge
1.2
467 void
468 mkdope()
469 {
470         struct dopest *q;
ragge
1.1
471
472         forq = indopeq->dopeop >= 0; ++q ){
473                 dope[q->dopeop] = q->dopeval;
474                 opst[q->dopeop] = q->opst;
475         }
ragge
1.2
476 }
477
478 /*
479  * output a nice description of the type of t
480  */
481 void
ragge
1.45
482 tprint(FILE *fpTWORD tTWORD q)
ragge
1.2
483 {
ragge
1.1
484         static char * tnames[] = {
485                 "undef",
ragge
1.95
486                 "bool",
ragge
1.1
487                 "char",
ragge
1.29
488                 "uchar",
ragge
1.1
489                 "short",
ragge
1.29
490                 "ushort",
ragge
1.1
491                 "int",
ragge
1.29
492                 "unsigned",
ragge
1.1
493                 "long",
ragge
1.29
494                 "ulong",
ragge
1.9
495                 "longlong",
ragge
1.29
496                 "ulonglong",
ragge
1.1
497                 "float",
498                 "double",
ragge
1.29
499                 "ldouble",
ragge
1.1
500                 "strty",
501                 "unionty",
502                 "enumty",
503                 "moety",
ragge
1.29
504                 "void",
ragge
1.66
505                 "signed"/* pass1 */
ragge
1.95
506                 "farg"/* pass1 */
ragge
1.90
507                 "fimag"/* pass1 */
508                 "dimag"/* pass1 */
509                 "limag"/* pass1 */
ragge
1.80
510                 "fcomplex"/* pass1 */
511                 "dcomplex"/* pass1 */
512                 "lcomplex"/* pass1 */
ragge
1.88
513                 "enumty"/* pass1 */
ragge
1.1
514                 "?""?"
515                 };
516
ragge
1.35
517         for(;; t = DECREF(t), q = DECREF(q)) {
518                 if (ISCON(q))
ragge
1.45
519                         fputc('C'fp);
ragge
1.35
520                 if (ISVOL(q))
ragge
1.45
521                         fputc('V'fp);
ragge
1.1
522
ragge
1.2
523                 if (ISPTR(t))
ragge
1.45
524                         fprintf(fp"PTR ");
ragge
1.2
525                 else if (ISFTN(t))
ragge
1.45
526                         fprintf(fp"FTN ");
ragge
1.2
527                 else if (ISARY(t))
ragge
1.45
528                         fprintf(fp"ARY ");
ragge
1.1
529                 else {
ragge
1.45
530                         fprintf(fp"%s%s%s"ISCON(q << TSHIFT) ? "const " : "",
ragge
1.35
531                             ISVOL(q << TSHIFT) ? "volatile " : ""tnames[t]);
ragge
1.1
532                         return;
533                 }
534         }
ragge
1.2
535 }
ragge
1.13
536
ragge
1.14
537 /*
ragge
1.13
538  * Memory allocation routines.
539  * Memory are allocated from the system in MEMCHUNKSZ blocks.
540  * permalloc() returns a bunch of memory that is never freed.
541  * Memory allocated through tmpalloc() will be released the
542  * next time a function is ended (via tmpfree()).
543  */
544
545 #define MEMCHUNKSZ 8192 /* 8k per allocation */
ragge
1.85
546 struct balloc {
ragge
1.67
547         char a1;
548         union {
549                 long long l;
550                 long double d;
551         } a2;
552 };
553
plunky
1.98
554 #define ALIGNMENT offsetof(struct balloc, a2)
ragge
1.72
555 #define ROUNDUP(x) (((x) + ((ALIGNMENT)-1)) & ~((ALIGNMENT)-1))
ragge
1.13
556
557 static char *allocpole;
558 static int allocleft;
ragge
1.18
559 int permallocsizetmpallocsizelostmem;
ragge
1.13
560
561 void *
562 permalloc(int size)
563 {
564         void *rv;
565
ragge
1.85
566         if (size > MEMCHUNKSZ) {
567                 if ((rv = malloc(size)) == NULL)
568                         cerror("permalloc: missing %d bytes"size);
569                 return rv;
570         }
ragge
1.20
571         if (size <= 0)
572                 cerror("permalloc2");
ragge
1.18
573         if (allocleft < size) {
plunky
1.94
574                 /* loses unused bytes */
ragge
1.18
575                 lostmem += allocleft;
ragge
1.13
576                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
577                         cerror("permalloc: out of memory");
578                 allocleft = MEMCHUNKSZ;
579         }
ragge
1.16
580         size = ROUNDUP(size);
ragge
1.13
581         rv = &allocpole[MEMCHUNKSZ-allocleft];
582         allocleft -= size;
ragge
1.17
583         permallocsize += size;
ragge
1.13
584         return rv;
585 }
586
587 void *
pj
1.54
588 tmpcalloc(int size)
589 {
590         void *rv;
591
592         rv = tmpalloc(size);
593         memset(rv0size);
594         return rv;
595 }
596
ragge
1.85
597 /*
598  * Duplicate a string onto the temporary heap.
599  */
600 char *
601 tmpstrdup(char *str)
602 {
603         int len;
604
605         len = strlen(str) + 1;
606         return memcpy(tmpalloc(len), strlen);
607 }
608
609 /*
610  * Allocation routines for temporary memory.
611  */
612 #if 0
613 #define ALLDEBUG(x)     printf x
614 #else
615 #define ALLDEBUG(x)
616 #endif
617
618 #define NELEM   ((MEMCHUNKSZ-ROUNDUP(sizeof(struct xalloc *)))/ALIGNMENT)
619 #define ELEMSZ  (ALIGNMENT)
620 #define MAXSZ   (NELEM*ELEMSZ)
621 struct xalloc {
622         struct xalloc *next;
623         union {
624                 struct balloc b/* for initial alignment */
625                 char elm[MAXSZ];
626         } u;
627 } *tapole, *tmpole;
628 int uselem = NELEM/* next unused element */
629
pj
1.54
630 void *
ragge
1.13
631 tmpalloc(int size)
632 {
ragge
1.85
633         struct xalloc *xp;
ragge
1.17
634         void *rv;
ragge
1.85
635         size_t nelem;
ragge
1.17
636
ragge
1.85
637         nelem = ROUNDUP(size)/ELEMSZ;
638         ALLDEBUG(("tmpalloc(%ld,%ld) %d (%zd) "ELEMSZNELEMsizenelem));
639         if (nelem > NELEM/2) {
640                 xp = malloc(size + ROUNDUP(sizeof(struct xalloc *)));
641                 if (xp == NULL)
642                         cerror("out of memory");
643                 ALLDEBUG(("XMEM! (%ld,%p) ",
644                     size + ROUNDUP(sizeof(struct xalloc *)), xp));
645                 xp->next = tmpole;
646                 tmpole = xp;
647                 ALLDEBUG(("rv %p\n", &xp->u.elm[0]));
648                 return &xp->u.elm[0];
649         }
650         if (nelem + uselem >= NELEM) {
651                 ALLDEBUG(("MOREMEM! "));
652                 /* alloc more */
653                 if ((xp = malloc(sizeof(struct xalloc))) == NULL)
654                         cerror("out of memory");
655                 xp->next = tapole;
656                 tapole = xp;
657                 uselem = 0;
658         } else
659                 xp = tapole;
660         rv = &xp->u.elm[uselem * ELEMSZ];
661         ALLDEBUG(("elemno %d "uselem));
662         uselem += nelem;
663         ALLDEBUG(("new %d rv %p\n"uselemrv));
ragge
1.17
664         return rv;
ragge
1.13
665 }
666
ragge
1.85
667 void
668 tmpfree()
ragge
1.61
669 {
ragge
1.85
670         struct xalloc *x1;
ragge
1.61
671
ragge
1.85
672         while (tmpole) {
673                 x1 = tmpole;
674                 tmpole = tmpole->next;
675                 ALLDEBUG(("XMEM! free %p\n"x1));
676                 free(x1);
677         }
678         while (tapole && tapole->next) {
679                 x1 = tapole;
680                 tapole = tapole->next;
681                 ALLDEBUG(("MOREMEM! free %p\n"x1));
682                 free(x1);
ragge
1.61
683         }
ragge
1.85
684         if (tapole)
685                 uselem = 0;
ragge
1.61
686 }
ragge
1.62
687
688 /*
ragge
1.85
689  * Set a mark for later removal from the temp heap.
ragge
1.81
690  */
ragge
1.85
691 void
692 markset(struct mark *m)
ragge
1.81
693 {
ragge
1.85
694         m->tmsav = tmpole;
695         m->tasav = tapole;
696         m->elem = uselem;
ragge
1.81
697 }
698
ragge
1.85
699 /*
700  * Remove everything on tmp heap from a mark.
701  */
ragge
1.13
702 void
ragge
1.85
703 markfree(struct mark *m)
ragge
1.13
704 {
ragge
1.85
705         struct xalloc *x1;
ragge
1.18
706
ragge
1.85
707         while (tmpole != m->tmsav) {
708                 x1 = tmpole;
709                 tmpole = tmpole->next;
710                 free(x1);
711         }
712         while (tapole != m->tasav) {
713                 x1 = tapole;
714                 tapole = tapole->next;
715                 free(x1);
ragge
1.19
716         }
ragge
1.85
717         uselem = m->elem;
ragge
1.16
718 }
719
720 /*
721  * Allocate space on the permanent stack for a string of length len+1
722  * and copy it there.
723  * Return the new address.
724  */
725 char *
726 newstring(char *sint len)
727 {
728         char *u, *c;
729
730         len++;
731         if (allocleft < len) {
732                 u = c = permalloc(len);
733         } else {
734                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
735                 allocleft -= ROUNDUP(len+1);
736         }
737         while (len--)
738                 *c++ = *s++;
739         return u;
ragge
1.13
740 }
ragge
1.80
741
742 /*
743  * Do a preorder walk of the CM list p and apply function f on each element.
744  */
745 void
746 flist(NODE *pvoid (*f)(NODE *, void *), void *arg)
747 {
748         if (p->n_op == CM) {
749                 (*f)(p->n_rightarg);
750                 flist(p->n_leftfarg);
751         } else
752                 (*f)(parg);
753 }
754
755 /*
756  * The same as flist but postorder.
757  */
758 void
759 listf(NODE *pvoid (*f)(NODE *))
760 {
761         if (p->n_op == CM) {
762                 listf(p->n_leftf);
763                 (*f)(p->n_right);
764         } else
765                 (*f)(p);
766 }
767
768 /*
769  * Get list argument number n from list, or NIL if out of list.
770  */
771 NODE *
772 listarg(NODE *pint nint *cnt)
773 {
774         NODE *r;
775
776         if (p->n_op == CM) {
777                 r = listarg(p->n_leftncnt);
778                 if (n == ++(*cnt))
779                         r = p->n_right;
780         } else {
781                 *cnt = 0;
782                 r = n == 0 ? p : NIL;
783         }
784         return r;
785 }
ragge
1.95
786
787 /*
788  * Make a type unsigned, if possible.
789  */
790 TWORD
791 enunsign(TWORD t)
792 {
793         if (BTYPE(t) >= CHAR && BTYPE(t) <= ULONGLONG)
794                 t |= 1;
795         return t;
796 }
797
798 /*
799  * Make a type signed, if possible.
800  */
801 TWORD
802 deunsign(TWORD t)
803 {
804         if (BTYPE(t) >= CHAR && BTYPE(t) <= ULONGLONG)
805                 t &= ~1;
806         return t;
807 }
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-16 15:29 +0200