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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
|
/* RCS $Id: struct.h,v 1.2 2006-06-29 11:24:50 ihi Exp $
--
-- SYNOPSIS
-- Structure definitions
--
-- DESCRIPTION
-- dmake main data structure definitions. See each of the individual
-- struct declarations for more detailed information on the defined
-- fields and their use.
--
-- AUTHOR
-- Dennis Vadura, dvadura@dmake.wticorp.com
--
-- WWW
-- http://dmake.wticorp.com/
--
-- COPYRIGHT
-- Copyright (c) 1996,1997 by WTI Corp. All rights reserved.
--
-- This program is NOT free software; you can redistribute it and/or
-- modify it under the terms of the Software License Agreement Provided
-- in the file <distribution-root>/readme/license.txt.
--
-- LOG
-- Use cvs log to obtain detailed change logs.
*/
#ifndef _STRUCT_INCLUDED_
#define _STRUCT_INCLUDED_
typedef uint32 t_attr;
/* The following struct is the cell used in the hash table.
* NOTE: It contains the actual hash value. This allows the hash table
* insertion to compare hash values and to do a string compare only
* for entries that have matching hash_key values. This elliminates
* 99.9999% of all extraneous string compare operations when searching
* a hash table chain for matching entries. */
typedef struct hcell {
struct hcell *ht_next; /* next entry in the hash table */
struct hcell *ht_link; /* for temporary lists */
char *ht_name; /* name of this cell */
char *ht_value; /* cell value if any */
uint32 ht_hash; /* actual hash_key of cell */
int ht_flag; /* flags belonging to hash entry */
/* NOTE: some macros have corresponding variables defined
* that control program behaviour. For these macros a
* bit of ht_flag indicates the variable value will be set, and the
* type of the value that will be set.
*
* The struct below contains a mask for bit variables, and a
* pointer to the global STATIC location for that variable.
* String and char variables point to the same place as ht_value
* and must be updated when ht_value changes, bit variables must
* have their value recomputed. See Def_macro code for more
* details.
*
* NOTE: Macro variables and Targets are always distinct. Thus
* the value union contains pointers back at cells that own
* a particular name entry. A conflict in this can never
* arise, ie pointers at cells will never be used as
* values for a macro variable, since the cell and macro
* name spaces are completely distinct. */
struct {
int mv_mask; /* bit mask for bit variable */
union {
char** mv_svar;/* ptr to string valued glob var */
char* mv_cvar;/* ptr to char valued glob var */
t_attr* mv_bvar;/* ptr to bit valued glob var */
int* mv_ivar;/* ptr to int valued glob var */
struct {
struct tcell* ht_owner;/* ptr to CELL owning name */
struct tcell* ht_root; /* root ptr for explode */
} ht;
} val;
} var; /* variable's static equivalent */
} HASH, *HASHPTR;
#define MV_MASK var.mv_mask
#define MV_SVAR var.val.mv_svar
#define MV_CVAR var.val.mv_cvar
#define MV_BVAR var.val.mv_bvar
#define MV_IVAR var.val.mv_ivar
#define CP_OWNR var.val.ht.ht_owner
#define CP_ROOT var.val.ht.ht_root
/* This struct holds the list of temporary files that have been created.
* It gets unlinked when Quit is called due to an execution error */
typedef struct flst {
char *fl_name; /* file name */
FILE *fl_file; /* the open file */
struct flst *fl_next; /* pointer to next file */
} FILELIST, *FILELISTPTR;
/* The next struct is used to link together prerequisite lists. It
* is also used to link multiple targets together. */
typedef struct lcell {
struct tcell *cl_prq; /* link to a prerequisite */
struct lcell *cl_next; /* next cell on dependency list */
int cl_flag; /* flags for link cell */
} LINK, *LINKPTR;
/* This is the structure of a target cell in the dag which represents the
* graph of dependencies. Each possible target is represented as a cell.
*
* Each cell contains a pointer to the hash table entry for this cell.
* The hash table entry records the name of the cell. */
typedef struct tcell {
struct hcell *ce_name; /* name of this cell */
struct hcell *ce_pushed; /* local pushed macro definitions */
/* Def_cell sets ce_all.cl_prq to point back to itself. .UPDATEALL
* uses ce_all.cl_next to link the cells together. */
struct lcell ce_all;
/* If set it points to first element of the list linked by ce_all. */
struct tcell *ce_set;
struct tcell *ce_setdir; /* SETDIR ROOT pointer for this cell*/
struct tcell *ce_link; /* link for temporary list making */
struct tcell *ce_parent; /* used by inner loop, not a static */
struct lcell *ce_prq; /* list of prerequisites for cell */
struct lcell *ce_prqorg; /* list of original prerequisites */
struct lcell *ce_indprq; /* indirect prerequisites for % cell*/
struct str *ce_recipe; /* recipe for making this cell */
FILELISTPTR ce_files; /* list of temporary files for cell */
struct str *ce_cond; /* conditional macro assignments */
char *ce_per; /* value of % in %-meta expansion */
char *ce_fname; /* file name associated with target */
char *ce_lib; /* archive name, if A_LIBRARYM */
char *ce_dir; /* value for .SETDIR attribute */
int ce_count; /* value for :: recipe set */
int ce_index; /* value of count for next :: child */
int ce_flag; /* all kinds of goodies */
t_attr ce_attr; /* attributes for this target */
time_t ce_time; /* time stamp value of target if any*/
} CELL, *CELLPTR;
#define CE_NAME ce_name->ht_name
#define CE_RECIPE ce_recipe
#define CE_PRQ ce_prq
#define CeMeToo(C) &((C)->ce_all)
#define CeNotMe(C) (C)->ce_all.cl_next
/* This struct represents that used by Get_token to return and control
* access to a token list inside a particular string. This gives the
* ability to access non overlapping tokens simultaneously from
* multiple strings. */
typedef struct {
char *tk_str; /* the string to search for tokens */
char tk_cchar; /* current char under *str */
int tk_quote; /* if we are scanning a quoted str */
} TKSTR, *TKSTRPTR;
/* Below is the struct used to represent a string. It points at possibly
* another string, since the set of rules for making a target is a collection
* of strings. */
typedef struct str {
char *st_string; /* the string value */
struct str *st_next; /* pointer to the next string */
t_attr st_attr; /* attr for rule operations */
} STRING, *STRINGPTR;
/* These structs are used in processing of the % rules, and in building
* the NFA machine that is used to match an arbitrary target string to
* one of the % rules that is represented by each DFA */
typedef int16 statecnt; /* limits the max number of dfa states */
/* Each state of the DFA contains four pieces of information. */
typedef struct st {
struct st *no_match; /* state to go to if no match */
struct st *match; /* state to go to if we do match */
char symbol; /* symbol on which we transit */
char action; /* action to perform if match */
} STATE, *STATEPTR;
/* Each DFA machine looks like this. It must have two pointers that represent
* the value of % in the matched string, and it contains a pointer into the
* current state, as well as the array of all states. */
typedef struct {
char *pstart; /* start of % string match */
char *pend; /* end of % string match */
STATEPTR c_state; /* current DFA state */
CELLPTR node; /* % target represented by this DFA */
STATEPTR states; /* table of states for the DFA */
} DFA, *DFAPTR;
/* An NFA is a collection of DFA's. For each DFA we must know it's current
* state and where the next NFA is. */
typedef struct nfa_machine {
DFAPTR dfa; /* The DFA for this eps transition */
char status; /* DFA state */
struct nfa_machine *next; /* the next DFA in NFA */
} NFA, *NFAPTR;
/* The next struct is used to link together DFA nodes for inference. */
typedef struct dfal {
struct tcell *dl_meta; /* link to %-meta cell */
struct dfal *dl_next; /* next cell on matched DFA list*/
struct dfal *dl_prev; /* prev cell on matched DFA list*/
struct dfal *dl_member; /* used during subset calc */
char dl_delete; /* used during subset calc */
char *dl_per; /* value of % for matched DFA */
statecnt dl_state; /* matched state of the DFA */
int dl_prep; /* repetion count for the cell */
} DFALINK, *DFALINKPTR;
/* This struct is used to store the stack of DFA sets during inference */
typedef struct dfst {
DFALINKPTR df_set; /* pointer to the set */
struct dfst *df_next; /* next element in the stack */
} DFASET, *DFASETPTR;
/* We need sets of items during inference, here is the item, we form sets
* by linking them together. */
typedef struct ic {
CELLPTR ic_meta; /* Edge we used to make this cell*/
DFALINKPTR ic_dfa; /* Dfa that we matched against */
CELLPTR ic_setdirroot; /* setdir root pointer for cell */
DFASET ic_dfastack; /* set of dfas we're working with*/
int ic_dmax; /* max depth of cycles in graph */
char *ic_name; /* name of the cell to insert */
char *ic_dir; /* dir to CD to prior to recurse */
struct ic *ic_next; /* next pointer to link */
struct ic *ic_link; /* link all ICELL'S together */
struct ic *ic_parent; /* pointer to post-requisite */
char ic_flag; /* flag, used for NOINFER only */
char ic_exists; /* TRUE if prerequisite exists */
} ICELL, *ICELLPTR;
#endif
|
