Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20070909174233

Diff

Diff from 1.67 to:

Annotations

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

Annotated File View

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