Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030606193955

Diff

Diff from 1.17 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;
431 int permallocsizetmpallocsize;
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");
441         if (allocpole == NULL || (allocleft < size)) {
442                 /* looses unused bytes */
ragge
1.17
443 //fprintf(stderr, "allocating perm\n");
ragge
1.13
444                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
445                         cerror("permalloc: out of memory");
446                 allocleft = MEMCHUNKSZ;
447         }
ragge
1.16
448         size = ROUNDUP(size);
ragge
1.13
449         rv = &allocpole[MEMCHUNKSZ-allocleft];
450 //printf("rv %p\n", rv);
451         allocleft -= size;
ragge
1.17
452         permallocsize += size;
ragge
1.13
453         return rv;
454 }
455
ragge
1.17
456 static char *tmplink;
457
ragge
1.13
458 void *
459 tmpalloc(int size)
460 {
ragge
1.17
461         void *rv;
462
463         if (size > MEMCHUNKSZ)
464                 cerror("tmpalloc");
465 //printf("tmpalloc: tmppole %p tmpleft %d size %d ", tmppole, tmpleft, size);
466         if (tmpleft < size) {
467                 if ((tmppole = malloc(MEMCHUNKSZ)) == NULL)
468                         cerror("tmpalloc: out of memory");
469 //fprintf(stderr, "allocating tmp\n");
470                 tmpleft = MEMCHUNKSZ - sizeof(char *);
471                 *(char **)tmppole = tmplink;
472                 tmplink = tmppole;
473         }
474         size = ROUNDUP(size);
475         rv = &tmppole[MEMCHUNKSZ-tmpleft];
476 //printf("rv %p\n", rv);
477         tmpleft -= size;
478         tmpallocsize += size;
479         return rv;
ragge
1.13
480 }
481
482 void
483 tmpfree()
484 {
ragge
1.17
485 //fprintf(stderr, "freeing tmp\n");
ragge
1.13
486         /* XXX - nothing right now */
ragge
1.16
487 }
488
489 /*
490  * Allocate space on the permanent stack for a string of length len+1
491  * and copy it there.
492  * Return the new address.
493  */
494 char *
495 newstring(char *sint len)
496 {
497         char *u, *c;
498
499         len++;
500         if (allocleft < len) {
501                 u = c = permalloc(len);
502         } else {
503                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
504                 allocleft -= ROUNDUP(len+1);
505         }
506         while (len--)
507                 *c++ = *s++;
508         return u;
ragge
1.13
509 }
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-31 04:17 +0200