397 lines
9.4 KiB
C++
397 lines
9.4 KiB
C++
/*
|
|
* CDDL HEADER START
|
|
*
|
|
* The contents of this file are subject to the terms of the
|
|
* Common Development and Distribution License (the "License").
|
|
* You may not use this file except in compliance with the License.
|
|
*
|
|
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
|
* or http://www.opensolaris.org/os/licensing.
|
|
* See the License for the specific language governing permissions
|
|
* and limitations under the License.
|
|
*
|
|
* When distributing Covered Code, include this CDDL HEADER in each
|
|
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
|
* If applicable, add the following below this CDDL HEADER, with the
|
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
|
* information: Portions Copyright [yyyy] [name of copyright owner]
|
|
*
|
|
* CDDL HEADER END
|
|
*/
|
|
/*
|
|
* Copyright 2003 Sun Microsystems, Inc. All rights reserved.
|
|
* Use is subject to license terms.
|
|
*/
|
|
|
|
/*
|
|
* rep.c
|
|
*
|
|
* This file handles the .nse_depinfo file
|
|
*/
|
|
|
|
/*
|
|
* Included files
|
|
*/
|
|
#include <mk/defs.h>
|
|
#include <mksh/misc.h> /* retmem() */
|
|
#include <vroot/report.h> /* NSE_DEPINFO */
|
|
|
|
#include <comp/wcsdup.h>
|
|
|
|
/*
|
|
* Static variables
|
|
*/
|
|
static Recursive_make recursive_list;
|
|
static Recursive_make *bpatch = &recursive_list;
|
|
static Boolean changed;
|
|
|
|
/*
|
|
* File table of contents
|
|
*/
|
|
|
|
|
|
/*
|
|
* report_recursive_init()
|
|
*
|
|
* Read the .nse_depinfo file and make a list of all the
|
|
* .RECURSIVE entries.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* Static variables used:
|
|
* bpatch Points to slot where next cell should be added
|
|
*
|
|
* Global variables used:
|
|
* recursive_name The Name ".RECURSIVE", compared against
|
|
*/
|
|
|
|
void
|
|
report_recursive_init(void)
|
|
{
|
|
char *search_dir;
|
|
char nse_depinfo[MAXPATHLEN];
|
|
FILE *fp;
|
|
int line_size, line_index;
|
|
wchar_t *line;
|
|
wchar_t *bigger_line;
|
|
wchar_t *colon;
|
|
wchar_t *dollar;
|
|
Recursive_make rp;
|
|
|
|
/*
|
|
* This routine can be called more than once, don't do
|
|
* anything after the first time.
|
|
*/
|
|
if (depinfo_already_read) {
|
|
return;
|
|
} else {
|
|
depinfo_already_read = true;
|
|
}
|
|
|
|
search_dir = getenv("NSE_DEP");
|
|
if (search_dir == NULL) {
|
|
return;
|
|
}
|
|
(void) sprintf(nse_depinfo, "%s/%s", search_dir, NSE_DEPINFO);
|
|
fp = fopen(nse_depinfo, "r");
|
|
if (fp == NULL) {
|
|
return;
|
|
}
|
|
line_size = MAXPATHLEN;
|
|
line_index = line_size - 1;
|
|
line = ALLOC_WC(line_size);
|
|
Wstring rns(recursive_name);
|
|
wchar_t * wcb = rns.get_string();
|
|
while (fgetws(line, line_size, fp) != NULL) {
|
|
while (wcslen(line) == line_index) {
|
|
if (line[wcslen(line) - 1] == '\n') {
|
|
continue;
|
|
}
|
|
bigger_line = ALLOC_WC(2 * line_size);
|
|
wcscpy(bigger_line, line);
|
|
retmem(line);
|
|
line = bigger_line;
|
|
if (fgetws(&line[line_index], line_size, fp) == NULL)
|
|
continue;
|
|
line_index = 2 * line_index;
|
|
line_size = 2 * line_size;
|
|
}
|
|
|
|
colon = (wchar_t *) wcschr(line, (int) colon_char);
|
|
if (colon == NULL) {
|
|
continue;
|
|
}
|
|
dollar = (wchar_t *) wcschr(line, (int) dollar_char);
|
|
line[wcslen(line) - 1] = (int) nul_char;
|
|
if (IS_WEQUALN(&colon[2], wcb,
|
|
(int) recursive_name->hash.length)) {
|
|
/*
|
|
* If this entry is an old entry, ignore it
|
|
*/
|
|
MBSTOWCS(wcs_buffer, DEPINFO_FMT_VERSION);
|
|
if (dollar == NULL ||
|
|
!IS_WEQUALN(wcs_buffer, (dollar+1) - VER_LEN, VER_LEN)){
|
|
continue;
|
|
}
|
|
rp = ALLOC(Recursive_make);
|
|
(void) memset((char *) rp, 0, sizeof (Recursive_make_rec));
|
|
/*
|
|
* set conditional_macro_string if string is present
|
|
*/
|
|
rp->oldline = (wchar_t *) wcsdup(line);
|
|
if ( dollar != NULL ){
|
|
rp->cond_macrostring =
|
|
(wchar_t *) wcsdup(dollar - VER_LEN + 1);
|
|
}
|
|
/*
|
|
* get target name into recursive struct
|
|
*/
|
|
*colon = (int) nul_char;
|
|
rp->target = (wchar_t *) wcsdup(line);
|
|
*bpatch = rp;
|
|
bpatch = &rp->next;
|
|
}
|
|
}
|
|
(void) fclose(fp);
|
|
}
|
|
|
|
/*
|
|
* report_recursive_dep(target, line)
|
|
*
|
|
* Report a target as recursive.
|
|
*
|
|
* Parameters:
|
|
* line Dependency line reported
|
|
*
|
|
* Static variables used:
|
|
* bpatch Points to slot where next cell should be added
|
|
* changed Written if report set changed
|
|
*/
|
|
void
|
|
report_recursive_dep(Name target, wchar_t *line)
|
|
{
|
|
Recursive_make rp;
|
|
wchar_t rec_buf[STRING_BUFFER_LENGTH];
|
|
String_rec string;
|
|
|
|
INIT_STRING_FROM_STACK(string, rec_buf);
|
|
cond_macros_into_string(target, &string);
|
|
/*
|
|
* find an applicable recursive entry, if there isn't one, create it
|
|
*/
|
|
rp = find_recursive_target(target);
|
|
if (rp == NULL) {
|
|
rp = ALLOC(Recursive_make);
|
|
(void) memset((char *) rp, 0, sizeof (Recursive_make_rec));
|
|
wchar_t * wcb = get_wstring(target->string_mb); // XXX Tolik: needs retmem
|
|
rp->target = wcb;
|
|
rp->newline = (wchar_t *) wcsdup(line);
|
|
rp->cond_macrostring = (wchar_t *) wcsdup(rec_buf);
|
|
*bpatch = rp;
|
|
bpatch = &rp->next;
|
|
changed = true;
|
|
} else {
|
|
if ((rp->oldline != NULL) && !IS_WEQUAL(rp->oldline, line)) {
|
|
rp->newline = (wchar_t *) wcsdup(line);
|
|
changed = true;
|
|
}
|
|
rp->removed = false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* find_recursive_target(target)
|
|
*
|
|
* Search the list for a given target.
|
|
*
|
|
* Return value:
|
|
* The target cell
|
|
*
|
|
* Parameters:
|
|
* target The target we need
|
|
* top_level_target more info used to determinde the
|
|
* target we need
|
|
*
|
|
* Static variables used:
|
|
* recursive_list The list of targets
|
|
*/
|
|
Recursive_make
|
|
find_recursive_target(Name target)
|
|
{
|
|
Recursive_make rp;
|
|
String_rec string;
|
|
wchar_t rec_buf[STRING_BUFFER_LENGTH];
|
|
|
|
INIT_STRING_FROM_STACK(string, rec_buf);
|
|
cond_macros_into_string(target, &string);
|
|
|
|
Wstring tstr(target);
|
|
wchar_t * wcb = tstr.get_string();
|
|
for (rp = recursive_list; rp != NULL; rp = rp->next) {
|
|
/*
|
|
* If this entry has already been removed, ignore it.
|
|
*/
|
|
if (rp->removed)
|
|
continue;
|
|
/*
|
|
* If this target, and the target on the list are the same
|
|
* and if one of them contains conditional macro info, while
|
|
* the other doesn't, remove this entry from the list of
|
|
* recursive entries. This can only happen if the Makefile
|
|
* has changed to no longer contain conditional macros.
|
|
*/
|
|
if (IS_WEQUAL(rp->target, wcb)) {
|
|
if (rp->cond_macrostring[VER_LEN] == '\0' &&
|
|
string.buffer.start[VER_LEN] != '\0'){
|
|
rp->removed = true;
|
|
continue;
|
|
} else if (rp->cond_macrostring[VER_LEN] != '\0' &&
|
|
string.buffer.start[VER_LEN] == '\0'){
|
|
rp->removed = true;
|
|
continue;
|
|
}
|
|
}
|
|
/*
|
|
* If this is not a VERS2 entry, only need to match
|
|
* the target name. toptarg information from VERS1 entries
|
|
* are ignored.
|
|
*/
|
|
MBSTOWCS(wcs_buffer, DEPINFO_FMT_VERSION);
|
|
if (IS_WEQUALN(wcs_buffer, string.buffer.start, VER_LEN)) {
|
|
if (IS_WEQUAL(rp->cond_macrostring,
|
|
string.buffer.start) &&
|
|
IS_WEQUAL(rp->target, wcb)) {
|
|
return rp;
|
|
}
|
|
} else {
|
|
if (IS_WEQUAL(rp->target, wcb)) {
|
|
return rp;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* remove_recursive_dep(target, top_level_target)
|
|
*
|
|
* Mark a target as no longer recursive.
|
|
*
|
|
* Parameters:
|
|
* target The target we want to remove
|
|
* top_level_target target we want to remove must be built from
|
|
* the same top level target
|
|
*
|
|
* Static variables used:
|
|
* changed Written if report set changed
|
|
*/
|
|
void
|
|
remove_recursive_dep(Name target)
|
|
{
|
|
Recursive_make rp;
|
|
|
|
rp = find_recursive_target(target);
|
|
|
|
if ( rp != NULL ) {
|
|
rp->removed = true;
|
|
changed = true;
|
|
if(rp->target) {
|
|
retmem(rp->target);
|
|
rp->target = NULL;
|
|
}
|
|
if(rp->newline) {
|
|
retmem(rp->newline);
|
|
rp->newline = NULL;
|
|
}
|
|
if(rp->oldline) {
|
|
retmem(rp->oldline);
|
|
rp->oldline = NULL;
|
|
}
|
|
if(rp->cond_macrostring) {
|
|
retmem(rp->cond_macrostring);
|
|
rp->cond_macrostring = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* gather_recursive_deps()
|
|
*
|
|
* Create or update list of recursive targets.
|
|
*/
|
|
void
|
|
gather_recursive_deps(void)
|
|
{
|
|
Name_set::iterator np, e;
|
|
String_rec rec;
|
|
wchar_t rec_buf[STRING_BUFFER_LENGTH];
|
|
register Property lines;
|
|
Boolean has_recursive;
|
|
Dependency dp;
|
|
|
|
report_recursive_init();
|
|
|
|
/* Go thru all targets and dump recursive dependencies */
|
|
for (np = hashtab.begin(), e = hashtab.end(); np != e; np++) {
|
|
if (np->has_recursive_dependency){
|
|
has_recursive = false;
|
|
/*
|
|
* start .RECURSIVE line with target:
|
|
*/
|
|
INIT_STRING_FROM_STACK(rec, rec_buf);
|
|
APPEND_NAME(np, &rec, FIND_LENGTH);
|
|
append_char((int) colon_char, &rec);
|
|
append_char((int) space_char, &rec);
|
|
|
|
for (lines = get_prop(np->prop,recursive_prop);
|
|
lines != NULL;
|
|
lines = get_prop(lines->next, recursive_prop)) {
|
|
/*
|
|
* if entry is already in depinfo
|
|
* file or entry was not built, ignore it
|
|
*/
|
|
if (lines->body.recursive.in_depinfo)
|
|
continue;
|
|
if (!lines->body.recursive.has_built)
|
|
continue;
|
|
has_recursive = true;
|
|
lines->body.recursive.in_depinfo=true;
|
|
|
|
/*
|
|
* Write the remainder of the
|
|
* .RECURSIVE line
|
|
*/
|
|
APPEND_NAME(recursive_name, &rec,
|
|
FIND_LENGTH);
|
|
append_char((int) space_char, &rec);
|
|
APPEND_NAME(lines->body.recursive.directory,
|
|
&rec, FIND_LENGTH);
|
|
append_char((int) space_char, &rec);
|
|
APPEND_NAME(lines->body.recursive.target,
|
|
&rec, FIND_LENGTH);
|
|
append_char((int) space_char, &rec);
|
|
|
|
/* Complete list of makefiles used */
|
|
for (dp = lines->body.recursive.makefiles;
|
|
dp != NULL;
|
|
dp = dp->next) {
|
|
APPEND_NAME(dp->name, &rec, FIND_LENGTH);
|
|
append_char((int) space_char, &rec);
|
|
}
|
|
}
|
|
/*
|
|
* dump list of conditional targets,
|
|
* and report recursive entry, if needed
|
|
*/
|
|
cond_macros_into_string(np, &rec);
|
|
if (has_recursive){
|
|
report_recursive_dep(np, rec.buffer.start);
|
|
}
|
|
|
|
} else if ( np->has_built ) {
|
|
remove_recursive_dep(np);
|
|
}
|
|
}
|
|
}
|
|
|