1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2003 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * rep.c 28 * 29 * This file handles the .nse_depinfo file 30 */ 31 32 /* 33 * Included files 34 */ 35 #include <mk/defs.h> 36 #include <mksh/misc.h> /* retmem() */ 37 #include <vroot/report.h> /* NSE_DEPINFO */ 38 39 /* 40 * Static variables 41 */ 42 static Recursive_make recursive_list; 43 static Recursive_make *bpatch = &recursive_list; 44 static Boolean changed; 45 46 /* 47 * File table of contents 48 */ 49 50 51 /* 52 * report_recursive_init() 53 * 54 * Read the .nse_depinfo file and make a list of all the 55 * .RECURSIVE entries. 56 * 57 * Parameters: 58 * 59 * Static variables used: 60 * bpatch Points to slot where next cell should be added 61 * 62 * Global variables used: 63 * recursive_name The Name ".RECURSIVE", compared against 64 */ 65 66 void 67 report_recursive_init(void) 68 { 69 char *search_dir; 70 char nse_depinfo[MAXPATHLEN]; 71 FILE *fp; 72 int line_size, line_index; 73 wchar_t *line; 74 wchar_t *bigger_line; 75 wchar_t *colon; 76 wchar_t *dollar; 77 Recursive_make rp; 78 79 /* 80 * This routine can be called more than once, don't do 81 * anything after the first time. 82 */ 83 if (depinfo_already_read) { 84 return; 85 } else { 86 depinfo_already_read = true; 87 } 88 89 search_dir = getenv("NSE_DEP"); 90 if (search_dir == NULL) { 91 return; 92 } 93 (void) sprintf(nse_depinfo, "%s/%s", search_dir, NSE_DEPINFO); 94 fp = fopen(nse_depinfo, "r"); 95 if (fp == NULL) { 96 return; 97 } 98 line_size = MAXPATHLEN; 99 line_index = line_size - 1; 100 line = ALLOC_WC(line_size); 101 Wstring rns(recursive_name); 102 wchar_t * wcb = rns.get_string(); 103 while (fgetws(line, line_size, fp) != NULL) { 104 while (wcslen(line) == line_index) { 105 if (line[wcslen(line) - 1] == '\n') { 106 continue; 107 } 108 bigger_line = ALLOC_WC(2 * line_size); 109 wcscpy(bigger_line, line); 110 retmem(line); 111 line = bigger_line; 112 if (fgetws(&line[line_index], line_size, fp) == NULL) 113 continue; 114 line_index = 2 * line_index; 115 line_size = 2 * line_size; 116 } 117 118 colon = (wchar_t *) wcschr(line, (int) colon_char); 119 if (colon == NULL) { 120 continue; 121 } 122 dollar = (wchar_t *) wcschr(line, (int) dollar_char); 123 line[wcslen(line) - 1] = (int) nul_char; 124 if (IS_WEQUALN(&colon[2], wcb, 125 (int) recursive_name->hash.length)) { 126 /* 127 * If this entry is an old entry, ignore it 128 */ 129 MBSTOWCS(wcs_buffer, DEPINFO_FMT_VERSION); 130 if (dollar == NULL || 131 !IS_WEQUALN(wcs_buffer, (dollar+1) - VER_LEN, VER_LEN)){ 132 continue; 133 } 134 rp = ALLOC(Recursive_make); 135 (void) memset((char *) rp, 0, sizeof (Recursive_make_rec)); 136 /* 137 * set conditional_macro_string if string is present 138 */ 139 rp->oldline = (wchar_t *) wcsdup(line); 140 if ( dollar != NULL ){ 141 rp->cond_macrostring = 142 (wchar_t *) wcsdup(dollar - VER_LEN + 1); 143 } 144 /* 145 * get target name into recursive struct 146 */ 147 *colon = (int) nul_char; 148 rp->target = (wchar_t *) wcsdup(line); 149 *bpatch = rp; 150 bpatch = &rp->next; 151 } 152 } 153 (void) fclose(fp); 154 } 155 156 /* 157 * report_recursive_dep(target, line) 158 * 159 * Report a target as recursive. 160 * 161 * Parameters: 162 * line Dependency line reported 163 * 164 * Static variables used: 165 * bpatch Points to slot where next cell should be added 166 * changed Written if report set changed 167 */ 168 void 169 report_recursive_dep(Name target, wchar_t *line) 170 { 171 Recursive_make rp; 172 wchar_t rec_buf[STRING_BUFFER_LENGTH]; 173 String_rec string; 174 175 INIT_STRING_FROM_STACK(string, rec_buf); 176 cond_macros_into_string(target, &string); 177 /* 178 * find an applicable recursive entry, if there isn't one, create it 179 */ 180 rp = find_recursive_target(target); 181 if (rp == NULL) { 182 rp = ALLOC(Recursive_make); 183 (void) memset((char *) rp, 0, sizeof (Recursive_make_rec)); 184 wchar_t * wcb = get_wstring(target->string_mb); // XXX Tolik: needs retmem 185 rp->target = wcb; 186 rp->newline = (wchar_t *) wcsdup(line); 187 rp->cond_macrostring = (wchar_t *) wcsdup(rec_buf); 188 *bpatch = rp; 189 bpatch = &rp->next; 190 changed = true; 191 } else { 192 if ((rp->oldline != NULL) && !IS_WEQUAL(rp->oldline, line)) { 193 rp->newline = (wchar_t *) wcsdup(line); 194 changed = true; 195 } 196 rp->removed = false; 197 } 198 } 199 200 /* 201 * find_recursive_target(target) 202 * 203 * Search the list for a given target. 204 * 205 * Return value: 206 * The target cell 207 * 208 * Parameters: 209 * target The target we need 210 * top_level_target more info used to determinde the 211 * target we need 212 * 213 * Static variables used: 214 * recursive_list The list of targets 215 */ 216 Recursive_make 217 find_recursive_target(Name target) 218 { 219 Recursive_make rp; 220 String_rec string; 221 wchar_t rec_buf[STRING_BUFFER_LENGTH]; 222 223 INIT_STRING_FROM_STACK(string, rec_buf); 224 cond_macros_into_string(target, &string); 225 226 Wstring tstr(target); 227 wchar_t * wcb = tstr.get_string(); 228 for (rp = recursive_list; rp != NULL; rp = rp->next) { 229 /* 230 * If this entry has already been removed, ignore it. 231 */ 232 if (rp->removed) 233 continue; 234 /* 235 * If this target, and the target on the list are the same 236 * and if one of them contains conditional macro info, while 237 * the other doesn't, remove this entry from the list of 238 * recursive entries. This can only happen if the Makefile 239 * has changed to no longer contain conditional macros. 240 */ 241 if (IS_WEQUAL(rp->target, wcb)) { 242 if (rp->cond_macrostring[VER_LEN] == '\0' && 243 string.buffer.start[VER_LEN] != '\0'){ 244 rp->removed = true; 245 continue; 246 } else if (rp->cond_macrostring[VER_LEN] != '\0' && 247 string.buffer.start[VER_LEN] == '\0'){ 248 rp->removed = true; 249 continue; 250 } 251 } 252 /* 253 * If this is not a VERS2 entry, only need to match 254 * the target name. toptarg information from VERS1 entries 255 * are ignored. 256 */ 257 MBSTOWCS(wcs_buffer, DEPINFO_FMT_VERSION); 258 if (IS_WEQUALN(wcs_buffer, string.buffer.start, VER_LEN)) { 259 if (IS_WEQUAL(rp->cond_macrostring, 260 string.buffer.start) && 261 IS_WEQUAL(rp->target, wcb)) { 262 return rp; 263 } 264 } else { 265 if (IS_WEQUAL(rp->target, wcb)) { 266 return rp; 267 } 268 } 269 } 270 return NULL; 271 } 272 273 /* 274 * remove_recursive_dep(target, top_level_target) 275 * 276 * Mark a target as no longer recursive. 277 * 278 * Parameters: 279 * target The target we want to remove 280 * top_level_target target we want to remove must be built from 281 * the same top level target 282 * 283 * Static variables used: 284 * changed Written if report set changed 285 */ 286 void 287 remove_recursive_dep(Name target) 288 { 289 Recursive_make rp; 290 291 rp = find_recursive_target(target); 292 293 if ( rp != NULL ) { 294 rp->removed = true; 295 changed = true; 296 if(rp->target) { 297 retmem(rp->target); 298 rp->target = NULL; 299 } 300 if(rp->newline) { 301 retmem(rp->newline); 302 rp->newline = NULL; 303 } 304 if(rp->oldline) { 305 retmem(rp->oldline); 306 rp->oldline = NULL; 307 } 308 if(rp->cond_macrostring) { 309 retmem(rp->cond_macrostring); 310 rp->cond_macrostring = NULL; 311 } 312 } 313 } 314 315 316 /* gather_recursive_deps() 317 * 318 * Create or update list of recursive targets. 319 */ 320 void 321 gather_recursive_deps(void) 322 { 323 Name_set::iterator np, e; 324 String_rec rec; 325 wchar_t rec_buf[STRING_BUFFER_LENGTH]; 326 register Property lines; 327 Boolean has_recursive; 328 Dependency dp; 329 330 report_recursive_init(); 331 332 /* Go thru all targets and dump recursive dependencies */ 333 for (np = hashtab.begin(), e = hashtab.end(); np != e; np++) { 334 if (np->has_recursive_dependency){ 335 has_recursive = false; 336 /* 337 * start .RECURSIVE line with target: 338 */ 339 INIT_STRING_FROM_STACK(rec, rec_buf); 340 APPEND_NAME(np, &rec, FIND_LENGTH); 341 append_char((int) colon_char, &rec); 342 append_char((int) space_char, &rec); 343 344 for (lines = get_prop(np->prop,recursive_prop); 345 lines != NULL; 346 lines = get_prop(lines->next, recursive_prop)) { 347 /* 348 * if entry is already in depinfo 349 * file or entry was not built, ignore it 350 */ 351 if (lines->body.recursive.in_depinfo) 352 continue; 353 if (!lines->body.recursive.has_built) 354 continue; 355 has_recursive = true; 356 lines->body.recursive.in_depinfo=true; 357 358 /* 359 * Write the remainder of the 360 * .RECURSIVE line 361 */ 362 APPEND_NAME(recursive_name, &rec, 363 FIND_LENGTH); 364 append_char((int) space_char, &rec); 365 APPEND_NAME(lines->body.recursive.directory, 366 &rec, FIND_LENGTH); 367 append_char((int) space_char, &rec); 368 APPEND_NAME(lines->body.recursive.target, 369 &rec, FIND_LENGTH); 370 append_char((int) space_char, &rec); 371 372 /* Complete list of makefiles used */ 373 for (dp = lines->body.recursive.makefiles; 374 dp != NULL; 375 dp = dp->next) { 376 APPEND_NAME(dp->name, &rec, FIND_LENGTH); 377 append_char((int) space_char, &rec); 378 } 379 } 380 /* 381 * dump list of conditional targets, 382 * and report recursive entry, if needed 383 */ 384 cond_macros_into_string(np, &rec); 385 if (has_recursive){ 386 report_recursive_dep(np, rec.buffer.start); 387 } 388 389 } else if ( np->has_built ) { 390 remove_recursive_dep(np); 391 } 392 } 393 } 394 395