Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20080210192221

Diff

Diff from 1.75 to:

Annotations

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

Annotated File View

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