Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030703181004

Diff

Diff from 1.23 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
ragge
1.22
118 static NODE *freelink;
119
ragge
1.1
120 NODE *
ragge
1.2
121 talloc()
122 {
ragge
1.1
123         register NODE *p, *q;
124
ragge
1.22
125         if (freelink != NULL) {
126                 p = freelink;
127                 freelink = p->next;
128 //printf("talloc reuse %p\n", p);
129                 if (p->n_op != FREE)
ragge
1.23
130                         cerror("node not FREE: %p"p);
131                 if (nflag)
132                         printf("alloc node %p from freelist\n"p);
ragge
1.22
133                 return p;
134         }
135
ragge
1.1
136         q = lastfree;
137         forp = TNEXT(q); p!=qpTNEXT(p))
ragge
1.22
138                 ifp->n_op ==FREE ) {
139 //printf("talloc new %p\n", p);
ragge
1.23
140                         if (nflag)
141                                 printf("alloc node %p from memory\n"p);
ragge
1.1
142                         return(lastfree=p);
ragge
1.22
143                 }
ragge
1.1
144
145         cerror"out of tree space; simplify expression");
146         /* NOTREACHED */
ragge
1.2
147         return NULL;
148 }
ragge
1.1
149
ragge
1.2
150 /*
151  * ensure that all nodes have been freed
152  */
153 void
154 tcheck()
155 {
156         NODE *p;
ragge
1.1
157
ragge
1.7
158         if (!nerrors)
159                 for (p=nodep<= &node[TREESZ-1]; ++p)
ragge
1.12
160                         if (p->n_op != FREE)
ragge
1.7
161                                 cerror("wasted space: %p"p);
ragge
1.1
162         tinit();
ragge
1.2
163 }
ragge
1.1
164
ragge
1.2
165 /*
166  * free the tree p
167  */
168 void
169 tfree(NODE *p)
170 {
ragge
1.22
171 //printf("tfreeing\n");
ragge
1.12
172         if (p->n_op != FREE)
ragge
1.22
173                 walkf(pnfree);
174 //printf("end tfreeing\n");
ragge
1.2
175 }
ragge
1.1
176
ragge
1.2
177 void
ragge
1.22
178 nfree(NODE *p)
ragge
1.2
179 {
ragge
1.22
180         NODE *q;
181
182 #if 0
183 printf("nfree %p\n"p);
184 fflush(stdout);
185 #endif
186
187         if (p != NULL) {
188                 if (p->n_op == FREE)
189                         cerror("freeing FREE node"p);
190                 q = freelink;
191                 while (q != NULL) {
192                         if (q == p)
193                                 cerror("freeing free node %p"p);
194                         q = q->next;
195                 }
196
ragge
1.23
197                 if (nflag)
198                         printf("freeing node %p\n"p);
ragge
1.12
199                 p->n_op = FREE;
ragge
1.23
200                 if (p >= node && p < &node[TREESZ+1]) {
201                         p->next = freelink;
202                         freelink = p;
203                 }
ragge
1.22
204         } else
205                 cerror("freeing blank node!");
ragge
1.2
206 }
ragge
1.1
207
ragge
1.2
208 void
209 fwalk(NODE *tint (*f)(NODE *, intint *, int *), int down)
210 {
ragge
1.1
211
212         int down1down2;
213
214         more:
215         down1 = down2 = 0;
216
ragge
1.2
217         (*f)(tdown, &down1, &down2);
ragge
1.1
218
ragge
1.12
219         switch (optypet->n_op )) {
ragge
1.1
220
221         case BITYPE:
ragge
1.12
222                 fwalkt->n_leftfdown1 );
223                 t = t->n_right;
ragge
1.1
224                 down = down2;
225                 goto more;
226
227         case UTYPE:
ragge
1.12
228                 t = t->n_left;
ragge
1.1
229                 down = down1;
230                 goto more;
231
232         }
ragge
1.2
233 }
ragge
1.1
234
235 #ifndef vax
ragge
1.2
236 void
237 walkf(NODE *tvoid (*f)(NODE *))
238 {
239         int opty;
ragge
1.1
240
ragge
1.12
241         opty = optype(t->n_op);
ragge
1.1
242
ragge
1.2
243         if (opty != LTYPE)
ragge
1.12
244                 walkft->n_leftf );
ragge
1.2
245         if (opty == BITYPE)
ragge
1.12
246                 walkft->n_rightf );
ragge
1.2
247         (*f)(t);
248 }
ragge
1.1
249 #else
250 #define NR      32
251
252 /*
253  * Deliberately avoids recursion -- use this version on machines with
254  * expensive procedure calls.
255  */
256 walkf(tf)
257         register NODE *t;
258         register int (*f)();
259 {
260         NODE *Aat[NR];
261         int Aao[NR];
262         register int i = 1;
ragge
1.12
263         register int opty = optype(t->n_op);
ragge
1.1
264         register NODE **at = Aat;
265         register int *ao = Aao;
266
267 #define PUSH(dir, state) \
ragge
1.12
268         (ao[i] = stateat[i++] = tt = t->in.diropty = optype(t->n_op))
ragge
1.1
269 #define POP() \
270         (opty = ao[--i], t = at[i])
271
272         do {
273                 switch (opty) {
274                 case LTYPE:     (*f)(t); POP(); break;
275                 case UTYPE:     PUSH(leftLTYPE); break;
276                 case BITYPE:    PUSH(leftBITYPE+1); break;
277                 case BITYPE+1:  PUSH(rightLTYPE); break;
278                 default:
279                         cerror("bad op type in walkf");
280                 }
281                 if (i >= NR) {
282                         walkf(tf);
283                         POP();
284                 }
285         } while (i > 0);
286 }
287 #undef NR
288 #undef PUSH
289 #undef POP
290 #endif
291
292
293
ragge
1.11
294 int dope[DSIZE];
ragge
1.1
295 char *opst[DSIZE];
296
ragge
1.2
297 struct dopest {
298         int dopeop;
299         char opst[8];
300         int dopeval;
301 indope[] = {
302         { NAME"NAME"LTYPE, },
303         { STRING"STRING"LTYPE, },
304         { REG"REG"LTYPE, },
305         { OREG"OREG"LTYPE, },
306         { ICON"ICON"LTYPE, },
307         { FCON"FCON"LTYPE, },
308         { DCON"DCON"LTYPE, },
309         { CCODES"CCODES"LTYPE, },
310         { UNARY MINUS"U-"UTYPE, },
311         { UNARY MUL"U*"UTYPE, },
312         { UNARY AND"U&"UTYPE, },
313         { UNARY CALL"UCALL"UTYPE|CALLFLG, },
314         { UNARY FORTCALL"UFCALL"UTYPE|CALLFLG, },
315         { NOT"!"UTYPE|LOGFLG, },
316         { COMPL"~"UTYPE, },
317         { FORCE"FORCE"UTYPE, },
318         { INIT"INIT"UTYPE, },
319         { SCONV"SCONV"UTYPE, },
320         { PCONV"PCONV"UTYPE, },
321         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
322         { ASG PLUS"+="BITYPE|ASGFLG|ASGOPFLG|FLOFLG|SIMPFLG|COMMFLG, },
323         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
324         { ASG MINUS"-="BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
325         { MUL"*"BITYPE|FLOFLG|MULFLG, },
326         { ASG MUL"*="BITYPE|FLOFLG|MULFLG|ASGFLG|ASGOPFLG, },
327         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
328         { ASG AND"&="BITYPE|SIMPFLG|COMMFLG|ASGFLG|ASGOPFLG, },
329         { QUEST"?"BITYPE, },
330         { COLON":"BITYPE, },
331         { ANDAND"&&"BITYPE|LOGFLG, },
332         { OROR"||"BITYPE|LOGFLG, },
333         { CM","BITYPE, },
334         { COMOP",OP"BITYPE, },
335         { ASSIGN"="BITYPE|ASGFLG, },
336         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
337         { ASG DIV"/="BITYPE|FLOFLG|MULFLG|DIVFLG|ASGFLG|ASGOPFLG, },
338         { MOD"%"BITYPE|DIVFLG, },
339         { ASG MOD"%="BITYPE|DIVFLG|ASGFLG|ASGOPFLG, },
340         { LS"<<"BITYPE|SHFFLG, },
341         { ASG LS"<<="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
342         { RS">>"BITYPE|SHFFLG, },
343         { ASG RS">>="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
344         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
345         { ASG OR"|="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
346         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
347         { ASG ER"^="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
348         { INCR"++"BITYPE|ASGFLG, },
349         { DECR"--"BITYPE|ASGFLG, },
350         { STREF"->"BITYPE, },
351         { CALL"CALL"BITYPE|CALLFLG, },
352         { FORTCALL"FCALL"BITYPE|CALLFLG, },
353         { EQ"=="BITYPE|LOGFLG, },
354         { NE"!="BITYPE|LOGFLG, },
355         { LE"<="BITYPE|LOGFLG, },
356         { LT"<"BITYPE|LOGFLG, },
357         { GE">"BITYPE|LOGFLG, },
358         { GT">"BITYPE|LOGFLG, },
359         { UGT"UGT"BITYPE|LOGFLG, },
360         { UGE"UGE"BITYPE|LOGFLG, },
361         { ULT"ULT"BITYPE|LOGFLG, },
362         { ULE"ULE"BITYPE|LOGFLG, },
ragge
1.1
363 #ifdef ARS
ragge
1.2
364         { ARS"A>>"BITYPE, },
ragge
1.1
365 #endif
ragge
1.22
366         { TYPE"TYPE"LTYPE, },
ragge
1.2
367         { LB"["BITYPE, },
368         { CBRANCH"CBRANCH"BITYPE, },
369         { FLD"FLD"UTYPE, },
370         { PMCONV"PMCONV"BITYPE, },
371         { PVCONV"PVCONV"BITYPE, },
372         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
373         { CAST"CAST"BITYPE|ASGFLG|ASGOPFLG, },
374         { GOTO"GOTO"UTYPE, },
375         { STASG"STASG"BITYPE|ASGFLG, },
376         { STARG"STARG"UTYPE, },
377         { STCALL"STCALL"BITYPE|CALLFLG, },
378         { UNARY STCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.1
379
ragge
1.2
380         { -1,   "",     0 },
ragge
1.1
381 };
382
ragge
1.2
383 void
384 mkdope()
385 {
386         struct dopest *q;
ragge
1.1
387
388         forq = indopeq->dopeop >= 0; ++q ){
389                 dope[q->dopeop] = q->dopeval;
390                 opst[q->dopeop] = q->opst;
391         }
ragge
1.2
392 }
393
ragge
1.1
394 # ifndef BUG4
ragge
1.2
395 /*
396  * output a nice description of the type of t
397  */
398 void
399 tprint(TWORD t)
400 {
ragge
1.1
401         static char * tnames[] = {
402                 "undef",
403                 "farg",
404                 "char",
405                 "short",
406                 "int",
407                 "long",
ragge
1.9
408                 "longlong",
ragge
1.1
409                 "float",
410                 "double",
411                 "strty",
412                 "unionty",
413                 "enumty",
414                 "moety",
415                 "uchar",
416                 "ushort",
417                 "unsigned",
418                 "ulong",
ragge
1.9
419                 "ulonglong",
ragge
1.1
420                 "?""?"
421                 };
422
423         for(;; t = DECREF(t) ){
424
ragge
1.2
425                 if (ISPTR(t))
426                         printf("PTR ");
427                 else if (ISFTN(t))
428                         printf("FTN ");
429                 else if (ISARY(t))
430                         printf("ARY ");
ragge
1.1
431                 else {
ragge
1.2
432                         printf("%s"tnames[t]);
ragge
1.1
433                         return;
434                 }
435         }
ragge
1.2
436 }
ragge
1.1
437 # endif
ragge
1.13
438
439 /*
ragge
1.14
440  * Return a number for internal labels.
441  * If multipass, the lowest digit will be the pass number, otherwise
442  * it's just a sequential number.
443  */
444 int 
445 getlab()
446 {
447         static int crslab = 10;
448 #if defined(PASS1)
449         return (crslab++ * 10)+1;
450 #elif defined(PASS2)
451         return (crslab++ * 10)+2;
452 #else
453         return crslab++;
454 #endif
455 }
456
457 /*
ragge
1.13
458  * Memory allocation routines.
459  * Memory are allocated from the system in MEMCHUNKSZ blocks.
460  * permalloc() returns a bunch of memory that is never freed.
461  * Memory allocated through tmpalloc() will be released the
462  * next time a function is ended (via tmpfree()).
463  */
464
465 #define MEMCHUNKSZ 8192 /* 8k per allocation */
ragge
1.16
466 #define ROUNDUP(x) ((x) + (sizeof(int)-1)) & ~(sizeof(int)-1)
ragge
1.13
467
468 static char *allocpole;
469 static int allocleft;
ragge
1.17
470 static char *tmppole;
471 static int tmpleft;
ragge
1.18
472 int permallocsizetmpallocsizelostmem;
ragge
1.13
473
474 void *
475 permalloc(int size)
476 {
477         void *rv;
478
479 //printf("permalloc: allocpole %p allocleft %d size %d ", allocpole, allocleft, size);
480         if (size > MEMCHUNKSZ)
481                 cerror("permalloc");
ragge
1.20
482         if (size <= 0)
483                 cerror("permalloc2");
ragge
1.18
484         if (allocleft < size) {
ragge
1.13
485                 /* looses unused bytes */
ragge
1.18
486                 lostmem += allocleft;
ragge
1.17
487 //fprintf(stderr, "allocating perm\n");
ragge
1.13
488                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
489                         cerror("permalloc: out of memory");
490                 allocleft = MEMCHUNKSZ;
491         }
ragge
1.16
492         size = ROUNDUP(size);
ragge
1.13
493         rv = &allocpole[MEMCHUNKSZ-allocleft];
494 //printf("rv %p\n", rv);
495         allocleft -= size;
ragge
1.17
496         permallocsize += size;
ragge
1.13
497         return rv;
498 }
499
ragge
1.17
500 static char *tmplink;
501
ragge
1.13
502 void *
503 tmpalloc(int size)
504 {
ragge
1.17
505         void *rv;
506
507         if (size > MEMCHUNKSZ)
508                 cerror("tmpalloc");
ragge
1.20
509         if (size <= 0)
510                 cerror("tmpalloc2");
ragge
1.17
511 //printf("tmpalloc: tmppole %p tmpleft %d size %d ", tmppole, tmpleft, size);
512         if (tmpleft < size) {
513                 if ((tmppole = malloc(MEMCHUNKSZ)) == NULL)
514                         cerror("tmpalloc: out of memory");
515 //fprintf(stderr, "allocating tmp\n");
516                 tmpleft = MEMCHUNKSZ - sizeof(char *);
517                 *(char **)tmppole = tmplink;
518                 tmplink = tmppole;
519         }
520         size = ROUNDUP(size);
521         rv = &tmppole[MEMCHUNKSZ-tmpleft];
522 //printf("rv %p\n", rv);
523         tmpleft -= size;
524         tmpallocsize += size;
525         return rv;
ragge
1.13
526 }
527
528 void
529 tmpfree()
530 {
ragge
1.18
531         char *f, *of;
532
533         f = tmplink;
ragge
1.19
534         if (f == NULL)
535                 return;
536         if (*(char **)f == NULL) {
537                 tmpleft = MEMCHUNKSZ - sizeof(char *);
538                 return;
539         }
ragge
1.18
540         while (f != NULL) {
541                 of = f;
542                 f = *(char **)f;
543                 free(of);
544         }
545         tmplink = tmppole = NULL;
546         tmpleft = 0;
ragge
1.17
547 //fprintf(stderr, "freeing tmp\n");
ragge
1.13
548         /* XXX - nothing right now */
ragge
1.16
549 }
550
551 /*
552  * Allocate space on the permanent stack for a string of length len+1
553  * and copy it there.
554  * Return the new address.
555  */
556 char *
557 newstring(char *sint len)
558 {
559         char *u, *c;
560
561         len++;
562         if (allocleft < len) {
563                 u = c = permalloc(len);
564         } else {
565                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
566                 allocleft -= ROUNDUP(len+1);
567         }
568         while (len--)
569                 *c++ = *s++;
570         return u;
ragge
1.13
571 }
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-18 06:50 +0100