1 /* RCS $Id: struct.h,v 1.2 2006-06-29 11:24:50 ihi Exp $ 2 -- 3 -- SYNOPSIS 4 -- Structure definitions 5 -- 6 -- DESCRIPTION 7 -- dmake main data structure definitions. See each of the individual 8 -- struct declarations for more detailed information on the defined 9 -- fields and their use. 10 -- 11 -- AUTHOR 12 -- Dennis Vadura, dvadura@dmake.wticorp.com 13 -- 14 -- WWW 15 -- http://dmake.wticorp.com/ 16 -- 17 -- COPYRIGHT 18 -- Copyright (c) 1996,1997 by WTI Corp. All rights reserved. 19 -- 20 -- This program is NOT free software; you can redistribute it and/or 21 -- modify it under the terms of the Software License Agreement Provided 22 -- in the file <distribution-root>/COPYING. 23 -- 24 -- LOG 25 -- Use cvs log to obtain detailed change logs. 26 */ 27 28 #ifndef _STRUCT_INCLUDED_ 29 #define _STRUCT_INCLUDED_ 30 31 typedef uint32 t_attr; 32 33 /* The following struct is the cell used in the hash table. 34 * NOTE: It contains the actual hash value. This allows the hash table 35 * insertion to compare hash values and to do a string compare only 36 * for entries that have matching hash_key values. This elliminates 37 * 99.9999% of all extraneous string compare operations when searching 38 * a hash table chain for matching entries. */ 39 40 typedef struct hcell { 41 struct hcell *ht_next; /* next entry in the hash table */ 42 struct hcell *ht_link; /* for temporary lists */ 43 char *ht_name; /* name of this cell */ 44 char *ht_value; /* cell value if any */ 45 uint32 ht_hash; /* actual hash_key of cell */ 46 int ht_flag; /* flags belonging to hash entry */ 47 48 /* NOTE: some macros have corresponding variables defined 49 * that control program behaviour. For these macros a 50 * bit of ht_flag indicates the variable value will be set, and the 51 * type of the value that will be set. 52 * 53 * The struct below contains a mask for bit variables, and a 54 * pointer to the global STATIC location for that variable. 55 * String and char variables point to the same place as ht_value 56 * and must be updated when ht_value changes, bit variables must 57 * have their value recomputed. See Def_macro code for more 58 * details. 59 * 60 * NOTE: Macro variables and Targets are always distinct. Thus 61 * the value union contains pointers back at cells that own 62 * a particular name entry. A conflict in this can never 63 * arise, ie pointers at cells will never be used as 64 * values for a macro variable, since the cell and macro 65 * name spaces are completely distinct. */ 66 67 struct { 68 int mv_mask; /* bit mask for bit variable */ 69 union { 70 char** mv_svar;/* ptr to string valued glob var */ 71 char* mv_cvar;/* ptr to char valued glob var */ 72 t_attr* mv_bvar;/* ptr to bit valued glob var */ 73 int* mv_ivar;/* ptr to int valued glob var */ 74 75 struct { 76 struct tcell* ht_owner;/* ptr to CELL owning name */ 77 struct tcell* ht_root; /* root ptr for explode */ 78 } ht; 79 } val; 80 } var; /* variable's static equivalent */ 81 } HASH, *HASHPTR; 82 83 #define MV_MASK var.mv_mask 84 #define MV_SVAR var.val.mv_svar 85 #define MV_CVAR var.val.mv_cvar 86 #define MV_BVAR var.val.mv_bvar 87 #define MV_IVAR var.val.mv_ivar 88 #define CP_OWNR var.val.ht.ht_owner 89 #define CP_ROOT var.val.ht.ht_root 90 91 92 93 /* This struct holds the list of temporary files that have been created. 94 * It gets unlinked when Quit is called due to an execution error */ 95 typedef struct flst { 96 char *fl_name; /* file name */ 97 FILE *fl_file; /* the open file */ 98 struct flst *fl_next; /* pointer to next file */ 99 } FILELIST, *FILELISTPTR; 100 101 102 /* The next struct is used to link together prerequisite lists. It 103 * is also used to link multiple targets together. */ 104 typedef struct lcell { 105 struct tcell *cl_prq; /* link to a prerequisite */ 106 struct lcell *cl_next; /* next cell on dependency list */ 107 int cl_flag; /* flags for link cell */ 108 } LINK, *LINKPTR; 109 110 111 /* This is the structure of a target cell in the dag which represents the 112 * graph of dependencies. Each possible target is represented as a cell. 113 * 114 * Each cell contains a pointer to the hash table entry for this cell. 115 * The hash table entry records the name of the cell. */ 116 117 typedef struct tcell { 118 struct hcell *ce_name; /* name of this cell */ 119 struct hcell *ce_pushed; /* local pushed macro definitions */ 120 121 /* Def_cell sets ce_all.cl_prq to point back to itself. .UPDATEALL 122 * uses ce_all.cl_next to link the cells together. */ 123 struct lcell ce_all; 124 125 /* If set it points to first element of the list linked by ce_all. */ 126 struct tcell *ce_set; 127 struct tcell *ce_setdir; /* SETDIR ROOT pointer for this cell*/ 128 struct tcell *ce_link; /* link for temporary list making */ 129 struct tcell *ce_parent; /* used by inner loop, not a static */ 130 131 struct lcell *ce_prq; /* list of prerequisites for cell */ 132 struct lcell *ce_prqorg; /* list of original prerequisites */ 133 struct lcell *ce_indprq; /* indirect prerequisites for % cell*/ 134 135 struct str *ce_recipe; /* recipe for making this cell */ 136 FILELISTPTR ce_files; /* list of temporary files for cell */ 137 struct str *ce_cond; /* conditional macro assignments */ 138 139 char *ce_per; /* value of % in %-meta expansion */ 140 char *ce_fname; /* file name associated with target */ 141 char *ce_lib; /* archive name, if A_LIBRARYM */ 142 char *ce_dir; /* value for .SETDIR attribute */ 143 144 int ce_count; /* value for :: recipe set */ 145 int ce_index; /* value of count for next :: child */ 146 int ce_flag; /* all kinds of goodies */ 147 t_attr ce_attr; /* attributes for this target */ 148 time_t ce_time; /* time stamp value of target if any*/ 149 } CELL, *CELLPTR; 150 151 #define CE_NAME ce_name->ht_name 152 #define CE_RECIPE ce_recipe 153 #define CE_PRQ ce_prq 154 #define CeMeToo(C) &((C)->ce_all) 155 #define CeNotMe(C) (C)->ce_all.cl_next 156 157 158 /* This struct represents that used by Get_token to return and control 159 * access to a token list inside a particular string. This gives the 160 * ability to access non overlapping tokens simultaneously from 161 * multiple strings. */ 162 163 typedef struct { 164 char *tk_str; /* the string to search for tokens */ 165 char tk_cchar; /* current char under *str */ 166 int tk_quote; /* if we are scanning a quoted str */ 167 } TKSTR, *TKSTRPTR; 168 169 170 171 /* Below is the struct used to represent a string. It points at possibly 172 * another string, since the set of rules for making a target is a collection 173 * of strings. */ 174 175 176 typedef struct str { 177 char *st_string; /* the string value */ 178 struct str *st_next; /* pointer to the next string */ 179 t_attr st_attr; /* attr for rule operations */ 180 } STRING, *STRINGPTR; 181 182 183 184 /* These structs are used in processing of the % rules, and in building 185 * the NFA machine that is used to match an arbitrary target string to 186 * one of the % rules that is represented by each DFA */ 187 188 typedef int16 statecnt; /* limits the max number of dfa states */ 189 190 191 /* Each state of the DFA contains four pieces of information. */ 192 typedef struct st { 193 struct st *no_match; /* state to go to if no match */ 194 struct st *match; /* state to go to if we do match */ 195 char symbol; /* symbol on which we transit */ 196 char action; /* action to perform if match */ 197 } STATE, *STATEPTR; 198 199 200 /* Each DFA machine looks like this. It must have two pointers that represent 201 * the value of % in the matched string, and it contains a pointer into the 202 * current state, as well as the array of all states. */ 203 typedef struct { 204 char *pstart; /* start of % string match */ 205 char *pend; /* end of % string match */ 206 STATEPTR c_state; /* current DFA state */ 207 CELLPTR node; /* % target represented by this DFA */ 208 STATEPTR states; /* table of states for the DFA */ 209 } DFA, *DFAPTR; 210 211 212 /* An NFA is a collection of DFA's. For each DFA we must know it's current 213 * state and where the next NFA is. */ 214 typedef struct nfa_machine { 215 DFAPTR dfa; /* The DFA for this eps transition */ 216 char status; /* DFA state */ 217 struct nfa_machine *next; /* the next DFA in NFA */ 218 } NFA, *NFAPTR; 219 220 221 222 /* The next struct is used to link together DFA nodes for inference. */ 223 224 typedef struct dfal { 225 struct tcell *dl_meta; /* link to %-meta cell */ 226 struct dfal *dl_next; /* next cell on matched DFA list*/ 227 struct dfal *dl_prev; /* prev cell on matched DFA list*/ 228 struct dfal *dl_member; /* used during subset calc */ 229 char dl_delete; /* used during subset calc */ 230 char *dl_per; /* value of % for matched DFA */ 231 statecnt dl_state; /* matched state of the DFA */ 232 int dl_prep; /* repetion count for the cell */ 233 } DFALINK, *DFALINKPTR; 234 235 236 /* This struct is used to store the stack of DFA sets during inference */ 237 typedef struct dfst { 238 DFALINKPTR df_set; /* pointer to the set */ 239 struct dfst *df_next; /* next element in the stack */ 240 } DFASET, *DFASETPTR; 241 242 243 /* We need sets of items during inference, here is the item, we form sets 244 * by linking them together. */ 245 246 typedef struct ic { 247 CELLPTR ic_meta; /* Edge we used to make this cell*/ 248 DFALINKPTR ic_dfa; /* Dfa that we matched against */ 249 CELLPTR ic_setdirroot; /* setdir root pointer for cell */ 250 DFASET ic_dfastack; /* set of dfas we're working with*/ 251 int ic_dmax; /* max depth of cycles in graph */ 252 char *ic_name; /* name of the cell to insert */ 253 char *ic_dir; /* dir to CD to prior to recurse */ 254 struct ic *ic_next; /* next pointer to link */ 255 struct ic *ic_link; /* link all ICELL'S together */ 256 struct ic *ic_parent; /* pointer to post-requisite */ 257 char ic_flag; /* flag, used for NOINFER only */ 258 char ic_exists; /* TRUE if prerequisite exists */ 259 } ICELL, *ICELLPTR; 260 261 #endif 262