Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

540 lines
15 KiB

//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1989 - 1994.
//
// File: buildinc.c
//
// Contents: This is the checking include module for the NT Build Tool (BUILD.EXE)
//
// Used for detecting the includes that do not satisfy the acceptable
// patterns.
//
// History: see SLM
//----------------------------------------------------------------------------
#include "build.h"
//+---------------------------------------------------------------------------
//
// Function: FoundCountedSequenceInString
//
// Synopsis: Roughly equivalent to "strstr" except that the substring doesn't
// have to be NULL-terminated.
//
// Arguments: [String] -- null-terminated string to search
// [Sequence] -- string to search for
// [Length] -- the length of the sequence
//----------------------------------------------------------------------------
LPCTSTR
FindCountedSequenceInString(
IN LPCTSTR String,
IN LPCTSTR Sequence,
IN DWORD Length
)
{
assert( Sequence );
assert( String );
if ( Length > 0 ) {
while ( *String ) {
while (( *String ) && ( *String != *Sequence )) {
String++;
}
if ( *String ) {
LPCTSTR SubString = String + 1;
LPCTSTR SubSequence = Sequence + 1;
DWORD Remaining = Length - 1;
while (( Remaining ) && ( *SubString++ == *SubSequence++ )) {
Remaining--;
}
if ( Remaining == 0 ) {
return String;
}
String++;
}
}
return NULL;
}
return String;
}
//+---------------------------------------------------------------------------
//
// Function: DoesInstanceMatchPattern
//
// Synopsis: Returns TRUE if pattern matches instance.
// Wildcards:
// * matches any text
// ? matches any and exactly one character
// # matches any text up to backslash character or end of string
//
// Arguments: [Instance] -- the string to be matched
// [Pattern] -- the pattern
//----------------------------------------------------------------------------
BOOL
DoesInstanceMatchPattern(
IN LPCTSTR Instance,
IN LPCTSTR Pattern
)
{
assert( Instance );
assert( Pattern );
while ( *Pattern ) {
if ( *Pattern == TEXT('*')) {
Pattern++;
while ( *Pattern == TEXT('*')) { // skip multiple '*' characters
Pattern++;
}
if ( *Pattern == 0 ) { // '*' at end of pattern matches rest
return TRUE;
}
if ( *Pattern == '?' ) { // '?' following '*'
//
// Expensive because we have to restart match for every
// character position remaining since '?' can match anything.
//
while ( *Instance ) {
if ( DoesInstanceMatchPattern( Instance, Pattern )) {
return TRUE;
}
Instance++;
}
return FALSE;
}
else {
//
// Now we know that next character in pattern is a regular
// character to be matched. Find out the length of that
// string to the next wildcard or end of string.
//
LPCTSTR NextWildCard = Pattern + 1;
DWORD MatchLength;
while (( *NextWildCard ) && ( *NextWildCard != TEXT('*')) && ( *NextWildCard != TEXT('?')) && ( *NextWildCard != TEXT('#'))) {
NextWildCard++;
}
MatchLength = (DWORD)(NextWildCard - Pattern); // always non-zero
//
// Now try to match with any instance of substring in pattern
// found in the instance.
//
Instance = FindCountedSequenceInString( Instance, Pattern, MatchLength );
while ( Instance ) {
if ( DoesInstanceMatchPattern( Instance + MatchLength, NextWildCard )) {
return TRUE;
}
Instance = FindCountedSequenceInString( Instance + 1, Pattern, MatchLength );
}
return FALSE;
}
}
else if ( *Pattern == TEXT('#')) {
//
// Match text up to backslash character or end of string
//
Pattern++;
while (( *Instance != 0 ) && ( *Instance != '\\' )) {
Instance++;
}
continue;
}
else if ( *Pattern == TEXT('?')) {
if ( *Instance == 0 ) {
return FALSE;
}
}
else if ( *Pattern != *Instance ) {
return FALSE;
}
Pattern++;
Instance++;
}
return ( *Instance == 0 );
}
//+---------------------------------------------------------------------------
//
// Function: CombinePaths
//
// Synopsis: Combine two strings to get a full path.
//
// Arguments: [ParentPath] -- head path
// [ChildPath] -- path to be added
// [TargetPath] -- full path
//----------------------------------------------------------------------------
LPSTR
CombinePaths(
IN LPCSTR ParentPath,
IN LPCSTR ChildPath,
OUT LPSTR TargetPath // can be same as ParentPath if want to append
)
{
ULONG ParentLength = strlen( ParentPath );
LPSTR p;
assert( ParentPath );
assert( ChildPath );
if ( ParentPath != TargetPath ) {
memcpy( TargetPath, ParentPath, ParentLength );
}
p = TargetPath + ParentLength;
if (( ParentLength > 0 ) &&
( *( p - 1 ) != '\\' ) &&
( *( p - 1 ) != '/' )) {
*p++ = '\\';
}
strcpy( p, ChildPath );
return TargetPath;
}
//+---------------------------------------------------------------------------
//
// Function: CreateRelativePath
//
// Synopsis: Determine the "canonical" path of one file relative to
// another file
//
// Arguments: [SourceAbsName] -- absolute path of the source file
// [TargetAbsName] -- absolute path of the target file
// [RelativePath] -- resulted relative path
//----------------------------------------------------------------------------
VOID
CreateRelativePath(
IN LPCSTR SourceAbsName, // must be lowercase
IN LPCSTR TargetAbsName, // must be lowercase
OUT LPSTR RelativePath // must be large enough
)
{
//
// First, walk through path components that match in Source and Target.
// For example:
//
// d:\nt\private\ntos\dd\efs.h
// d:\nt\private\windows\base\ntcrypto\des.h
// ^
// This is where the relative path stops going up (..)
// and starts going back down.
//
// So, the "cannonical" relative path generated should look like:
//
// ..\..\..\windows\base\ntcrypto\des.h
//
// For relative includes that are "below" the includer in the path should
// look like this:
//
// .\foo\bar\foobar.h
//
LPCSTR Source = SourceAbsName;
LPCSTR Target = TargetAbsName;
LPSTR Output = RelativePath;
ULONG PathSeparatorIndex;
BOOL AnyParent;
ULONG i;
assert( SourceAbsName );
assert( TargetAbsName );
PathSeparatorIndex = 0;
i = 0;
//
// Scan forward to first non-matching character, and keep track of
// most recent path separator character.
//
while (( Source[ i ] == Target[ i ] ) && ( Source[ i ] != 0 )) {
if ( Source[ i ] == '\\' ) {
PathSeparatorIndex = i;
}
++i;
}
//
// Coming out of this loop, there are 2 possibilities:
//
// 1) Found common ancestor path ( *PathSeparatorIndex == '\\' )
// 2) Don't have common ancestor ( *PathSeparatorIndex != '\\' )
//
if ( Source[ PathSeparatorIndex ] != '\\' ) {
strcpy( RelativePath, TargetAbsName );
return;
}
i = PathSeparatorIndex + 1;
//
// Now continue to walk down source path and insert a "..\" in the result
// for each path separator encountered.
//
AnyParent = FALSE;
while ( Source[ i ] != 0 ) {
if ( Source[ i ] == '\\' ) {
AnyParent = TRUE;
*Output++ = '.';
*Output++ = '.';
*Output++ = '\\';
}
++i;
}
if ( ! AnyParent ) {
//
// Relative path is below current directory.
//
*Output++ = '.';
*Output++ = '\\';
}
//
// Now we simply append what's remaining of the Target path from the
// ancestor match point.
//
strcpy( Output, Target + PathSeparatorIndex + 1 );
}
//+---------------------------------------------------------------------------
//
// Function: ShouldWarnInclude
//
// Synopsis: Returns true if the name of the included file matches a
// BUILD_UNACCEPTABLE_INCLUDES pattern or it does not match
// any of the patterns specified in BUILD_ACCEPTABLE_INCLUDES.
//
// Arguments: [CompilandFullName] -- name of the including file
// [IncludeeFullName] -- name of the included file
//----------------------------------------------------------------------------
BOOL
ShouldWarnInclude(
IN LPCSTR CompilandFullName,
IN LPCSTR IncludeeFullName
)
{
UINT i;
CHAR IncludeeRelativeName[ MAX_PATH ];
assert( CompilandFullName );
assert( IncludeeFullName );
CreateRelativePath( CompilandFullName, IncludeeFullName, IncludeeRelativeName );
//
// First we check for a match against any unacceptable include path
// because we always want to warn about these.
//
for ( i = 0; UnacceptableIncludePatternList[ i ] != NULL; i++ ) {
if ( DoesInstanceMatchPattern( IncludeeFullName, UnacceptableIncludePatternList[ i ] )) {
return TRUE;
}
if ( DoesInstanceMatchPattern( IncludeeRelativeName, UnacceptableIncludePatternList[ i ] )) {
return TRUE;
}
}
//
// If we get to here, the include path was not explicitly unacceptable, so
// we now want to see if it matches any acceptable paths. But, if no
// acceptable paths are specified, we don't want to warn.
//
if ( AcceptableIncludePatternList[ 0 ] == NULL ) {
return FALSE;
}
for ( i = 0; AcceptableIncludePatternList[ i ] != NULL; i++ ) {
if ( DoesInstanceMatchPattern( IncludeeFullName, AcceptableIncludePatternList[ i ] )) {
return FALSE;
}
if ( DoesInstanceMatchPattern( IncludeeRelativeName, AcceptableIncludePatternList[ i ] )) {
return FALSE;
}
}
return TRUE;
}
//+---------------------------------------------------------------------------
//
// Function: CheckIncludeForWarning
//
// Synopsis: Warnings if the dependency does not respect the
// BUILD_UNACCEPTABLE_INCLUDES or BUILD_ACCEPTABLE_INCLUDES
// restristions. Works with build -#.
//
// Arguments: [CompilandDir]
// [CompilandName]
// [IncluderDir]
// [IncluderName]
// [IncludeeDir]
// [IncludeeName]
//----------------------------------------------------------------------------
VOID
CheckIncludeForWarning(
IN LPCSTR CompilandDir,
IN LPCSTR CompilandName,
IN LPCSTR IncluderDir,
IN LPCSTR IncluderName,
IN LPCSTR IncludeeDir,
IN LPCSTR IncludeeName
)
{
CHAR CompilandFullName[ MAX_PATH ];
CHAR IncluderFullName[ MAX_PATH ];
CHAR IncludeeFullName[ MAX_PATH ];
assert( CompilandDir );
assert( CompilandName );
assert( IncluderDir );
assert( IncluderName );
assert( IncludeeDir );
assert( IncludeeName );
CombinePaths( CompilandDir, CompilandName, CompilandFullName );
CombinePaths( IncluderDir, IncluderName, IncluderFullName );
CombinePaths( IncludeeDir, IncludeeName, IncludeeFullName );
_strlwr( CompilandFullName );
_strlwr( IncluderFullName );
_strlwr( IncludeeFullName );
if ( IncFile ) {
fprintf(
IncFile,
"%s includes %s\r\n",
IncluderFullName,
IncludeeFullName
);
}
if ( ShouldWarnInclude( CompilandFullName, IncludeeFullName )) {
if ( strcmp( IncluderFullName, CompilandFullName ) == 0 ) {
if ( WrnFile ) {
fprintf(
WrnFile,
"WARNING: %s includes %s\n",
CompilandFullName,
IncludeeFullName
);
}
if ( fShowWarningsOnScreen ) {
BuildMsgRaw(
"WARNING: %s includes %s\n",
CompilandFullName,
IncludeeFullName
);
}
}
else {
if ( WrnFile ) {
fprintf(
WrnFile,
"WARNING: %s includes %s through %s\n",
CompilandFullName,
IncludeeFullName,
IncluderFullName
);
}
if ( fShowWarningsOnScreen ) {
BuildMsgRaw(
"WARNING: %s includes %s through %s\n",
CompilandFullName,
IncludeeFullName,
IncluderFullName
);
}
}
}
}