← Back to branch summary

~helenos-nicf/helenos/nicf

« back to all changes in this revision

Viewing changes to uspace/app/pcc/f77/fcom/defs.h

  • Committer: Radim Vansa
  • Date: 2011-09-20 21:55:59 UTC
  • mfrom: (697.1.517 HelenOS.mainline)
  • Revision ID: radim.vansa@matfyz.cz-20110920215559-7fjpai6wt5ieurcq
Merge with mainline

Show diffs side-by-side

added added

removed removed

Lines of Context:
uspace/app/pcc/f77/fcom/defs.h
 
1
/*      $Id: defs.h,v 1.22 2008/12/24 17:40:41 sgk Exp $        */
 
2
/*
 
3
 * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 *
 
9
 * Redistributions of source code and documentation must retain the above
 
10
 * copyright notice, this list of conditions and the following disclaimer.
 
11
 * Redistributions in binary form must reproduce the above copyright
 
12
 * notice, this list of conditionsand the following disclaimer in the
 
13
 * documentation and/or other materials provided with the distribution.
 
14
 * All advertising materials mentioning features or use of this software
 
15
 * must display the following acknowledgement:
 
16
 *      This product includes software developed or owned by Caldera
 
17
 *      International, Inc.
 
18
 * Neither the name of Caldera International, Inc. nor the names of other
 
19
 * contributors may be used to endorse or promote products derived from
 
20
 * this software without specific prior written permission.
 
21
 *
 
22
 * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
 
23
 * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
 
24
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
25
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
26
 * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
 
27
 * FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
28
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 
29
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
30
 * HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
 
31
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 
32
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 
33
 * POSSIBILITY OF SUCH DAMAGE.
 
34
 */
 
35
#include <stdio.h>
 
36
#include <ctype.h>
 
37
#include <stdlib.h>
 
38
 
 
39
#define VL 6
 
40
#define XL 8
 
41
 
 
42
#define MAXINCLUDES 10
 
43
#define MAXLITERALS 20
 
44
#define MAXCTL 20
 
45
#define MAXHASH 401
 
46
#define MAXSTNO 1000
 
47
#define MAXEXT 200
 
48
#define MAXEQUIV 150
 
49
#define MAXLABLIST 100
 
50
 
 
51
typedef struct bigblock *bigptr;
 
52
typedef union chainedblock *chainp;
 
53
 
 
54
extern FILE *infile;
 
55
extern FILE *diagfile;
 
56
extern long int headoffset;
 
57
 
 
58
extern char token [ ];
 
59
extern int toklen;
 
60
extern int lineno;
 
61
extern char *infname;
 
62
extern int needkwd;
 
63
extern struct labelblock *thislabel;
 
64
 
 
65
extern int mflag, tflag;
 
66
 
 
67
extern flag profileflag;
 
68
extern flag optimflag;
 
69
extern flag quietflag;
 
70
extern flag nowarnflag;
 
71
extern flag ftn66flag;
 
72
extern flag shiftcase;
 
73
extern flag undeftype;
 
74
extern flag shortsubs;
 
75
extern flag onetripflag;
 
76
extern flag checksubs;
 
77
extern flag debugflag;
 
78
extern int nerr;
 
79
extern int nwarn;
 
80
extern int ndata;
 
81
 
 
82
extern int parstate;
 
83
extern flag headerdone;
 
84
extern int blklevel;
 
85
extern flag saveall;
 
86
extern flag substars;
 
87
extern int impltype[ ];
 
88
extern int implleng[ ];
 
89
extern int implstg[ ];
 
90
 
 
91
extern int tyint;
 
92
extern int tylogical;
 
93
extern ftnint typesize[];
 
94
extern int typealign[];
 
95
extern int procno;
 
96
extern int proctype;
 
97
extern char * procname;
 
98
extern int rtvlabel[ ];
 
99
extern int fudgelabel;  /* to confuse the pdp11 optimizer */
 
100
extern struct bigblock *typeaddr;
 
101
extern struct bigblock *retslot;
 
102
extern int cxslot;
 
103
extern int chslot;
 
104
extern int chlgslot;
 
105
extern int procclass;
 
106
extern ftnint procleng;
 
107
extern int nentry;
 
108
extern flag multitype;
 
109
extern int blklevel;
 
110
extern int lastlabno;
 
