Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030703205227

Diff

Diff from 1.24 to:

Annotations

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

Annotated File View

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