replace nob with ms' build, move disk creation to build.bat, major comment cleanup, remove old and stupid tests, overhaul interrupt management with per-CPU vector allocation, affinity migration and safe teardown, add proper IOAPIC routing and PCI MSI/MSI-X/INTx support, migrate drivers to the new interrupt API, integrate ACPICA with a proper OS services layer, move ACPI firmware events, power button handling and S5 shutdown into acpi.sys, add parallel driver startup and atomic publication, replace PnP arrays with dynamic lists, redesign service startup again to be asynchronous, add delayed startup mode for services, allow omitting keys in services.ini, fix acpi ec deferred work handling, fix kernel threads having garbage exit code.

sdktools/buildinc.c

@@ -0,0 +1,540 @@
+//+---------------------------------------------------------------------------
+//
+//  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
+                    );
+                }
+            }
+        }
+    }
+