Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030703135351

Diff

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