Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030713123729

Diff

Diff from 1.31 to:

Annotations

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

Annotated File View

ragge
1.31
1 /*      $Id: common.c,v 1.31 2003/07/13 12:37:29 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>
ragge
1.2
66
ragge
1.1
67 #include "pass1.h"
68
69 # ifndef EXIT
70 # define EXIT exit
71 # endif
72
73 int nerrors = 0;  /* number of errors */
74
ragge
1.10
75 #ifndef WHERE
76 #define WHERE(ch) fprintf(stderr, "%s, line %d: ", ftitle, lineno);
77 #endif
ragge
1.1
78
ragge
1.2
79 /*
80  * nonfatal error message
81  * the routine where is different for pass 1 and pass 2;
82  * it tells where the error took place
83  */
84 void
85 uerror(char *s, ...)
86 {
87         va_list ap;
ragge
1.1
88
ragge
1.2
89         va_start(aps);
ragge
1.1
90         ++nerrors;
ragge
1.10
91         WHERE('u');
ragge
1.2
92         vfprintf(stderrsap);
93         fprintf(stderr"\n");
94         if (nerrors > 30)
95                 cerror("too many errors");
96         va_end(ap);
97 }
98
99 /*
100  * compiler error: die
101  */
102 void
103 cerror(char *s, ...)
104 {
105         va_list ap;
ragge
1.1
106
ragge
1.2
107         va_start(aps);
ragge
1.10
108         WHERE('c');
ragge
1.2
109
110         /* give the compiler the benefit of the doubt */
111         if (nerrors && nerrors <= 30) {
112                 fprintf(stderr,
113                     "cannot recover from earlier errors: goodbye!\n");
114         } else {
115                 fprintf(stderr"compiler error: ");
116                 vfprintf(stderrsap);
117                 fprintf(stderr"\n");
118         }
119         va_end(ap);
ragge
1.1
120         EXIT(1);
ragge
1.2
121 }
ragge
1.1
122
ragge
1.2
123 /*
124  * warning
125  */
126 void
127 werror(char *s, ...)
128 {
129         va_list ap;
130
131         va_start(aps);
ragge
1.10
132         WHERE('w');
ragge
1.2
133         fprintf(stderr"warning: ");
134         vfprintf(stderrsap);
135         fprintf(stderr"\n");
136 }
ragge
1.1
137
ragge
1.22
138 static NODE *freelink;
ragge
1.24
139 static int usednodes;
ragge
1.22
140
ragge
1.1
141 NODE *
ragge
1.2
142 talloc()
143 {
ragge
1.24
144         extern int inlnodecntrecovernodes;
145         register NODE *p;
146
147         if ((usednodes++ - inlnodecnt) > TREESZ)
ragge
1.25
148                 cerror("out of tree space; usednodes %d inlnodecnt %d",
149                     usednodesinlnodecnt);
ragge
1.1
150
ragge
1.24
151         if (recovernodes)
152                 inlnodecnt++;
ragge
1.22
153         if (freelink != NULL) {
154                 p = freelink;
155                 freelink = p->next;
156                 if (p->n_op != FREE)
ragge
1.23
157                         cerror("node not FREE: %p"p);
158                 if (nflag)
159                         printf("alloc node %p from freelist\n"p);
ragge
1.22
160                 return p;
161         }
162
ragge
1.24
163         p = permalloc(sizeof(NODE));
164         p->n_op = FREE;
165         if (nflag)
166                 printf("alloc node %p from memory\n"p);
167         return p;
ragge
1.2
168 }
ragge
1.1
169
ragge
1.2
170 /*
171  * ensure that all nodes have been freed
172  */
173 void
174 tcheck()
175 {
ragge
1.24
176         extern int inlnodecnt;
ragge
1.1
177
ragge
1.24
178         if (nerrors)
179                 return;
180
181         if ((usednodes - inlnodecnt) != 0)
182                 cerror("usednodes == %d, inlnodecnt %d"usednodesinlnodecnt);
ragge
1.2
183 }
ragge
1.1
184
ragge
1.2
185 /*
186  * free the tree p
187  */
188 void
189 tfree(NODE *p)
190 {
ragge
1.12
191         if (p->n_op != FREE)
ragge
1.22
192                 walkf(pnfree);
ragge
1.2
193 }
ragge
1.1
194
ragge
1.2
195 void
ragge
1.22
196 nfree(NODE *p)
ragge
1.2
197 {
ragge
1.24
198         extern int inlnodecntrecovernodes;
ragge
1.31
199         NODE *q;
ragge
1.22
200
201         if (p != NULL) {
202                 if (p->n_op == FREE)
203                         cerror("freeing FREE node"p);
204                 q = freelink;
205                 while (q != NULL) {
206                         if (q == p)
207                                 cerror("freeing free node %p"p);
208                         q = q->next;
209                 }
210
ragge
1.23
211                 if (nflag)
212                         printf("freeing node %p\n"p);
ragge
1.12
213                 p->n_op = FREE;
ragge
1.24
214                 p->next = freelink;
215                 freelink = p;
216                 usednodes--;
217                 if (recovernodes)
218                         inlnodecnt--;
ragge
1.22
219         } else
220                 cerror("freeing blank node!");
ragge
1.2
221 }
ragge
1.1
222
ragge
1.2
223 void
224 fwalk(NODE *tint (*f)(NODE *, intint *, int *), int down)
225 {
ragge
1.1
226
227         int down1down2;
228
229         more:
230         down1 = down2 = 0;
231
ragge
1.2
232         (*f)(tdown, &down1, &down2);
ragge
1.1
233
ragge
1.12
234         switch (optypet->n_op )) {
ragge
1.1
235
236         case BITYPE:
ragge
1.12
237                 fwalkt->n_leftfdown1 );
238                 t = t->n_right;
ragge
1.1
239                 down = down2;
240                 goto more;
241
242         case UTYPE:
ragge
1.12
243                 t = t->n_left;
ragge
1.1
244                 down = down1;
245                 goto more;
246
247         }
ragge
1.2
248 }
ragge
1.1
249
ragge
1.2
250 void
251 walkf(NODE *tvoid (*f)(NODE *))
252 {
253         int opty;
ragge
1.1
254
ragge
1.12
255         opty = optype(t->n_op);
ragge
1.1
256
ragge
1.2
257         if (opty != LTYPE)
ragge
1.12
258                 walkft->n_leftf );
ragge
1.2
259         if (opty == BITYPE)
ragge
1.12
260                 walkft->n_rightf );
ragge
1.2
261         (*f)(t);
262 }
ragge
1.1
263
ragge
1.11
264 int dope[DSIZE];
ragge
1.1
265 char *opst[DSIZE];
266
ragge
1.2
267 struct dopest {
268         int dopeop;
269         char opst[8];
270         int dopeval;
271 indope[] = {
272         { NAME"NAME"LTYPE, },
273         { STRING"STRING"LTYPE, },
274         { REG"REG"LTYPE, },
275         { OREG"OREG"LTYPE, },
ragge
1.31
276         { TEMP"TEMP"LTYPE, },
ragge
1.2
277         { ICON"ICON"LTYPE, },
278         { FCON"FCON"LTYPE, },
279         { CCODES"CCODES"LTYPE, },
280         { UNARY MINUS"U-"UTYPE, },
281         { UNARY MUL"U*"UTYPE, },
282         { UNARY AND"U&"UTYPE, },
283         { UNARY CALL"UCALL"UTYPE|CALLFLG, },
284         { UNARY FORTCALL"UFCALL"UTYPE|CALLFLG, },
285         { NOT"!"UTYPE|LOGFLG, },
286         { COMPL"~"UTYPE, },
287         { FORCE"FORCE"UTYPE, },
288         { INIT"INIT"UTYPE, },
289         { SCONV"SCONV"UTYPE, },
290         { PCONV"PCONV"UTYPE, },
291         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
292         { ASG PLUS"+="BITYPE|ASGFLG|ASGOPFLG|FLOFLG|SIMPFLG|COMMFLG, },
293         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
294         { ASG MINUS"-="BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
295         { MUL"*"BITYPE|FLOFLG|MULFLG, },
296         { ASG MUL"*="BITYPE|FLOFLG|MULFLG|ASGFLG|ASGOPFLG, },
297         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
298         { ASG AND"&="BITYPE|SIMPFLG|COMMFLG|ASGFLG|ASGOPFLG, },
299         { QUEST"?"BITYPE, },
300         { COLON":"BITYPE, },
301         { ANDAND"&&"BITYPE|LOGFLG, },
302         { OROR"||"BITYPE|LOGFLG, },
303         { CM","BITYPE, },
304         { COMOP",OP"BITYPE, },
305         { ASSIGN"="BITYPE|ASGFLG, },
306         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
307         { ASG DIV"/="BITYPE|FLOFLG|MULFLG|DIVFLG|ASGFLG|ASGOPFLG, },
308         { MOD"%"BITYPE|DIVFLG, },
309         { ASG MOD"%="BITYPE|DIVFLG|ASGFLG|ASGOPFLG, },
310         { LS"<<"BITYPE|SHFFLG, },
311         { ASG LS"<<="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
312         { RS">>"BITYPE|SHFFLG, },
313         { ASG RS">>="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
314         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
315         { ASG OR"|="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
316         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
317         { ASG ER"^="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
318         { INCR"++"BITYPE|ASGFLG, },
319         { DECR"--"BITYPE|ASGFLG, },
320         { STREF"->"BITYPE, },
321         { CALL"CALL"BITYPE|CALLFLG, },
322         { FORTCALL"FCALL"BITYPE|CALLFLG, },
323         { EQ"=="BITYPE|LOGFLG, },
324         { NE"!="BITYPE|LOGFLG, },
325         { LE"<="BITYPE|LOGFLG, },
326         { LT"<"BITYPE|LOGFLG, },
327         { GE">"BITYPE|LOGFLG, },
328         { GT">"BITYPE|LOGFLG, },
329         { UGT"UGT"BITYPE|LOGFLG, },
330         { UGE"UGE"BITYPE|LOGFLG, },
331         { ULT"ULT"BITYPE|LOGFLG, },
332         { ULE"ULE"BITYPE|LOGFLG, },
ragge
1.22
333         { TYPE"TYPE"LTYPE, },
ragge
1.2
334         { LB"["BITYPE, },
335         { CBRANCH"CBRANCH"BITYPE, },
336         { FLD"FLD"UTYPE, },
337         { PMCONV"PMCONV"BITYPE, },
338         { PVCONV"PVCONV"BITYPE, },
339         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
340         { CAST"CAST"BITYPE|ASGFLG|ASGOPFLG, },
341         { GOTO"GOTO"UTYPE, },
342         { STASG"STASG"BITYPE|ASGFLG, },
343         { STARG"STARG"UTYPE, },
344         { STCALL"STCALL"BITYPE|CALLFLG, },
345         { UNARY STCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.1
346
ragge
1.2
347         { -1,   "",     0 },
ragge
1.1
348 };
349
ragge
1.2
350 void
351 mkdope()
352 {
353         struct dopest *q;
ragge
1.1
354
355         forq = indopeq->dopeop >= 0; ++q ){
356                 dope[q->dopeop] = q->dopeval;
357                 opst[q->dopeop] = q->opst;
358         }
ragge
1.2
359 }
360
361 /*
362  * output a nice description of the type of t
363  */
364 void
365 tprint(TWORD t)
366 {
ragge
1.1
367         static char * tnames[] = {
368                 "undef",
369                 "farg",
370                 "char",
ragge
1.29
371                 "uchar",
ragge
1.1
372                 "short",
ragge
1.29
373                 "ushort",
ragge
1.1
374                 "int",
ragge
1.29
375                 "unsigned",
ragge
1.1
376                 "long",
ragge
1.29
377                 "ulong",
ragge
1.9
378                 "longlong",
ragge
1.29
379                 "ulonglong",
ragge
1.1
380                 "float",
381                 "double",
ragge
1.29
382                 "ldouble",
ragge
1.1
383                 "strty",
384                 "unionty",
385                 "enumty",
386                 "moety",
ragge
1.29
387                 "void",
ragge
1.1
388                 "?""?"
389                 };
390
391         for(;; t = DECREF(t) ){
392
ragge
1.2
393                 if (ISPTR(t))
394                         printf("PTR ");
395                 else if (ISFTN(t))
396                         printf("FTN ");
397                 else if (ISARY(t))
398                         printf("ARY ");
ragge
1.1
399                 else {
ragge
1.2
400                         printf("%s"tnames[t]);
ragge
1.1
401                         return;
402                 }
403         }
ragge
1.2
404 }
ragge
1.13
405
406 /*
ragge
1.14
407  * Return a number for internal labels.
408  */
409 int 
410 getlab()
411 {
412         static int crslab = 10;
413         return crslab++;
414 }
415
416 /*
ragge
1.13
417  * Memory allocation routines.
418  * Memory are allocated from the system in MEMCHUNKSZ blocks.
419  * permalloc() returns a bunch of memory that is never freed.
420  * Memory allocated through tmpalloc() will be released the
421  * next time a function is ended (via tmpfree()).
422  */
423
424 #define MEMCHUNKSZ 8192 /* 8k per allocation */
ragge
1.16
425 #define ROUNDUP(x) ((x) + (sizeof(int)-1)) & ~(sizeof(int)-1)
ragge
1.13
426
427 static char *allocpole;
428 static int allocleft;
ragge
1.17
429 static char *tmppole;
430 static int tmpleft;
ragge
1.18
431 int permallocsizetmpallocsizelostmem;
ragge
1.13
432
433 void *
434 permalloc(int size)
435 {
436         void *rv;
437
438 //printf("permalloc: allocpole %p allocleft %d size %d ", allocpole, allocleft, size);
439         if (size > MEMCHUNKSZ)
440                 cerror("permalloc");
ragge
1.20
441         if (size <= 0)
442                 cerror("permalloc2");
ragge
1.18
443         if (allocleft < size) {
ragge
1.13
444                 /* looses unused bytes */
ragge
1.18
445                 lostmem += allocleft;
ragge
1.17
446 //fprintf(stderr, "allocating perm\n");
ragge
1.13
447                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
448                         cerror("permalloc: out of memory");
449                 allocleft = MEMCHUNKSZ;
450         }
ragge
1.16
451         size = ROUNDUP(size);
ragge
1.13
452         rv = &allocpole[MEMCHUNKSZ-allocleft];
453 //printf("rv %p\n", rv);
454         allocleft -= size;
ragge
1.17
455         permallocsize += size;
ragge
1.13
456         return rv;
457 }
458
ragge
1.17
459 static char *tmplink;
460
ragge
1.13
461 void *
462 tmpalloc(int size)
463 {
ragge
1.17
464         void *rv;
465
466         if (size > MEMCHUNKSZ)
467                 cerror("tmpalloc");
ragge
1.20
468         if (size <= 0)
469                 cerror("tmpalloc2");
ragge
1.17
470 //printf("tmpalloc: tmppole %p tmpleft %d size %d ", tmppole, tmpleft, size);
471         if (tmpleft < size) {
472                 if ((tmppole = malloc(MEMCHUNKSZ)) == NULL)
473                         cerror("tmpalloc: out of memory");
474 //fprintf(stderr, "allocating tmp\n");
475                 tmpleft = MEMCHUNKSZ - sizeof(char *);
476                 *(char **)tmppole = tmplink;
477                 tmplink = tmppole;
478         }
479         size = ROUNDUP(size);
480         rv = &tmppole[MEMCHUNKSZ-tmpleft];
481 //printf("rv %p\n", rv);
482         tmpleft -= size;
483         tmpallocsize += size;
484         return rv;
ragge
1.13
485 }
486
487 void
488 tmpfree()
489 {
ragge
1.18
490         char *f, *of;
491
492         f = tmplink;
ragge
1.19
493         if (f == NULL)
494                 return;
495         if (*(char **)f == NULL) {
496                 tmpleft = MEMCHUNKSZ - sizeof(char *);
497                 return;
498         }
ragge
1.18
499         while (f != NULL) {
500                 of = f;
501                 f = *(char **)f;
502                 free(of);
503         }
504         tmplink = tmppole = NULL;
505         tmpleft = 0;
ragge
1.17
506 //fprintf(stderr, "freeing tmp\n");
ragge
1.13
507         /* XXX - nothing right now */
ragge
1.16
508 }
509
510 /*
511  * Allocate space on the permanent stack for a string of length len+1
512  * and copy it there.
513  * Return the new address.
514  */
515 char *
516 newstring(char *sint len)
517 {
518         char *u, *c;
519
520         len++;
521         if (allocleft < len) {
522                 u = c = permalloc(len);
523         } else {
524                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
525                 allocleft -= ROUNDUP(len+1);
526         }
527         while (len--)
528                 *c++ = *s++;
529         return u;
ragge
1.13
530 }
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-11-01 15:09 +0100