111
extern int lastvarno;
 
112
extern int lastargslot;
 
113
extern int argloc;
 
114
extern ftnint autoleng;
 
115
extern ftnint bssleng;
 
116
extern int retlabel;
 
117
extern int ret0label;
 
118
extern int dorange;
 
119
extern int regnum[ ];
 
120
extern bigptr regnamep[ ];
 
121
extern int maxregvar;
 
122
extern int highregvar;
 
123
 
 
124
extern chainp templist;
 
125
extern chainp holdtemps;
 
126
extern chainp entries;
 
127
extern chainp rpllist;
 
128
extern chainp curdtp;
 
129
extern ftnint curdtelt;
 
130
extern flag toomanyinit;
 
131
 
 
132
extern flag inioctl;
 
133
extern int iostmt;
 
134
extern struct bigblock *ioblkp;
 
135
extern int nioctl;
 
136
extern int nequiv;
 
137
extern int nintnames;
 
138
extern int nextnames;
 
139
 
 
140
struct chain
 
141
        {
 
142
        chainp nextp;
 
143
        bigptr datap;
 
144
        };
 
145
 
 
146
extern chainp chains;
 
147
 
 
148
struct ctlframe
 
149
        {
 
150
        unsigned ctltype:8;
 
151
        unsigned dostepsign:8;
 
152
        int ctlabels[4];
 
153
        int dolabel;
 
154
        struct bigblock *donamep;
 
155
        bigptr domax;
 
156
        bigptr dostep;
 
157
        };
 
158
#define endlabel ctlabels[0]
 
159
#define elselabel ctlabels[1]
 
160
#define dobodylabel ctlabels[1]
 
161
#define doposlabel ctlabels[2]
 
162
#define doneglabel ctlabels[3]
 
163
extern struct ctlframe ctls[ ];
 
164
extern struct ctlframe *ctlstack;
 
165
extern struct ctlframe *lastctl;
 
166
 
 
167
struct extsym
 
168
        {
 
169
        char extname[XL];
 
170
        unsigned extstg:4;
 
171
        unsigned extsave:1;
 
172
        unsigned extinit:1;
 
173
        chainp extp;
 
174
        ftnint extleng;
 
175
        ftnint maxleng;
 
176
        };
 
177
 
 
178
extern struct extsym extsymtab[ ];
 
179
extern struct extsym *nextext;
 
180
extern struct extsym *lastext;
 
181
 
 
182
struct labelblock
 
183
        {
 
184
        int labelno;
 
185
        unsigned blklevel:8;
 
186
        unsigned labused:1;
 
187
        unsigned labinacc:1;
 
188
        unsigned labdefined:1;
 
189
        unsigned labtype:2;
 
190
        ftnint stateno;
 
191
        };
 
192
 
 
193
extern struct labelblock labeltab[ ];
 
194
extern struct labelblock *labtabend;
 
195
extern struct labelblock *highlabtab;
 
196
 
 
197
struct entrypoint
 
198
        {
 
199
        chainp nextp;
 
200
        struct extsym *entryname;
 
201
        chainp arglist;
 
202
        int entrylabel;
 
203
        int typelabel;
 
204
        ptr enamep;
 
205
        };
 
206
 
 
207
struct primblock
 
208
        {
 
209
        struct bigblock *namep;
 
210
        struct bigblock *argsp;
 
211
        bigptr fcharp;
 
212
        bigptr lcharp;
 
213
        };
 
214
 
 
215
 
 
216
struct hashentry
 
217
        {
 
218
        int hashval;
 
219
        struct bigblock *varp;
 
220
        };
 
221
extern struct hashentry hashtab[ ];
 
222
extern struct hashentry *lasthash;
 
223
 
 
224
struct intrpacked       /* bits for intrinsic function description */
 
225
        {
 
226
        unsigned f1:3;
 
227
        unsigned f2:4;
 
228
        unsigned f3:7;
 
229
        };
 
230
 
 
231
struct nameblock
 
232
        {
 
233
        char varname[VL];
 
234
        unsigned vdovar:1;
 
235
        unsigned vdcldone:1;
 
236
        unsigned vadjdim:1;
 
237
        unsigned vsave:1;
 
238
        unsigned vprocclass:3;
 
239
        unsigned vregno:4;
 
240
        union   {
 
241
                int varno;
 
242
                chainp vstfdesc;        /* points to (formals, expr) pair */
 
243
                struct intrpacked intrdesc;     /* bits for intrinsic function */
 
244
                } vardesc;
 
245
        struct dimblock *vdim;
 
246
        int voffset;
 
247
        };
 
