Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20070811090505

Diff

Diff from 1.66 to:

Annotations

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

Annotated File View

ragge
1.66
1 /*      $Id: common.c,v 1.66 2007/08/11 09:05:05 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.56
455 #define ROUNDUP(x) ((x) + (sizeof(ALIGNMENT)-1)) & ~(sizeof(ALIGNMENT)-1)
ragge
1.13
456
457 static char *allocpole;
458 static int allocleft;
ragge
1.17
459 static char *tmppole;
460 static int tmpleft;
ragge
1.18
461 int permallocsizetmpallocsizelostmem;
ragge
1.13
462
463 void *
464 permalloc(int size)
465 {
466         void *rv;
467
468 //printf("permalloc: allocpole %p allocleft %d size %d ", allocpole, allocleft, size);
469         if (size > MEMCHUNKSZ)
470                 cerror("permalloc");
ragge
1.20
471         if (size <= 0)
472                 cerror("permalloc2");
ragge
1.18
473         if (allocleft < size) {
ragge
1.13
474                 /* looses unused bytes */
ragge
1.18
475                 lostmem += allocleft;
ragge
1.17
476 //fprintf(stderr, "allocating perm\n");
ragge
1.13
477                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
478                         cerror("permalloc: out of memory");
479                 allocleft = MEMCHUNKSZ;
480         }
ragge
1.16
481         size = ROUNDUP(size);
ragge
1.13
482         rv = &allocpole[MEMCHUNKSZ-allocleft];
483 //printf("rv %p\n", rv);
484         allocleft -= size;
ragge
1.17
485         permallocsize += size;
ragge
1.13
486         return rv;
487 }
488
ragge
1.17
489 static char *tmplink;
490
ragge
1.13
491 void *
pj
1.54
492 tmpcalloc(int size)
493 {
494         void *rv;
495
496         rv = tmpalloc(size);
497         memset(rv0size);
498         return rv;
499 }
500
ragge
1.61
501 #define TMPOLE  &tmppole[MEMCHUNKSZ-tmpleft]
pj
1.54
502 void *
ragge
1.13
503 tmpalloc(int size)
504 {
ragge
1.17
505         void *rv;
506
ragge
1.59
507         if (size > MEMCHUNKSZ) {
508                 return malloc(size);
509         //      cerror("tmpalloc %d", size);
510         }
ragge
1.20
511         if (size <= 0)
512                 cerror("tmpalloc2");
ragge
1.17
513 //printf("tmpalloc: tmppole %p tmpleft %d size %d ", tmppole, tmpleft, size);
ragge
1.61
514         size = ROUNDUP(size);
ragge
1.17
515         if (tmpleft < size) {
516                 if ((tmppole = malloc(MEMCHUNKSZ)) == NULL)
517                         cerror("tmpalloc: out of memory");
518 //fprintf(stderr, "allocating tmp\n");
ragge
1.53
519                 tmpleft = MEMCHUNKSZ - (ROUNDUP(sizeof(char *)));
ragge
1.17
520                 *(char **)tmppole = tmplink;
521                 tmplink = tmppole;
522         }
ragge
1.61
523         rv = TMPOLE;
ragge
1.17
524 //printf("rv %p\n", rv);
525         tmpleft -= size;
526         tmpallocsize += size;
527         return rv;
ragge
1.13
528 }
529
ragge
1.62
530 #if 0
ragge
1.61
531 /*
532  * Print and pack strings on heap.
533  */
534 char *tmpsprintf(char *fmt, ...);
535 char *
536 tmpsprintf(char *fmt, ...)
537 {
538         va_list ap;
539         int len;
540         char *tmp;
541
542         tmp = TMPOLE;
543         va_start(apfmt);
544         if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft) {
545                 (void)tmpalloc(tmpleft); /* ugly */
546                 tmp = TMPOLE;
547                 if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft)
548                         cerror("bad tmpsprintf len");
549         }
550         va_end(ap);
551         tmpleft += len;
552         return tmp;
553 }
ragge
1.62
554 #endif
555
556 /*
557  * Print and pack vararg string on heap.
558  */
559 char *tmpvsprintf(char *fmtva_list ap);
560 char *
561 tmpvsprintf(char *fmtva_list ap)
562 {
563         int len;
564         char *tmp;
565
566         if (tmpleft == 0)
567                 (void)tmpalloc(1); /* XXX ugly */
568         tmp = TMPOLE;
569         if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft) {
570                 (void)tmpalloc(tmpleft+1); /* ugly */
571                 tmp = TMPOLE;
572                 if ((len = vsnprintf(tmptmpleftfmtap)) >= tmpleft)
573                         cerror("bad tmpsprintf len");
574         }
575         tmpleft -= len+1;
576         return tmp;
577 }
ragge
1.61
578
ragge
1.13
579 void
580 tmpfree()
581 {
ragge
1.18
582         char *f, *of;
583
584         f = tmplink;
ragge
1.19
585         if (f == NULL)
586                 return;
587         if (*(char **)f == NULL) {
ragge
1.55
588                 tmpleft = MEMCHUNKSZ - (ROUNDUP(sizeof(char *)));
ragge
1.19
589                 return;
590         }
ragge
1.18
591         while (f != NULL) {
592                 of = f;
593                 f = *(char **)f;
594                 free(of);
595         }
596         tmplink = tmppole = NULL;
597         tmpleft = 0;
ragge
1.17
598 //fprintf(stderr, "freeing tmp\n");
ragge
1.13
599         /* XXX - nothing right now */
ragge
1.16
600 }
601
602 /*
603  * Allocate space on the permanent stack for a string of length len+1
604  * and copy it there.
605  * Return the new address.
606  */
607 char *
608 newstring(char *sint len)
609 {
610         char *u, *c;
611
612         len++;
613         if (allocleft < len) {
614                 u = c = permalloc(len);
615         } else {
616                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
617                 allocleft -= ROUNDUP(len+1);
618         }
619         while (len--)
620                 *c++ = *s++;
621         return u;
ragge
1.13
622 }
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-21 10:10 +0200