Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030616222950

Diff

Diff from 1.20 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
38 NODE *lastfree;  /* pointer to last free node; (for allocator) */
39
ragge
1.2
40 /*
41  * nonfatal error message
42  * the routine where is different for pass 1 and pass 2;
43  * it tells where the error took place
44  */
45 void
46 uerror(char *s, ...)
47 {
48         va_list ap;
ragge
1.1
49
ragge
1.2
50         va_start(aps);
ragge
1.1
51         ++nerrors;
ragge
1.10
52         WHERE('u');
ragge
1.2
53         vfprintf(stderrsap);
54         fprintf(stderr"\n");
55         if (nerrors > 30)
56                 cerror("too many errors");
57         va_end(ap);
58 }
59
60 /*
61  * compiler error: die
62  */
63 void
64 cerror(char *s, ...)
65 {
66         va_list ap;
ragge
1.1
67
ragge
1.2
68         va_start(aps);
ragge
1.10
69         WHERE('c');
ragge
1.2
70
71         /* give the compiler the benefit of the doubt */
72         if (nerrors && nerrors <= 30) {
73                 fprintf(stderr,
74                     "cannot recover from earlier errors: goodbye!\n");
75         } else {
76                 fprintf(stderr"compiler error: ");
77                 vfprintf(stderrsap);
78                 fprintf(stderr"\n");
79         }
80         va_end(ap);
ragge
1.1
81         EXIT(1);
ragge
1.2
82 }
ragge
1.1
83
ragge
1.8
84 int wflag = 0/* Non-zero means do not print warnings */
ragge
1.1
85
ragge
1.2
86 /*
87  * warning
88  */
89 void
90 werror(char *s, ...)
91 {
92         va_list ap;
93
ragge
1.8
94         if(wflag)
ragge
1.2
95                 return;
96         va_start(aps);
ragge
1.10
97         WHERE('w');
ragge
1.2
98         fprintf(stderr"warning: ");
99         vfprintf(stderrsap);
100         fprintf(stderr"\n");
101 }
ragge
1.1
102
ragge
1.2
103 /*
104  * initialize expression tree search
105  */
106 void
107 tinit()
108 {
109         NODE *p;
ragge
1.1
110
ragge
1.2
111         for (p=nodep<= &node[TREESZ-1]; ++p)
ragge
1.12
112                 p->n_op = FREE;
ragge
1.1
113         lastfree = node;
ragge
1.2
114 }
ragge
1.1
115
116 # define TNEXT(p) (p== &node[TREESZ-1]?node:p+1)
117
118 NODE *
ragge
1.2
119 talloc()
120 {
ragge
1.1
121         register NODE *p, *q;
122
123         q = lastfree;
124         forp = TNEXT(q); p!=qpTNEXT(p))
ragge
1.12
125                 ifp->n_op ==FREE )
ragge
1.1
126                         return(lastfree=p);
127
128         cerror"out of tree space; simplify expression");
129         /* NOTREACHED */
ragge
1.2
130         return NULL;
131 }
ragge
1.1
132
ragge
1.2
133 /*
134  * ensure that all nodes have been freed
135  */
136 void
137 tcheck()
138 {
139         NODE *p;
ragge
1.1
140
ragge
1.7
141         if (!nerrors)
142                 for (p=nodep<= &node[TREESZ-1]; ++p)
ragge
1.12
143                         if (p->n_op != FREE)
ragge
1.7
144                                 cerror("wasted space: %p"p);
ragge
1.1
145         tinit();
ragge
1.2
146 }
ragge
1.1
147
ragge
1.2
148 /*
149  * free the tree p
150  */
151 void
152 tfree(NODE *p)
153 {
ragge
1.12
154         if (p->n_op != FREE)
ragge
1.2
155                 walkf(ptfree1);
156 }
ragge
1.1
157
ragge
1.2
158 void
159 tfree1(NODE *p)
160 {
161         if (p == 0)
162                 cerror("freeing blank tree!");
163         else
ragge
1.12
164                 p->n_op = FREE;
ragge
1.2
165 }
ragge
1.1
166
ragge
1.2
167 void
168 fwalk(NODE *tint (*f)(NODE *, intint *, int *), int down)
169 {
ragge
1.1
170
171         int down1down2;
172
173         more:
174         down1 = down2 = 0;
175
ragge
1.2
176         (*f)(tdown, &down1, &down2);
ragge
1.1
177
ragge
1.12
178         switch (optypet->n_op )) {
ragge
1.1
179
180         case BITYPE:
ragge
1.12
181                 fwalkt->n_leftfdown1 );
182                 t = t->n_right;
ragge
1.1
183                 down = down2;
184                 goto more;
185
186         case UTYPE:
ragge
1.12
187                 t = t->n_left;
ragge
1.1
188                 down = down1;
189                 goto more;
190
191         }
ragge
1.2
192 }
ragge
1.1
193
194 #ifndef vax
ragge
1.2
195 void
196 walkf(NODE *tvoid (*f)(NODE *))
197 {
198         int opty;
ragge
1.1
199
ragge
1.12
200         opty = optype(t->n_op);
ragge
1.1
201
ragge
1.2
202         if (opty != LTYPE)
ragge
1.12
203                 walkft->n_leftf );
ragge
1.2
204         if (opty == BITYPE)
ragge
1.12
205                 walkft->n_rightf );
ragge
1.2
206         (*f)(t);
207 }
ragge
1.1
208 #else
209 #define NR      32
210
211 /*
212  * Deliberately avoids recursion -- use this version on machines with
213  * expensive procedure calls.
214  */
215 walkf(tf)
216         register NODE *t;
217         register int (*f)();
218 {
219         NODE *Aat[NR];
220         int Aao[NR];
221         register int i = 1;
ragge
1.12
222         register int opty = optype(t->n_op);
ragge
1.1
223         register NODE **at = Aat;
224         register int *ao = Aao;
225
226 #define PUSH(dir, state) \
ragge
1.12
227         (ao[i] = stateat[i++] = tt = t->in.diropty = optype(t->n_op))
ragge
1.1
228 #define POP() \
229         (opty = ao[--i], t = at[i])
230
231         do {
232                 switch (opty) {
233                 case LTYPE:     (*f)(t); POP(); break;
234                 case UTYPE:     PUSH(leftLTYPE); break;
235                 case BITYPE:    PUSH(leftBITYPE+1); break;
236                 case BITYPE+1:  PUSH(rightLTYPE); break;
237                 default:
238                         cerror("bad op type in walkf");
239                 }
240                 if (i >= NR) {
241                         walkf(tf);
242                         POP();
243                 }
244         } while (i > 0);
245 }
246 #undef NR
247 #undef PUSH
248 #undef POP
249 #endif
250
251
252
ragge
1.11
253 int dope[DSIZE];
ragge
1.1
254 char *opst[DSIZE];
255
ragge
1.2
256 struct dopest {
257         int dopeop;
258         char opst[8];
259         int dopeval;
260 indope[] = {
261         { NAME"NAME"LTYPE, },
262         { STRING"STRING"LTYPE, },
263         { REG"REG"LTYPE, },
264         { OREG"OREG"LTYPE, },
265         { ICON"ICON"LTYPE, },
266         { FCON"FCON"LTYPE, },
267         { DCON"DCON"LTYPE, },
268         { CCODES"CCODES"LTYPE, },
269         { UNARY MINUS"U-"UTYPE, },
270         { UNARY MUL"U*"UTYPE, },
271         { UNARY AND"U&"UTYPE, },
272         { UNARY CALL"UCALL"UTYPE|CALLFLG, },
273         { UNARY FORTCALL"UFCALL"UTYPE|CALLFLG, },
274         { NOT"!"UTYPE|LOGFLG, },
275         { COMPL"~"UTYPE, },
276         { FORCE"FORCE"UTYPE, },
277         { INIT"INIT"UTYPE, },
278         { SCONV"SCONV"UTYPE, },
279         { PCONV"PCONV"UTYPE, },
280         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
281         { ASG PLUS"+="BITYPE|ASGFLG|ASGOPFLG|FLOFLG|SIMPFLG|COMMFLG, },
282         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
283         { ASG MINUS"-="BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
284         { MUL"*"BITYPE|FLOFLG|MULFLG, },
285         { ASG MUL"*="BITYPE|FLOFLG|MULFLG|ASGFLG|ASGOPFLG, },
286         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
287         { ASG AND"&="BITYPE|SIMPFLG|COMMFLG|ASGFLG|ASGOPFLG, },
288         { QUEST"?"BITYPE, },
289         { COLON":"BITYPE, },
290         { ANDAND"&&"BITYPE|LOGFLG, },
291         { OROR"||"BITYPE|LOGFLG, },
292         { CM","BITYPE, },
293         { COMOP",OP"BITYPE, },
294         { ASSIGN"="BITYPE|ASGFLG, },
295         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
296         { ASG DIV"/="BITYPE|FLOFLG|MULFLG|DIVFLG|ASGFLG|ASGOPFLG, },
297         { MOD"%"BITYPE|DIVFLG, },
298         { ASG MOD"%="BITYPE|DIVFLG|ASGFLG|ASGOPFLG, },
299         { LS"<<"BITYPE|SHFFLG, },
300         { ASG LS"<<="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
301         { RS">>"BITYPE|SHFFLG, },
302         { ASG RS">>="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
303         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
304         { ASG OR"|="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
305         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
306         { ASG ER"^="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
307         { INCR"++"BITYPE|ASGFLG, },
308         { DECR"--"BITYPE|ASGFLG, },
309         { STREF"->"BITYPE, },
310         { CALL"CALL"BITYPE|CALLFLG, },
311         { FORTCALL"FCALL"BITYPE|CALLFLG, },
312         { EQ"=="BITYPE|LOGFLG, },
313         { NE"!="BITYPE|LOGFLG, },
314         { LE"<="BITYPE|LOGFLG, },
315         { LT"<"BITYPE|LOGFLG, },
316         { GE">"BITYPE|LOGFLG, },
317         { GT">"BITYPE|LOGFLG, },
318         { UGT"UGT"BITYPE|LOGFLG, },
319         { UGE"UGE"BITYPE|LOGFLG, },
320         { ULT"ULT"BITYPE|LOGFLG, },
321         { ULE"ULE"BITYPE|LOGFLG, },
ragge
1.1
322 #ifdef ARS
ragge
1.2
323         { ARS"A>>"BITYPE, },
ragge
1.1
324 #endif
ragge
1.2
325         { TYPE"TYPE"LTYPE, },
326         { LB"["BITYPE, },
327         { CBRANCH"CBRANCH"BITYPE, },
328         { FLD"FLD"UTYPE, },
329         { PMCONV"PMCONV"BITYPE, },
330         { PVCONV"PVCONV"BITYPE, },
331         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
332         { CAST"CAST"BITYPE|ASGFLG|ASGOPFLG, },
333         { GOTO"GOTO"UTYPE, },
334         { STASG"STASG"BITYPE|ASGFLG, },
335         { STARG"STARG"UTYPE, },
336         { STCALL"STCALL"BITYPE|CALLFLG, },
337         { UNARY STCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.1
338
ragge
1.2
339         { -1,   "",     0 },
ragge
1.1
340 };
341
ragge
1.2
342 void
343 mkdope()
344 {
345         struct dopest *q;
ragge
1.1
346
347         forq = indopeq->dopeop >= 0; ++q ){
348                 dope[q->dopeop] = q->dopeval;
349                 opst[q->dopeop] = q->opst;
350         }
ragge
1.2
351 }
352
ragge
1.1
353 # ifndef BUG4
ragge
1.2
354 /*
355  * output a nice description of the type of t
356  */
357 void
358 tprint(TWORD t)
359 {
ragge
1.1
360         static char * tnames[] = {
361                 "undef",
362                 "farg",
363                 "char",
364                 "short",
365                 "int",
366                 "long",
ragge
1.9
367                 "longlong",
ragge
1.1
368                 "float",
369                 "double",
370                 "strty",
371                 "unionty",
372                 "enumty",
373                 "moety",
374                 "uchar",
375                 "ushort",
376                 "unsigned",
377                 "ulong",
ragge
1.9
378                 "ulonglong",
ragge
1.1
379                 "?""?"
380                 };
381
382         for(;; t = DECREF(t) ){
383
ragge
1.2
384                 if (ISPTR(t))
385                         printf("PTR ");
386                 else if (ISFTN(t))
387                         printf("FTN ");
388                 else if (ISARY(t))
389                         printf("ARY ");
ragge
1.1
390                 else {
ragge
1.2
391                         printf("%s"tnames[t]);
ragge
1.1
392                         return;
393                 }
394         }
ragge
1.2
395 }
ragge
1.1
396 # endif
ragge
1.13
397
398 /*
ragge
1.14
399  * Return a number for internal labels.
400  * If multipass, the lowest digit will be the pass number, otherwise
401  * it's just a sequential number.
402  */
403 int 
404 getlab()
405 {
406         static int crslab = 10;
407 #if defined(PASS1)
408         return (crslab++ * 10)+1;
409 #elif defined(PASS2)
410         return (crslab++ * 10)+2;
411 #else
412         return crslab++;
413 #endif
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.
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-12-21 15:27 +0100