248
 
 
249
 
 
250
struct paramblock
 
251
        {
 
252
        char varname[VL];
 
253
        bigptr paramval;
 
254
        } ;
 
255
 
 
256
 
 
257
struct exprblock
 
258
        {
 
259
        unsigned opcode:6;
 
260
        bigptr leftp;
 
261
        bigptr rightp;
 
262
        };
 
263
 
 
264
struct dcomplex {
 
265
        double dreal, dimag;
 
266
};
 
267
 
 
268
union constant
 
269
        {
 
270
        char *ccp;
 
271
        ftnint ci;
 
272
        double cd[2];
 
273
        struct dcomplex dc;
 
274
        };
 
275
 
 
276
struct constblock
 
277
        {
 
278
        union constant fconst;
 
279
        };
 
280
 
 
281
 
 
282
struct listblock
 
283
        {
 
284
        chainp listp;
 
285
        };
 
286
 
 
287
 
 
288
 
 
289
struct addrblock
 
290
        {
 
291
        int memno;
 
292
        bigptr memoffset;
 
293
        unsigned istemp:1;
 
294
        unsigned ntempelt:10;
 
295
        };
 
296
 
 
297
 
 
298
 
 
299
struct errorblock
 
300
        {
 
301
        int pad;
 
302
        };
 
303
 
 
304
 
 
305
struct dimblock
 
306
        {
 
307
        int ndim;
 
308
        bigptr nelt;
 
309
        bigptr baseoffset;
 
310
        bigptr basexpr;
 
311
        struct
 
312
                {
 
313
                bigptr dimsize;
 
314
                bigptr dimexpr;
 
315
                } dims[1];
 
316
        };
 
317
 
 
318
 
 
319
struct impldoblock  /* XXXX */
 
320
        {
 
321
#define isactive vtype
 
322
#define isbusy vclass
 
323
        struct bigblock *varnp;
 
324
        struct bigblock *varvp;
 
325
        bigptr implb;
 
326
        bigptr impub;
 
327
        bigptr impstep;
 
328
        ftnint impdiff;
 
329
        ftnint implim;
 
330
        chainp datalist;
 
331
        };
 
332
 
 
333
 
 
334
struct rplblock /* name replacement block */
 
335
        {
 
336
        chainp nextp;
 
337
        struct bigblock *rplnp;
 
338
        ptr rplvp;
 
339
        struct bigblock *rplxp;
 
340
        int rpltag;
 
341
        };
 
342
 
 
343
 
 
344
 
 
345
struct equivblock
 
346
        {
 
347
        ptr equivs;
 
348
        unsigned eqvinit:1;
 
349
        long int eqvtop;
 
350
        long int eqvbottom;
 
351
        } ;
 
352
#define eqvleng eqvtop
 
353
 
 
354
extern struct equivblock eqvclass[ ];
 
355
 
 
356
 
 
357
struct eqvchain
 
358
        {
 
359
        chainp nextp;
 
360
        ptr eqvitem;
 
361
        long int eqvoffset;
 
362
        } ;
 
363
 
 
364
union chainedblock
 
365
        {
 
366
        struct chain chain;
 
367
        struct entrypoint entrypoint;
 
368
        struct rplblock rplblock;
 
369
        struct eqvchain eqvchain;
 
370
        };
 
371
 
 
372
 
 
373
struct bigblock {
 
374
        unsigned tag:4;
 
375
        unsigned vtype:4;
 
376
        unsigned vclass:4;
 
377
        unsigned vstg:4;
 
378
        bigptr vleng;
 
379
        union {
 
380
                struct exprblock _expr;
 
381
                struct addrblock _addr;
 
382
                struct constblock _const;
 
383
                struct errorblock _error;
 
384
                struct listblock _list;
 
385
                struct primblock _prim;
 
386
                struct nameblock _name;
 
387
                struct paramblock _param;
 
388
                struct impldoblock _impldo;
 
389
        } _u;
 
390
#define b_expr          _u._expr
 
391
#define b_addr          _u._addr
 
392
#define b_const         _u._const
 
393
#define b_error         _u._error
 
394
#define b_list          _u._list
 
395
#define b_prim          _u._prim
 
396
#define b_name          _u._name
 
397
#define b_param         _u._param
 
398
#define b_impldo        _u._impldo
 
399
};
 
