Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20080305185601

Diff

Diff from 1.77 to:

Annotations

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

Annotated File View

ragge
1.77
1 /*      $Id: common.c,v 1.77 2008/03/05 18:56:01 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  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 /*
30  * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
31  *
32  * Redistribution and use in source and binary forms, with or without
33  * modification, are permitted provided that the following conditions
34  * are met:
35  *
36  * Redistributions of source code and documentation must retain the above
37  * copyright notice, this list of conditions and the following disclaimer.
38  * Redistributions in binary form must reproduce the above copyright
39  * notice, this list of conditionsand the following disclaimer in the
40  * documentation and/or other materials provided with the distribution.
41  * All advertising materials mentioning features or use of this software
42  * must display the following acknowledgement:
43  *      This product includes software developed or owned by Caldera
44  *      International, Inc.
45  * Neither the name of Caldera International, Inc. nor the names of other
46  * contributors may be used to endorse or promote products derived from
47  * this software without specific prior written permission.
48  *
49  * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
50  * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
51  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
52  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
53  * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
54  * FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57  * HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
58  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
59  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
60  * POSSIBILITY OF SUCH DAMAGE.
61  */
ragge
1.1
62
ragge
1.2
63 #include <stdarg.h>
64 #include <stdlib.h>
ragge
1.10
65 #include <stdio.h>
pj
1.54
66 #include <string.h>
ragge
1.2
67
ragge
1.32
68 #include "pass2.h"
ragge
1.1
69
70 # ifndef EXIT
71 # define EXIT exit
72 # endif
73
74 int nerrors = 0;  /* number of errors */
ragge
1.37
75 char *ftitle;
76 int lineno;
ragge
1.1
77
gmcgarry
1.76
78 int warniserr = 0;
79
ragge
1.10
80 #ifndef WHERE
81 #define WHERE(ch) fprintf(stderr, "%s, line %d: ", ftitle, lineno);
82 #endif
ragge
1.1
83
ragge
1.2
84 /*
85  * nonfatal error message
86  * the routine where is different for pass 1 and pass 2;
87  * it tells where the error took place
88  */
89 void
90 uerror(char *s, ...)
91 {
92         va_list ap;
ragge
1.1
93
ragge
1.2
94         va_start(aps);
ragge
1.1
95         ++nerrors;
ragge
1.10
96         WHERE('u');
ragge
1.2
97         vfprintf(stderrsap);
98         fprintf(stderr"\n");
99         if (nerrors > 30)
100                 cerror("too many errors");
101         va_end(ap);
102 }
103
104 /*
105  * compiler error: die
106  */
107 void
108 cerror(char *s, ...)
109 {
110         va_list ap;
ragge
1.1
111
ragge
1.2
112         va_start(aps);
ragge
1.10
113         WHERE('c');
ragge
1.2
114
115         /* give the compiler the benefit of the doubt */
116         if (nerrors && nerrors <= 30) {
117                 fprintf(stderr,
118                     "cannot recover from earlier errors: goodbye!\n");
119         } else {
120                 fprintf(stderr"compiler error: ");
121                 vfprintf(stderrsap);
122                 fprintf(stderr"\n");
123         }
124         va_end(ap);
ragge
1.1
125         EXIT(1);
ragge
1.2
126 }
ragge
1.1
127
ragge
1.2
128 /*
129  * warning
130  */
131 void
132 werror(char *s, ...)
133 {
134         va_list ap;
135
136         va_start(aps);
gmcgarry
1.76
137         if (warniserr)
138                 uerror(sap);
ragge
1.10
139         WHERE('w');
ragge
1.2
140         fprintf(stderr"warning: ");
141         vfprintf(stderrsap);
142         fprintf(stderr"\n");
ragge
1.70
143         va_end(ap);
ragge
1.2
144 }
ragge
1.1
145
ragge
1.37
146 #ifndef MKEXT
ragge
1.22
147 static NODE *freelink;
ragge
1.24
148 static int usednodes;
ragge
1.22
149
ragge
1.77
150 #ifndef LANG_F77
ragge
1.1
151 NODE *
ragge
1.2
152 talloc()
153 {
ragge
1.24
154         extern int inlnodecntrecovernodes;
155         register NODE *p;
156
ragge
1.63
157         usednodes++;
ragge
1.1
158
ragge
1.24
159         if (recovernodes)
160                 inlnodecnt++;
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.51
224                 walkf(p, (void (*)(NODE *))nfree);
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.77
234 #ifndef LANG_F77
ragge
1.24
235         extern int inlnodecntrecovernodes;
ragge
1.77
236 #endif
ragge
1.51
237         NODE *l;
ragge
1.38
238 #ifdef PCC_DEBUG_NODES
ragge
1.31
239         NODE *q;
ragge
1.36
240 #endif
ragge
1.22
241
ragge
1.51
242         if (p == NULL)
243                 cerror("freeing blank node!");
244                 
245         l = p->n_left;
246         if (p->n_op == FREE)
247                 cerror("freeing FREE node"p);
ragge
1.38
248 #ifdef PCC_DEBUG_NODES
ragge
1.51
249         q = freelink;
250         while (q != NULL) {
251                 if (q == p)
252                         cerror("freeing free node %p"p);
253                 q = q->next;
254         }
ragge
1.36
255 #endif
ragge
1.22
256
ragge
1.51
257         if (nflag)
258                 printf("freeing node %p\n"p);
259         p->n_op = FREE;
260         p->next = freelink;
261         freelink = p;
262         usednodes--;
ragge
1.77
263 #ifndef LANG_F77
ragge
1.51
264         if (recovernodes)
265                 inlnodecnt--;
ragge
1.77
266 #endif
ragge
1.51
267         return l;
ragge
1.2
268 }
ragge
1.37
269 #endif
270
ragge
1.77
271 #ifdef LANG_F77
272 #define OPTYPE(x) optype(x)
273 #else
274 #define OPTYPE(x) coptype(x)
275 #endif
276
ragge
1.37
277 #ifdef MKEXT
278 #define coptype(o)      (dope[o]&TYFLG)
279 #else
ragge
1.34
280 int cdope(int);
ragge
1.37
281 #define coptype(o)      (cdope(o)&TYFLG)
282 #endif
ragge
1.34
283
ragge
1.2
284 void
ragge
1.60
285 fwalk(NODE *tvoid (*f)(NODE *, intint *, int *), int down)
ragge
1.2
286 {
ragge
1.1
287
288         int down1down2;
289
290         more:
291         down1 = down2 = 0;
292
ragge
1.2
293         (*f)(tdown, &down1, &down2);
ragge
1.1
294
ragge
1.77
295         switch (OPTYPEt->n_op )) {
ragge
1.1
296
297         case BITYPE:
ragge
1.12
298                 fwalkt->n_leftfdown1 );
299                 t = t->n_right;
ragge
1.1
300                 down = down2;
301                 goto more;
302
303         case UTYPE:
ragge
1.12
304                 t = t->n_left;
ragge
1.1
305                 down = down1;
306                 goto more;
307
308         }
ragge
1.2
309 }
ragge
1.1
310
ragge
1.2
311 void
312 walkf(NODE *tvoid (*f)(NODE *))
313 {
314         int opty;
ragge
1.1
315
ragge
1.77
316
317         opty = OPTYPE(t->n_op);
ragge
1.1
318
ragge
1.2
319         if (opty != LTYPE)
ragge
1.12
320                 walkft->n_leftf );
ragge
1.2
321         if (opty == BITYPE)
ragge
1.12
322                 walkft->n_rightf );
ragge
1.2
323         (*f)(t);
324 }
ragge
1.1
325
ragge
1.11
326 int dope[DSIZE];
ragge
1.1
327 char *opst[DSIZE];
328
ragge
1.2
329 struct dopest {
330         int dopeop;
331         char opst[8];
332         int dopeval;
333 indope[] = {
334         { NAME"NAME"LTYPE, },
335         { REG"REG"LTYPE, },
336         { OREG"OREG"LTYPE, },
ragge
1.52
337         { TEMP"TEMP"LTYPE, },
ragge
1.2
338         { ICON"ICON"LTYPE, },
339         { FCON"FCON"LTYPE, },
340         { CCODES"CCODES"LTYPE, },
ragge
1.41
341         { UMINUS"U-"UTYPE, },
342         { UMUL"U*"UTYPE, },
ragge
1.44
343         { FUNARG"FUNARG"UTYPE, },
ragge
1.42
344         { UCALL"UCALL"UTYPE|CALLFLG, },
345         { UFORTCALL"UFCALL"UTYPE|CALLFLG, },
ragge
1.2
346         { COMPL"~"UTYPE, },
347         { FORCE"FORCE"UTYPE, },
ragge
1.75
348         { XARG"XARG"UTYPE, },
349         { XASM"XASM"BITYPE, },
ragge
1.2
350         { SCONV"SCONV"UTYPE, },
351         { PCONV"PCONV"UTYPE, },
352         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
353         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
354         { MUL"*"BITYPE|FLOFLG|MULFLG, },
355         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
356         { CM","BITYPE, },
357         { ASSIGN"="BITYPE|ASGFLG, },
358         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
359         { MOD"%"BITYPE|DIVFLG, },
360         { LS"<<"BITYPE|SHFFLG, },
361         { RS">>"BITYPE|SHFFLG, },
362         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
363         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
364         { STREF"->"BITYPE, },
365         { CALL"CALL"BITYPE|CALLFLG, },
366         { FORTCALL"FCALL"BITYPE|CALLFLG, },
367         { EQ"=="BITYPE|LOGFLG, },
368         { NE"!="BITYPE|LOGFLG, },
369         { LE"<="BITYPE|LOGFLG, },
370         { LT"<"BITYPE|LOGFLG, },
ragge
1.50
371         { GE">="BITYPE|LOGFLG, },
ragge
1.2
372         { GT">"BITYPE|LOGFLG, },
373         { UGT"UGT"BITYPE|LOGFLG, },
374         { UGE"UGE"BITYPE|LOGFLG, },
375         { ULT"ULT"BITYPE|LOGFLG, },
376         { ULE"ULE"BITYPE|LOGFLG, },
377         { CBRANCH"CBRANCH"BITYPE, },
378         { FLD"FLD"UTYPE, },
379         { PMCONV"PMCONV"BITYPE, },
380         { PVCONV"PVCONV"BITYPE, },
381         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
382         { GOTO"GOTO"UTYPE, },
383         { STASG"STASG"BITYPE|ASGFLG, },
384         { STARG"STARG"UTYPE, },
385         { STCALL"STCALL"BITYPE|CALLFLG, },
ragge
1.42
386         { USTCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.48
387         { ADDROF"U&"UTYPE, },
ragge
1.1
388
ragge
1.2
389         { -1,   "",     0 },
ragge
1.1
390 };
391
ragge
1.2
392 void
393 mkdope()
394 {
395         struct dopest *q;
ragge
1.1
396
397         forq = indopeq->dopeop >= 0; ++q ){
398                 dope[q->dopeop] = q->dopeval;
399                 opst[q->dopeop] = q->opst;
400         }
ragge
1.2
401 }
402
403 /*
404  * output a nice description of the type of t
405  */
406 void
ragge
1.45
407 tprint(FILE *fpTWORD tTWORD q)
ragge
1.2
408 {
ragge
1.1
409         static char * tnames[] = {
410                 "undef",
411                 "farg",
412                 "char",
ragge
1.29
413                 "uchar",
ragge
1.1
414                 "short",
ragge
1.29
415                 "ushort",
ragge
1.1
416                 "int",
ragge
1.29
417                 "unsigned",
ragge
1.1
418                 "long",
ragge
1.29
419                 "ulong",
ragge
1.9
420                 "longlong",
ragge
1.29
421                 "ulonglong",
ragge
1.1
422                 "float",
423                 "double",
ragge
1.29
424                 "ldouble",
ragge
1.1
425                 "strty",
426                 "unionty",
427                 "enumty",
428                 "moety",
ragge
1.29
429                 "void",
ragge
1.66
430                 "signed"/* pass1 */
431                 "bool"/* 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.57
455 int crslab = 10;
ragge
1.13
456 /*
ragge
1.14
457  * Return a number for internal labels.
458  */
459 int 
460 getlab()
461 {
462         return crslab++;
463 }
464
465 /*
ragge
1.13
466  * Memory allocation routines.
467  * Memory are allocated from the system in MEMCHUNKSZ blocks.
468  * permalloc() returns a bunch of memory that is never freed.
469  * Memory allocated through tmpalloc() will be released the
470  * next time a function is ended (via tmpfree()).
471  */
472
473 #define MEMCHUNKSZ 8192 /* 8k per allocation */
ragge
1.67
474 struct b {
475         char a1;
476         union {
477                 long long l;
478                 long double d;
479         } a2;
480 };
481
ragge
1.73
482 #define ALIGNMENT ((long)&((struct b *)0)->a2)
ragge
1.72
483 #define ROUNDUP(x) (((x) + ((ALIGNMENT)-1)) & ~((ALIGNMENT)-1))
ragge
1.13
484
485 static char *allocpole;
486 static int allocleft;
ragge
1.17
487 static char *tmppole;
488 static int tmpleft;
ragge
1.18
489 int permallocsizetmpallocsizelostmem;
ragge
1.13
490
491 void *
492 permalloc(int size)
493 {
494         void *rv;
495
mickey
1.74
496 //fprintf(stderr, "permalloc: allocpole %p allocleft %d size %d ", allocpole, allocleft, size);
ragge
1.13
497         if (size > MEMCHUNKSZ)
498                 cerror("permalloc");
ragge
1.20
499         if (size <= 0)
500                 cerror("permalloc2");
ragge
1.18
501         if (allocleft < size) {
ragge
1.13
502                 /* looses unused bytes */
ragge
1.18
503                 lostmem += allocleft;
ragge
1.17
504 //fprintf(stderr, "allocating perm\n");
ragge
1.13
505                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
506                         cerror("permalloc: out of memory");
507                 allocleft = MEMCHUNKSZ;
508         }
ragge
1.16
509         size = ROUNDUP(size);
ragge
1.13
510         rv = &allocpole[MEMCHUNKSZ-allocleft];
mickey
1.74
511 //fprintf(stderr, "rv %p\n", rv);
ragge
1.13
512         allocleft -= size;
ragge
1.17
513         permallocsize += size;
ragge
1.13
514         return rv;
515 }
516
ragge
1.17
517 static char *tmplink;
518
ragge
1.13
519 void *
pj
1.54
520 tmpcalloc(int size)
521 {
522         void *rv;
523
524         rv = tmpalloc(size);
525         memset(rv0size);
526         return rv;
527 }
528
ragge
1.61
529 #define TMPOLE  &tmppole[MEMCHUNKSZ-tmpleft]
pj
1.54
530 void *
ragge
1.13
531 tmpalloc(int size)
532 {
ragge
1.17
533         void *rv;
534
ragge
1.72
535         if (size > MEMCHUNKSZ/2) {
ragge
1.71
536                 size += ROUNDUP(sizeof(char *));
ragge
1.69
537                 if ((rv = malloc(size)) == NULL)
538                         cerror("tmpalloc: out of memory");
ragge
1.72
539                 /* link in before current chunk XXX */
540                 *(char **)rv = *(char **)tmppole;
541                 *(char **)tmppole = rv;
ragge
1.71
542                 tmpallocsize += size;
ragge
1.72
543                 return (char *)rv + ROUNDUP(sizeof(char *));
ragge
1.59
544         }
ragge
1.20
545         if (size <= 0)
546                 cerror("tmpalloc2");
mickey
1.74
547 //fprintf(stderr, "tmpalloc: tmppole %p tmpleft %d size %d ", tmppole, tmpleft, size);
ragge
1.61
548         size = ROUNDUP(size);
ragge
1.17
549         if (tmpleft < size) {
550                 if ((tmppole = malloc(MEMCHUNKSZ)) == NULL)
551                         cerror("tmpalloc: out of memory");
552 //fprintf(stderr, "allocating tmp\n");
ragge
1.72
553                 tmpleft = MEMCHUNKSZ - ROUNDUP(sizeof(char *));
ragge
1.17
554                 *(char **)tmppole = tmplink;
555                 tmplink = tmppole;
556         }
ragge
1.61
557         rv = TMPOLE;
mickey
1.74
558 //fprintf(stderr,"rv %p\n", rv);
ragge
1.17
559         tmpleft -= size;
560         tmpallocsize += size;
561         return rv;
ragge
1.13
562 }
563
ragge
1.62
564 #if 0
ragge
1.61
565 /*
566  * Print and pack strings on heap.
567  */
568 char *tmpsprintf(char *fmt, ...);
569 char *
570 tmpsprintf(char *fmt, ...)
571 {
572         va_list ap;
573         int len;
574         char *tmp;
575
576         tmp = TMPOLE;
577         va_start(apfmt);
578         if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft) {
579                 (void)tmpalloc(tmpleft); /* ugly */
580                 tmp = TMPOLE;
581                 if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft)
582                         cerror("bad tmpsprintf len");
583         }
584         va_end(ap);
585         tmpleft += len;
586         return tmp;
587 }
ragge
1.62
588 #endif
589
590 /*
591  * Print and pack vararg string on heap.
592  */
593 char *tmpvsprintf(char *fmtva_list ap);
594 char *
595 tmpvsprintf(char *fmtva_list ap)
596 {
597         int len;
598         char *tmp;
599
600         if (tmpleft == 0)
601                 (void)tmpalloc(1); /* XXX ugly */
602         tmp = TMPOLE;
603         if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft) {
604                 (void)tmpalloc(tmpleft+1); /* ugly */
605                 tmp = TMPOLE;
606                 if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft)
607                         cerror("bad tmpsprintf len");
608         }
609         tmpleft -= len+1;
610         return tmp;
611 }
ragge
1.61
612
ragge
1.13
613 void
614 tmpfree()
615 {
ragge
1.18
616         char *f, *of;
617
618         f = tmplink;
ragge
1.19
619         if (f == NULL)
620                 return;
621         if (*(char **)f == NULL) {
ragge
1.72
622                 tmpleft = MEMCHUNKSZ - ROUNDUP(sizeof(char *));
ragge
1.19
623                 return;
624         }
ragge
1.18
625         while (f != NULL) {
626                 of = f;
627                 f = *(char **)f;
628                 free(of);
629         }
630         tmplink = tmppole = NULL;
631         tmpleft = 0;
ragge
1.17
632 //fprintf(stderr, "freeing tmp\n");
ragge
1.13
633         /* XXX - nothing right now */
ragge
1.16
634 }
635
636 /*
637  * Allocate space on the permanent stack for a string of length len+1
638  * and copy it there.
639  * Return the new address.
640  */
641 char *
642 newstring(char *sint len)
643 {
644         char *u, *c;
645
646         len++;
647         if (allocleft < len) {
648                 u = c = permalloc(len);
649         } else {
650                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
651                 allocleft -= ROUNDUP(len+1);
652         }
653         while (len--)
654                 *c++ = *s++;
655         return u;
ragge
1.13
656 }
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-08-29 01:17 +0200