Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:gmcgarry:20080220011138

Diff

Diff from 1.76 to:

Annotations

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

Annotated File View

gmcgarry
1.76
1 /*      $Id: common.c,v 1.76 2008/02/20 01:11:38 gmcgarry 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.1
150 NODE *
ragge
1.2
151 talloc()
152 {
ragge
1.24
153         extern int inlnodecntrecovernodes;
154         register NODE *p;
155
ragge
1.63
156         usednodes++;
ragge
1.1
157
ragge
1.24
158         if (recovernodes)
159                 inlnodecnt++;
ragge
1.22
160         if (freelink != NULL) {
161                 p = freelink;
162                 freelink = p->next;
163                 if (p->n_op != FREE)
ragge
1.23
164                         cerror("node not FREE: %p"p);
165                 if (nflag)
166                         printf("alloc node %p from freelist\n"p);
ragge
1.22
167                 return p;
168         }
169
ragge
1.24
170         p = permalloc(sizeof(NODE));
171         p->n_op = FREE;
172         if (nflag)
173                 printf("alloc node %p from memory\n"p);
174         return p;
ragge
1.2
175 }
ragge
1.47
176
177 /*
178  * make a fresh copy of p
179  */
180 NODE *
181 tcopy(NODE *p)
182 {
183         NODE *q;
184
185         q = talloc();
186         *q = *p;
187
188         switch (optype(q->n_op)) {
189         case BITYPE:
190                 q->n_right = tcopy(p->n_right);
191         case UTYPE:
192                 q->n_left = tcopy(p->n_left);
193         }
194
195         return(q);
196 }
197
ragge
1.1
198
ragge
1.2
199 /*
200  * ensure that all nodes have been freed
201  */
202 void
203 tcheck()
204 {
ragge
1.24
205         extern int inlnodecnt;
ragge
1.1
206
ragge
1.24
207         if (nerrors)
208                 return;
209
210         if ((usednodes - inlnodecnt) != 0)
211                 cerror("usednodes == %d, inlnodecnt %d"usednodesinlnodecnt);
ragge
1.2
212 }
ragge
1.1
213
ragge
1.2
214 /*
215  * free the tree p
216  */
217 void
218 tfree(NODE *p)
219 {
ragge
1.12
220         if (p->n_op != FREE)
ragge
1.51
221                 walkf(p, (void (*)(NODE *))nfree);
ragge
1.2
222 }
ragge
1.1
223
ragge
1.51
224 /*
225  * Free a node, and return its left descendant.
226  * It is up to the caller to know whether the return value is usable.
227  */
228 NODE *
ragge
1.22
229 nfree(NODE *p)
ragge
1.2
230 {
ragge
1.24
231         extern int inlnodecntrecovernodes;
ragge
1.51
232         NODE *l;
ragge
1.38
233 #ifdef PCC_DEBUG_NODES
ragge
1.31
234         NODE *q;
ragge
1.36
235 #endif
ragge
1.22
236
ragge
1.51
237         if (p == NULL)
238                 cerror("freeing blank node!");
239                 
240         l = p->n_left;
241         if (p->n_op == FREE)
242                 cerror("freeing FREE node"p);
ragge
1.38
243 #ifdef PCC_DEBUG_NODES
ragge
1.51
244         q = freelink;
245         while (q != NULL) {
246                 if (q == p)
247                         cerror("freeing free node %p"p);
248                 q = q->next;
249         }
ragge
1.36
250 #endif
ragge
1.22
251
ragge
1.51
252         if (nflag)
253                 printf("freeing node %p\n"p);
254         p->n_op = FREE;
255         p->next = freelink;
256         freelink = p;
257         usednodes--;
258         if (recovernodes)
259                 inlnodecnt--;
260         return l;
ragge
1.2
261 }
ragge
1.37
262 #endif
263
264 #ifdef MKEXT
265 #define coptype(o)      (dope[o]&TYFLG)
266 #else
ragge
1.34
267 int cdope(int);
ragge
1.37
268 #define coptype(o)      (cdope(o)&TYFLG)
269 #endif
ragge
1.34
270
ragge
1.2
271 void
ragge
1.60
272 fwalk(NODE *tvoid (*f)(NODE *, intint *, int *), int down)
ragge
1.2
273 {
ragge
1.1
274
275         int down1down2;
276
277         more:
278         down1 = down2 = 0;
279
ragge
1.2
280         (*f)(tdown, &down1, &down2);
ragge
1.1
281
ragge
1.34
282         switch (coptypet->n_op )) {
ragge
1.1
283
284         case BITYPE:
ragge
1.12
285                 fwalkt->n_leftfdown1 );
286                 t = t->n_right;
ragge
1.1
287                 down = down2;
288                 goto more;
289
290         case UTYPE:
ragge
1.12
291                 t = t->n_left;
ragge
1.1
292                 down = down1;
293                 goto more;
294
295         }
ragge
1.2
296 }
ragge
1.1
297
ragge
1.2
298 void
299 walkf(NODE *tvoid (*f)(NODE *))
300 {
301         int opty;
ragge
1.1
302
ragge
1.34
303         opty = coptype(t->n_op);
ragge
1.1
304
ragge
1.2
305         if (opty != LTYPE)
ragge
1.12
306                 walkft->n_leftf );
ragge
1.2
307         if (opty == BITYPE)
ragge
1.12
308                 walkft->n_rightf );
ragge
1.2
309         (*f)(t);
310 }
ragge
1.1
311
ragge
1.11
312 int dope[DSIZE];
ragge
1.1
313 char *opst[DSIZE];
314
ragge
1.2
315 struct dopest {
316         int dopeop;
317         char opst[8];
318         int dopeval;
319 indope[] = {
320         { NAME"NAME"LTYPE, },
321         { REG"REG"LTYPE, },
322         { OREG"OREG"LTYPE, },
ragge
1.52
323         { TEMP"TEMP"LTYPE, },
ragge
1.2
324         { ICON"ICON"LTYPE, },
325         { FCON"FCON"LTYPE, },
326         { CCODES"CCODES"LTYPE, },
ragge
1.41
327         { UMINUS"U-"UTYPE, },
328         { UMUL"U*"UTYPE, },
ragge
1.44
329         { FUNARG"FUNARG"UTYPE, },
ragge
1.42
330         { UCALL"UCALL"UTYPE|CALLFLG, },
331         { UFORTCALL"UFCALL"UTYPE|CALLFLG, },
ragge
1.2
332         { COMPL"~"UTYPE, },
333         { FORCE"FORCE"UTYPE, },
ragge
1.75
334         { XARG"XARG"UTYPE, },
335         { XASM"XASM"BITYPE, },
ragge
1.2
336         { SCONV"SCONV"UTYPE, },
337         { PCONV"PCONV"UTYPE, },
338         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
339         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
340         { MUL"*"BITYPE|FLOFLG|MULFLG, },
341         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
342         { CM","BITYPE, },
343         { ASSIGN"="BITYPE|ASGFLG, },
344         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
345         { MOD"%"BITYPE|DIVFLG, },
346         { LS"<<"BITYPE|SHFFLG, },
347         { RS">>"BITYPE|SHFFLG, },
348         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
349         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
350         { STREF"->"BITYPE, },
351         { CALL"CALL"BITYPE|CALLFLG, },
352         { FORTCALL"FCALL"BITYPE|CALLFLG, },
353         { EQ"=="BITYPE|LOGFLG, },
354         { NE"!="BITYPE|LOGFLG, },
355         { LE"<="BITYPE|LOGFLG, },
356         { LT"<"BITYPE|LOGFLG, },
ragge
1.50
357         { GE">="BITYPE|LOGFLG, },
ragge
1.2
358         { GT">"BITYPE|LOGFLG, },
359         { UGT"UGT"BITYPE|LOGFLG, },
360         { UGE"UGE"BITYPE|LOGFLG, },
361         { ULT"ULT"BITYPE|LOGFLG, },
362         { ULE"ULE"BITYPE|LOGFLG, },
363         { CBRANCH"CBRANCH"BITYPE, },
364         { FLD"FLD"UTYPE, },
365         { PMCONV"PMCONV"BITYPE, },
366         { PVCONV"PVCONV"BITYPE, },
367         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
368         { GOTO"GOTO"UTYPE, },
369         { STASG"STASG"BITYPE|ASGFLG, },
370         { STARG"STARG"UTYPE, },
371         { STCALL"STCALL"BITYPE|CALLFLG, },
ragge
1.42
372         { USTCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.48
373         { ADDROF"U&"UTYPE, },
ragge
1.1
374
ragge
1.2
375         { -1,   "",     0 },
ragge
1.1
376 };
377
ragge
1.2
378 void
379 mkdope()
380 {
381         struct dopest *q;
ragge
1.1
382
383         forq = indopeq->dopeop >= 0; ++q ){
384                 dope[q->dopeop] = q->dopeval;
385                 opst[q->dopeop] = q->opst;
386         }
ragge
1.2
387 }
388
389 /*
390  * output a nice description of the type of t
391  */
392 void
ragge
1.45
393 tprint(FILE *fpTWORD tTWORD q)
ragge
1.2
394 {
ragge
1.1
395         static char * tnames[] = {
396                 "undef",
397                 "farg",
398                 "char",
ragge
1.29
399                 "uchar",
ragge
1.1
400                 "short",
ragge
1.29
401                 "ushort",
ragge
1.1
402                 "int",
ragge
1.29
403                 "unsigned",
ragge
1.1
404                 "long",
ragge
1.29
405                 "ulong",
ragge
1.9
406                 "longlong",
ragge
1.29
407                 "ulonglong",
ragge
1.1
408                 "float",
409                 "double",
ragge
1.29
410                 "ldouble",
ragge
1.1
411                 "strty",
412                 "unionty",
413                 "enumty",
414                 "moety",
ragge
1.29
415                 "void",
ragge
1.66
416                 "signed"/* pass1 */
417                 "bool"/* pass1 */
ragge
1.1
418                 "?""?"
419                 };
420
ragge
1.35
421         for(;; t = DECREF(t), q = DECREF(q)) {
422                 if (ISCON(q))
ragge
1.45
423                         fputc('C'fp);
ragge
1.35
424                 if (ISVOL(q))
ragge
1.45
425                         fputc('V'fp);
ragge
1.1
426
ragge
1.2
427                 if (ISPTR(t))
ragge
1.45
428                         fprintf(fp"PTR ");
ragge
1.2
429                 else if (ISFTN(t))
ragge
1.45
430                         fprintf(fp"FTN ");
ragge
1.2
431                 else if (ISARY(t))
ragge
1.45
432                         fprintf(fp"ARY ");
ragge
1.1
433                 else {
ragge
1.45
434                         fprintf(fp"%s%s%s"ISCON(q << TSHIFT) ? "const " : "",
ragge
1.35
435                             ISVOL(q << TSHIFT) ? "volatile " : ""tnames[t]);
ragge
1.1
436                         return;
437                 }
438         }
ragge
1.2
439 }
ragge
1.13
440
ragge
1.57
441 int crslab = 10;
ragge
1.13
442 /*
ragge
1.14
443  * Return a number for internal labels.
444  */
445 int 
446 getlab()
447 {
448         return crslab++;
449 }
450
451 /*
ragge
1.13
452  * Memory allocation routines.
453  * Memory are allocated from the system in MEMCHUNKSZ blocks.
454  * permalloc() returns a bunch of memory that is never freed.
455  * Memory allocated through tmpalloc() will be released the
456  * next time a function is ended (via tmpfree()).
457  */
458
459 #define MEMCHUNKSZ 8192 /* 8k per allocation */
ragge
1.67
460 struct b {
461         char a1;
462         union {
463                 long long l;
464                 long double d;
465         } a2;
466 };
467
ragge
1.73
468 #define ALIGNMENT ((long)&((struct b *)0)->a2)
ragge
1.72
469 #define ROUNDUP(x) (((x) + ((ALIGNMENT)-1)) & ~((ALIGNMENT)-1))
ragge
1.13
470
471 static char *allocpole;
472 static int allocleft;
ragge
1.17
473 static char *tmppole;
474 static int tmpleft;
ragge
1.18
475 int permallocsizetmpallocsizelostmem;
ragge
1.13
476
477 void *
478 permalloc(int size)
479 {
480         void *rv;
481
mickey
1.74
482 //fprintf(stderr, "permalloc: allocpole %p allocleft %d size %d ", allocpole, allocleft, size);
ragge
1.13
483         if (size > MEMCHUNKSZ)
484                 cerror("permalloc");
ragge
1.20
485         if (size <= 0)
486                 cerror("permalloc2");
ragge
1.18
487         if (allocleft < size) {
ragge
1.13
488                 /* looses unused bytes */
ragge
1.18
489                 lostmem += allocleft;
ragge
1.17
490 //fprintf(stderr, "allocating perm\n");
ragge
1.13
491                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
492                         cerror("permalloc: out of memory");
493                 allocleft = MEMCHUNKSZ;
494         }
ragge
1.16
495         size = ROUNDUP(size);
ragge
1.13
496         rv = &allocpole[MEMCHUNKSZ-allocleft];
mickey
1.74
497 //fprintf(stderr, "rv %p\n", rv);
ragge
1.13
498         allocleft -= size;
ragge
1.17
499         permallocsize += size;
ragge
1.13
500         return rv;
501 }
502
ragge
1.17
503 static char *tmplink;
504
ragge
1.13
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.61
515 #define TMPOLE  &tmppole[MEMCHUNKSZ-tmpleft]
pj
1.54
516 void *
ragge
1.13
517 tmpalloc(int size)
518 {
ragge
1.17
519         void *rv;
520
ragge
1.72
521         if (size > MEMCHUNKSZ/2) {
ragge
1.71
522                 size += ROUNDUP(sizeof(char *));
ragge
1.69
523                 if ((rv = malloc(size)) == NULL)
524                         cerror("tmpalloc: out of memory");
ragge
1.72
525                 /* link in before current chunk XXX */
526                 *(char **)rv = *(char **)tmppole;
527                 *(char **)tmppole = rv;
ragge
1.71
528                 tmpallocsize += size;
ragge
1.72
529                 return (char *)rv + ROUNDUP(sizeof(char *));
ragge
1.59
530         }
ragge
1.20
531         if (size <= 0)
532                 cerror("tmpalloc2");
mickey
1.74
533 //fprintf(stderr, "tmpalloc: tmppole %p tmpleft %d size %d ", tmppole, tmpleft, size);
ragge
1.61
534         size = ROUNDUP(size);
ragge
1.17
535         if (tmpleft < size) {
536                 if ((tmppole = malloc(MEMCHUNKSZ)) == NULL)
537                         cerror("tmpalloc: out of memory");
538 //fprintf(stderr, "allocating tmp\n");
ragge
1.72
539                 tmpleft = MEMCHUNKSZ - ROUNDUP(sizeof(char *));
ragge
1.17
540                 *(char **)tmppole = tmplink;
541                 tmplink = tmppole;
542         }
ragge
1.61
543         rv = TMPOLE;
mickey
1.74
544 //fprintf(stderr,"rv %p\n", rv);
ragge
1.17
545         tmpleft -= size;
546         tmpallocsize += size;
547         return rv;
ragge
1.13
548 }
549
ragge
1.62
550 #if 0
ragge
1.61
551 /*
552  * Print and pack strings on heap.
553  */
554 char *tmpsprintf(char *fmt, ...);
555 char *
556 tmpsprintf(char *fmt, ...)
557 {
558         va_list ap;
559         int len;
560         char *tmp;
561
562         tmp = TMPOLE;
563         va_start(apfmt);
564         if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft) {
565                 (void)tmpalloc(tmpleft); /* ugly */
566                 tmp = TMPOLE;
567                 if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft)
568                         cerror("bad tmpsprintf len");
569         }
570         va_end(ap);
571         tmpleft += len;
572         return tmp;
573 }
ragge
1.62
574 #endif
575
576 /*
577  * Print and pack vararg string on heap.
578  */
579 char *tmpvsprintf(char *fmtva_list ap);
580 char *
581 tmpvsprintf(char *fmtva_list ap)
582 {
583         int len;
584         char *tmp;
585
586         if (tmpleft == 0)
587                 (void)tmpalloc(1); /* XXX ugly */
588         tmp = TMPOLE;
589         if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft) {
590                 (void)tmpalloc(tmpleft+1); /* ugly */
591                 tmp = TMPOLE;
592                 if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft)
593                         cerror("bad tmpsprintf len");
594         }
595         tmpleft -= len+1;
596         return tmp;
597 }
ragge
1.61
598
ragge
1.13
599 void
600 tmpfree()
601 {
ragge
1.18
602         char *f, *of;
603
604         f = tmplink;
ragge
1.19
605         if (f == NULL)
606                 return;
607         if (*(char **)f == NULL) {
ragge
1.72
608                 tmpleft = MEMCHUNKSZ - ROUNDUP(sizeof(char *));
ragge
1.19
609                 return;
610         }
ragge
1.18
611         while (f != NULL) {
612                 of = f;
613                 f = *(char **)f;
614                 free(of);
615         }
616         tmplink = tmppole = NULL;
617         tmpleft = 0;
ragge
1.17
618 //fprintf(stderr, "freeing tmp\n");
ragge
1.13
619         /* XXX - nothing right now */
ragge
1.16
620 }
621
622 /*
623  * Allocate space on the permanent stack for a string of length len+1
624  * and copy it there.
625  * Return the new address.
626  */
627 char *
628 newstring(char *sint len)
629 {
630         char *u, *c;
631
632         len++;
633         if (allocleft < len) {
634                 u = c = permalloc(len);
635         } else {
636                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
637                 allocleft -= ROUNDUP(len+1);
638         }
639         while (len--)
640                 *c++ = *s++;
641         return u;
ragge
1.13
642 }
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-30 13:54 +0200