400
 
 
401
struct literal
 
402
        {
 
403
        short littype;
 
404
        short litnum;
 
405
        union   {
 
406
                ftnint litival;
 
407
                double litdval;
 
408
                struct  {
 
409
                        char litclen;   /* small integer */
 
410
                        char litcstr[XL];
 
411
                        } litcval;
 
412
                } litval;
 
413
        };
 
414
 
 
415
extern struct literal litpool[ ];
 
416
extern int nliterals;
 
417
 
 
418
 
 
419
 
 
420
 
 
421
 
 
422
/* popular functions with non integer return values */
 
423
#define expptr bigptr
 
424
#define tagptr bigptr
 
425
 
 
426
ptr cpblock(int ,void *);
 
427
 
 
428
ptr ckalloc(int);
 
429
char *varstr(int, char *), *nounder(int, char *), *varunder(int, char *);
 
430
char *copyn(int, char *), *copys(char *);
 
431
chainp hookup(chainp, chainp), mkchain(bigptr, chainp);
 
432
ftnint convci(int, char *), iarrlen(struct bigblock *q);
 
433
ftnint lmin(ftnint, ftnint), lmax(ftnint, ftnint);
 
434
ftnint simoffset(expptr *);
 
435
char *memname(int, int), *convic(ftnint), *setdoto(char *);
 
436
double convcd(int, char *);
 
437
struct extsym *mkext(char *), 
 
438
        *newentry(struct bigblock *),
 
439
        *comblock(int, char *s);
 
440
struct bigblock *mkname(int, char *);
 
441
struct labelblock *mklabel(ftnint);
 
442
struct bigblock *addrof(expptr), *call1(int, char *, expptr),
 
443
        *call2(int, char *, expptr, expptr),
 
444
        *call3(int, char *, expptr, expptr, expptr),
 
445
        *call4(int, char *, expptr, expptr, expptr, expptr);
 
446
struct bigblock *call0(int, char *), *mkexpr(int, bigptr, bigptr);
 
447
struct bigblock *callk(int, char *, bigptr);
 
448
 
 
449
struct bigblock *builtin(int, char *), *fmktemp(int, bigptr),
 
450
        *mktmpn(int, int, bigptr), *nextdata(ftnint *, ftnint *),
 
451
        *autovar(int, int, bigptr), *mklhs(struct bigblock *),
 
452
        *mkaddr(struct bigblock *), *putconst(struct bigblock *),
 
453
        *memversion(struct bigblock *);
 
454
struct bigblock *mkscalar(struct bigblock *np);
 
455
struct bigblock *realpart(struct bigblock *p);
 
456
struct bigblock *imagpart(struct bigblock *p);
 
457
 
 
458
struct bigblock *mkintcon(ftnint), *mkbitcon(int, int, char *),
 
459
        *mklogcon(int), *mkaddcon(int), *mkrealcon(int, double),
 
460
        *mkstrcon(int, char *), *mkcxcon(bigptr,bigptr);
 
461
bigptr mkconst(int t);
 
462
 
 
463
bigptr mklist(chainp p);
 
464
bigptr mkiodo(chainp, chainp);
 
465
 
 
466
 
 
467
bigptr mkconv(int, bigptr),
 
468
        mkfunct(struct bigblock *), fixexpr(struct bigblock *),
 
469
        fixtype(bigptr);
 
470
 
 
471
 
 
472
bigptr cpexpr(bigptr), mkprim(bigptr, struct bigblock *, bigptr, bigptr);
 
473
struct bigblock *mkarg(int, int);
 
474
struct bigblock *errnode(void);
 
475
void initkey(void), prtail(void), puteof(void), done(int);
 
476
void fileinit(void), procinit(void), endproc(void), doext(void), preven(int);
 
477
int inilex(char *), yyparse(void), newlabel(void), lengtype(int, int);
 
478
void err(char *, ...), warn(char *, ...), fatal(char *, ...), enddcl(void);
 
479
void p2pass(char *s), frexpr(bigptr), execerr(char *, ...);
 
