1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
#include "../preproc/preproc.h"
#include "../preproc/pproto.h"
#define IndentInc 3
#define MaxCol 80
#define Max(x,y) ((x)>(y)?(x):(y))
/*
* cfile is used to create a list of cfiles created from a source file.
*/
struct cfile {
char *name;
struct cfile *next;
};
/*
* srcfile is an entry of dependants of a source file.
*/
struct srcfile {
char *name;
struct cfile *dependents;
struct srcfile *next;
};
#define ForceNl() nl = 1;
extern int nl; /* flag: a new-line is needed in the output */
/*
* The lexical analyzer recognizes 3 states. Operators are treated differently
* in each state.
*/
#define DfltLex 0 /* Covers most input. */
#define OpHead 1 /* In head of an operator definition. */
#define TypeComp 2 /* In abstract type computation */
extern int lex_state; /* state of operator recognition */
extern char *compiler_def; /* #define for COMPILER */
extern FILE *out_file; /* output file */
extern int def_fnd; /* C input defines something concrete */
extern char *inclname; /* include file to be included by C compiler */
extern int iconx_flg; /* flag: indicate that iconx style code is needed */
extern int enable_out; /* enable output of C code */
extern char *largeints; /* "Largeints" or "NoLargeInts" */
/*
* The symbol table is used by the lexical analyser to decide whether an
* identifier is an ordinary identifier, a typedef name, or a reserved
* word. It is used by the parse tree builder to decide whether an
* identifier is an ordinary C variable, a tended variable, a parameter
* to a run-time routine, or the special variable "result".
*/
struct sym_entry {
int tok_id; /* Ident, TokType, or identification of reserved word */
char *image; /* image of symbol */
int id_type; /* OtherDcl, TndDesc, TndStr, TndBlk, Label, RtParm,
DrfPrm, RsltLoc */
union {
struct { /* RtParm: */
int param_num; /* parameter number */
int cur_loc; /* PrmTend, PrmCStr, PrmInt, or PrmDbl */
int non_tend; /* non-tended locations used */
int parm_mod; /* something may have modified it */
struct sym_entry *next;
} param_info;
struct { /* TndDesc, TndStr, TndBlk: */
struct node *init; /* initial value from declaration */
char *blk_name; /* TndBlk: struct name of block */
struct sym_entry *next;
} tnd_var;
struct { /* OtherDcl from "declare {...}": */
struct node *tqual; /* storage class, type qualifier list */
struct node *dcltor; /* declarator */
struct node *init; /* initial value from declaration */
struct sym_entry *next;
} declare_var;
int typ_indx; /* index into arrays of type information */
word lbl_num; /* label number used in in-line code */
int referenced; /* RsltLoc: is referenced */
} u;
int t_indx; /* index into tended array */
int il_indx; /* index used in in-line code */
int nest_lvl; /* 0 - reserved word, 1 - global, >= 2 - local */
int may_mod; /* may be modified in particular piece of code */
int ref_cnt;
struct sym_entry *next;
};
/*
* Path-specific parameter information must be saved and merged for
* branching and joining of paths.
*/
struct parminfo {
int cur_loc;
int parm_mod;
};
/*
* A list is maintained of information needed to initialize tended descriptors.
*/
struct init_tend {
int t_indx; /* index into tended array */
int init_typ; /* TndDesc, TndStr, TndBlk */
struct node *init; /* initial value from declaration */
int nest_lvl; /* level of nesting of current use of tended slot */
int in_use; /* tended slot is being used in current scope */
struct init_tend *next;
};
extern int op_type; /* Function, Keyword, Operator, or OrdFunc */
extern char lc_letter; /* f = function, o = operator, k = keyword */
extern char uc_letter; /* F = function, O = operator, K = keyword */
extern char prfx1; /* 1st char of unique prefix for operation */
extern char prfx2; /* 2nd char of unique prefix for operation */
extern char *fname; /* current source file name */
extern int line; /* current source line number */
extern struct implement *cur_impl; /* data base entry for current operator */
extern struct token *comment; /* descriptive comment for current oper */
extern int n_tmp_str; /* total number of string buffers needed */
extern int n_tmp_cset; /* total number of cset buffers needed */
extern int nxt_sbuf; /* index of next string buffer */
extern int nxt_cbuf; /* index of next cset buffer */
extern struct sym_entry *params; /* current list of parameters */
extern struct sym_entry *decl_lst; /* declarations from "declare {...}" */
extern struct init_tend *tend_lst; /* list of allocated tended slots */
extern char *str_rslt; /* string "result" in string table */
extern word lbl_num; /* next unused label number */
extern struct sym_entry *v_len; /* symbol entry for size of varargs */
extern int il_indx; /* next index into data base symbol table */
/*
* lvl_entry keeps track of what is happening at a level of nested declarations.
*/
struct lvl_entry {
int nest_lvl;
int kind_dcl; /* IsTypedef, TndDesc, TndStr, TndBlk, or OtherDcl */
char *blk_name; /* for TndBlk, the struct name of the block */
int parms_done; /* level consists of parameter list which is complete */
struct sym_entry *tended; /* symbol table entries for tended variables */
struct lvl_entry *next;
};
extern struct lvl_entry *dcl_stk; /* stack of declaration contexts */
extern int fnc_ret; /* RetInt, RetDbl, RetNoVal, or RetSig for current func */
#define NoAbstr -1001 /* no abstract return statement has been encountered */
#define SomeType -1002 /* assume returned value is consistent with abstr ret */
extern int abs_ret; /* type from abstract return statement */
/*
* Definitions for use in parse tree nodes.
*/
#define PrimryNd 1 /* simply a token */
#define PrefxNd 2 /* a prefix expression */
#define PstfxNd 3 /* a postfix expression */
#define BinryNd 4 /* a binary expression (not necessarily infix) */
#define TrnryNd 5 /* an expression with 3 subexpressions */
#define QuadNd 6 /* an expression with 4 subexpressions */
#define LstNd 7 /* list of declaration parts */
#define CommaNd 8 /* arg lst, declarator lst, or init lst, not comma op */
#define StrDclNd 9 /* structure field declaration */
#define PreSpcNd 10 /* prefix expression that needs a space after it */
#define ConCatNd 11 /* two ajacent pieces of code with no other syntax */
#define SymNd 12 /* a symbol (identifier) node */
#define ExactCnv 13 /* (exact)integer or (exact)C_integer conversion */
#define CompNd 14 /* compound statement */
#define AbstrNd 15 /* abstract type computation */
#define IcnTypNd 16 /* name of an Icon type */
#define NewNode(size) (struct node *)alloc(\
sizeof(struct node) + (size-1) * sizeof(union field))
union field {
struct node *child;
struct sym_entry *sym; /* used with SymNd & CompNd*/
};
struct node {
int nd_id;
struct token *tok;
union field u[1]; /* actual size varies with node type */
};
#include "rttproto.h"
|