480
void setimpl(int, ftnint, int, int), setlog(void), newproc(void);
 
481
void prdbginfo(void), impldcl(struct bigblock *p);
 
482
void putbracket(void), enddcl(void), doequiv(void);
 
483
void puthead(char *), startproc(struct extsym *, int);
 
484
void dclerr(char *s, struct bigblock *v), putforce(int, bigptr);
 
485
void entrypt(int, int, ftnint, struct extsym *, chainp);
 
486
void settype(struct bigblock *, int, int), putlabel(int);
 
487
void putbranch(struct bigblock *p), goret(int), putrbrack(int);
 
488
void prolog(struct entrypoint *, struct bigblock *), prendproc(void);
 
489
void prlocvar(char *, ftnint), prext(char *, ftnint, int);
 
490
void vardcl(struct bigblock *v), frchain(chainp *p); 
 
491
void frtemp(struct bigblock *p), incomm(struct extsym *, struct bigblock *);
 
492
void setintr(struct bigblock * v), setext(struct bigblock * v);
 
493
struct uux { expptr lb, ub; };
 
494
void setbound(struct bigblock *, int, struct uux []);
 
495
void setfmt(struct labelblock *lp), frdata(chainp), frrpl(void),
 
496
        dataval(struct bigblock *, struct bigblock *),
 
497
        consnegop(struct bigblock *p), exdo(int, chainp), exelse(void),
 
498
        exendif(void), exif(bigptr), exelif(bigptr),
 
499
        exequals(struct bigblock *, bigptr),
 
500
        exassign(struct bigblock *, struct labelblock *),
 
501
        exarif(bigptr, struct labelblock *, struct labelblock *,
 
502
            struct labelblock *);
 
503
 
 
504
 
 
505
 
 
506
int intrfunct(char s[VL]), eqn(int, char *, char *);
 
507
int fmtstmt(struct labelblock *lp);
 
508
int cktype(int, int, int);
 
509
int yylex(void), inregister(struct bigblock *);
 
510
int inilex(char *), iocname(void);
 
511
int maxtype(int, int), flog2(ftnint), hextoi(int);
 
512
int cmpstr(char *, char *, ftnint, ftnint);
 
513
int enregister(struct bigblock *np);
 
514
int conssgn(bigptr p);
 
515
int fixargs(int, struct bigblock *);
 
516
int addressable(bigptr p);
 
517
 
 
518
void prlabel(int);
 
519
void prconi(FILE *, int, ftnint);
 
520
void prcona(ftnint);
 
521
void prconr(FILE *, int, double);
 
522
void prarif(bigptr, int, int, int);
 
523
void putstr(char *, ftnint);
 
524
NODE *putex1(bigptr p);
 
525
void puteq(bigptr, bigptr);
 
526
void popstack(chainp *p); 
 
527
void consconv(int, union constant *, int, union constant *);
 
528
void yyerror(char *s);
 
529
void enddo(int);
 
530
void doinclude(char *);
 
531
void flline(void);
 
532
void startioctl(void);
 
533
void endioctl(void), endio(void), ioclause(int, bigptr), doio(chainp);
 
534
void excall(struct bigblock *, struct bigblock *, int, struct labelblock *[]);
 
535
void exreturn(expptr p);
 
536
void exstop(int, expptr);
 
537
void exgoto(struct labelblock *);
 
538
void exasgoto(bigptr);
 
539
void putcmgo(expptr, int, struct labelblock *[]);
 
540
void putexpr(expptr p);
 
541
void putif(expptr, int);
 
542
void putgoto(int);
 
543
void deregister(struct bigblock *np);
 
544
NODE *putx(expptr p);
 
545
void cpn(int, char *, char *);
 
546
void prcmgoto(expptr, int, int, int);
 
547
char *lexline(ftnint *n);
 
548
bigptr suboffset(struct bigblock *p);
 
549
struct bigblock *intraddr(struct bigblock *np);
 
550
struct bigblock *intrcall(bigptr, bigptr, int);
 
551
void setloc(int);
 
552
void prnloc(char *name);
 
553
void fprint(bigptr p, int indx);
 
554
void ckfree(void *p);
 
555
 
 
556
#undef expptr
 
557
#undef tagptr
 
558
 
 
559
#define err1 err
 
560
#define err2 err
 
561
#define warn1 warn
 
562
#define fatal1 fatal