## @ CheckCodeBase.py
|
#
|
# Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
#
|
##
|
|
import os
|
import re
|
import sys
|
import time
|
import shutil
|
|
class FileChecker:
|
def __init__(self):
|
# sourceRoot == WORKSPACE
|
# sourceRoot != PACKAGES_PATH
|
self.sourceRoot = ""
|
self.includeCoreList = ["\\CryptoPkg\\", "\\FatBinPkg\\", "\\FatPkg\\", "\\IntelFrameworkModulePkg\\", "\\IntelFrameworkPkg\\", "\\IntelFsp2Pkg\\", "\\IntelFsp2WrapperPkg\\", "\\IntelFspPkg\\", "\\IntelFspWrapperPkg\\", "\\IntelSiliconPkg\\", "\\MdeModulePkg\\", "\\MdePkg\\", "\\NetworkPkg\\", "\\PcAtChipsetPkg\\", "\\PerformancePkg\\", "\\SecurityPkg\\", "\\ShellBinPkg\\", "\\ShellPkg\\", "\\SignedCapsulePkg\\", "\\SourceLevelDebugPkg\\", "\\UefiCpuPkg\\"]
|
self.includeList = self.includeCoreList
|
self.excluseCoreList = ["\\BaseTools\\", "\\Conf\\", "\\Tools\\", "\\Build\\", "\\tool\\", "\\.svn", "\\.git", "\\Override\\", "\\SampleCode\\", "\\openssl"]
|
self.excluseList = self.excluseCoreList
|
self.usedModuleList = []
|
self.usedLibraryList = []
|
self.makefileList = []
|
self.usedIncludeFileList = []
|
self.usedModuleFileList = []
|
self.usedLibraryFileList = []
|
self.usedFileList = []
|
self.usedPackageList = []
|
self.allModuleList = []
|
self.allLibraryList = []
|
self.allDirList = []
|
self.allIncludeFileList = []
|
self.allModuleFileList = []
|
self.allLibraryFileList = []
|
self.allFileList = []
|
self.allPackageList = []
|
self.unusedModuleList = []
|
self.unusedLibraryList = []
|
self.unusedIncludeFileList = []
|
self.unusedModuleFileList = []
|
self.unusedLibraryFileList = []
|
self.unusedFileList = []
|
self.unusedPackageList = []
|
self.unusedPackageFileList = []
|
|
def CheckFile(self, file):
|
if os.path.isfile(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
|
def CheckDir(self, file):
|
if os.path.isdir(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
|
def IsIncludeFile(self, file):
|
if (cmp (file[-2:], ".h") == 0) and (file.find ("Pkg\\Include") != -1):
|
return True
|
else:
|
return False
|
|
def IsLibraryFile(self, file):
|
if (file.find ("Pkg\\Library") != -1):
|
return True
|
else:
|
return False
|
|
def CheckIncludeFile(self, file):
|
if self.IsIncludeFile(file) and (self.IsInExclusiveList(file) == False):
|
return file.decode('gbk')
|
else:
|
return ""
|
|
def GetModulePathFromMakefile (self, file):
|
makefile = open (file, "r")
|
data = makefile.read ()
|
for line in data.split("\n"):
|
# MODULE_DIR = c:\home\edkiigit\edk2\MdeModulePkg\Library\BaseSerialPortLib16550
|
if "MODULE_DIR =" in line:
|
moduleDir = line.split(" = ")[1]
|
# BUILD_DIR = c:\home\edkiigit\Build\KabylakeOpenBoardPkg\KabylakeRvp3\DEBUG_VS2015x86
|
if "BUILD_DIR =" in line:
|
buildDir = line.split(" = ")[1]
|
makefile.close()
|
|
# record sourceRoot = c:\home\Edk-II
|
self.sourceRoot = buildDir.split("\\Build\\")[0]
|
|
if (self.IsInExclusiveList(moduleDir) == False):
|
self.AddPackageList(moduleDir, self.usedPackageList)
|
|
return moduleDir
|
|
def AddPackageList(self, file, packageList):
|
packageName = file.split("Pkg")
|
packagePath = packageName[0] + "Pkg"
|
if packagePath not in packageList:
|
packageList.append(packagePath)
|
|
def IsInPackageList(self, file):
|
for package in self.usedPackageList:
|
if file.find(package) != -1:
|
return True
|
return False
|
|
def CheckUsedModule(self, file):
|
if (cmp (file[-8:], "Makefile") == 0) and (self.IsLibraryFile(file) == False):
|
finalDir = self.GetModulePathFromMakefile(file)
|
if self.IsInExclusiveList(finalDir):
|
return ""
|
return finalDir.decode('gbk')
|
else:
|
return ""
|
|
def CheckUsedLibrary(self, file):
|
if (cmp (file[-8:], "Makefile") == 0) and self.IsLibraryFile(file):
|
finalDir = self.GetModulePathFromMakefile(file)
|
if self.IsInExclusiveList(finalDir):
|
return ""
|
return finalDir.decode('gbk')
|
else:
|
return ""
|
|
def CheckMakefile(self, file):
|
if cmp (file[-8:], "Makefile") == 0:
|
finalDir = self.GetModulePathFromMakefile(file)
|
if self.IsInExclusiveList(finalDir):
|
return ""
|
return file.decode('gbk')
|
else:
|
return ""
|
|
def ParseMakefile(self, fileName):
|
try :
|
file = open(fileName)
|
except Exception:
|
print "fail to open " + fileName
|
return
|
try:
|
while 1:
|
line = file.readline()
|
if not line:
|
break
|
if cmp (line[0], "#") == 0:
|
continue
|
newline = line[:-1]
|
|
#print "check - (" + newline + ")"
|
headFile = ""
|
#COMMON_DEPS = $(WORKSPACE)\MdePkg\Include\Protocol\DebugSupport.h \
|
# $(WORKSPACE)\MdePkg\Include\Ppi\PciCfg2.h \
|
#$(OUTPUT_DIR)\X64\Semaphore.obj : $(WORKSPACE)\UefiCpuPkg\Include\Library\MtrrLib.h
|
#MatchString = "[\w\\\s\=\:\.\(\)\$]*\$\(WORKSPACE\)([\\\w]*\.h)[\\w\s]*"
|
MatchString1 = "(COMMON_DEPS = | |\$\(OUTPUT_DIR\)[\\\\\w]*.obj : )\$\(WORKSPACE\)\\\\([\\\\\w]*\.h)"
|
match1 = re.match(MatchString1, newline)
|
if match1 is not None:
|
#print "match1 - " + newline
|
#print "0 - " + match1.group(0)
|
#print "1 - " + match1.group(1)
|
#print "2 - " + match1.group(2)
|
headFile = match1.group(2)
|
|
if (cmp (headFile, "") != 0) and self.IsIncludeFile(headFile):
|
finalPath = os.path.join (self.sourceRoot, headFile)
|
if (self.IsInExclusiveList(finalPath) == False) and (finalPath not in self.usedIncludeFileList):
|
self.usedIncludeFileList.append(finalPath)
|
self.AddPackageList (finalPath, self.usedPackageList)
|
|
finally:
|
file.close()
|
|
return
|
|
def IsInIncludeList(self, file):
|
for list in self.includeList:
|
result = file.find(list);
|
if (result != -1):
|
return True
|
return False
|
|
def IsInExclusiveList(self, file):
|
if self.IsInIncludeList(file) == False:
|
return True
|
for list in self.excluseList:
|
result = file.find(list);
|
if (result != -1):
|
return True
|
for list in self.excluseList:
|
full_file = file + "\\"
|
result = full_file.find(list);
|
if (result != -1):
|
return True
|
return False
|
|
def IsFinalDir(self, file):
|
for s in os.listdir(file):
|
newFile=os.path.join(file,s)
|
if cmp (newFile[-4:], ".inf") == 0:
|
return True
|
return False
|
|
def IsInUsedModuleList(self, file):
|
if file in self.usedModuleList:
|
return True
|
else:
|
return False
|
|
def IsInUsedLibraryList(self, file):
|
if file in self.usedLibraryList:
|
return True
|
else:
|
return False
|
|
def IsUsedModule(self, file):
|
for used in self.usedModuleList:
|
final = used + "\\"
|
result = file.find(final);
|
if (result != -1):
|
return True
|
return False
|
|
def IsUsedLibrary(self, file):
|
for used in self.usedLibraryList:
|
final = used + "\\"
|
result = file.find(final);
|
if (result != -1):
|
return True
|
return False
|
|
def IsUnusedModule(self, file):
|
for unused in self.unusedModuleList:
|
final = unused + "\\"
|
result = file.find(final);
|
if (result != -1):
|
return True
|
return False
|
|
def IsUnusedLibrary(self, file):
|
for unused in self.unusedLibraryList:
|
final = unused + "\\"
|
result = file.find(final);
|
if (result != -1):
|
return True
|
return False
|
|
def IsUnusedPackage(self, file):
|
for unused in self.unusedPackageList:
|
final = unused + "\\"
|
result = file.find(final);
|
if (result != -1):
|
return True
|
return False
|
|
def CheckUnusedModule(self, file):
|
if os.path.isdir(file):
|
if (self.IsInExclusiveList(file) == False) and self.IsFinalDir(file) and (self.IsInUsedModuleList(file) == False) and (self.IsLibraryFile(file) == False):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckUnusedLibrary(self, file):
|
if os.path.isdir(file):
|
if (self.IsInExclusiveList(file) == False) and self.IsFinalDir(file) and (self.IsInUsedLibraryList(file) == False) and self.IsLibraryFile(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckAllModule(self, file):
|
if os.path.isdir(file):
|
if (self.IsInExclusiveList(file) == False) and self.IsFinalDir(file) and (self.IsLibraryFile(file) == False):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckAllLibrary(self, file):
|
if os.path.isdir(file):
|
if (self.IsInExclusiveList(file) == False) and self.IsFinalDir(file) and self.IsLibraryFile(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckAllDir(self, file):
|
if os.path.isdir(file):
|
if (self.IsInExclusiveList(file) == False):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckAllModuleFile(self, file):
|
if os.path.isfile(file):
|
if (self.IsInExclusiveList(file) == False) and (self.IsUsedModule(file) or self.IsUnusedModule(file)) and (self.IsLibraryFile(file) == False):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckAllLibraryFile(self, file):
|
if os.path.isfile(file):
|
if (self.IsInExclusiveList(file) == False) and (self.IsUsedLibrary(file) or self.IsUnusedLibrary(file)) and self.IsLibraryFile(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckAllFile(self, file):
|
if os.path.isfile(file):
|
if (self.IsInExclusiveList(file) == False):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckUsedModuleFile(self, file):
|
if os.path.isfile(file):
|
if (self.IsInExclusiveList(file) == False) and self.IsUsedModule(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckUsedLibraryFile(self, file):
|
if os.path.isfile(file):
|
if (self.IsInExclusiveList(file) == False) and self.IsUsedLibrary(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckUnusedModuleFile(self, file):
|
if os.path.isfile(file):
|
if (self.IsInExclusiveList(file) == False) and self.IsUnusedModule(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckUnusedLibraryFile(self, file):
|
if os.path.isfile(file):
|
if (self.IsInExclusiveList(file) == False) and self.IsUnusedLibrary(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def CheckUnusedPackageFile(self, file):
|
if os.path.isfile(file):
|
if (self.IsInExclusiveList(file) == False) and self.IsUnusedPackage(file):
|
return file.decode('gbk')
|
else:
|
return ""
|
else:
|
return ""
|
|
def GetFileList(self, dir, fileList, checkFunc):
|
newDir = dir
|
AppendName = checkFunc (dir)
|
if cmp (AppendName, "") != 0:
|
#print "AppendName = " + AppendName
|
if AppendName not in fileList:
|
fileList.append(AppendName)
|
if os.path.isdir(dir):
|
for sub in os.listdir(dir):
|
newDir = os.path.join(dir,sub)
|
self.GetFileList(newDir, fileList, checkFunc)
|
return fileList
|
|
def DeleteEmptyDir(self, dir):
|
if os.path.exists(dir) == False:
|
return
|
if os.path.isdir(dir):
|
for sub in os.listdir(dir):
|
newDir = os.path.join(dir,sub)
|
if (os.path.isdir(newDir) == True):
|
self.DeleteEmptyDir(newDir)
|
if not os.listdir(dir):
|
print "deleting empty " + dir
|
os.rmdir(dir)
|
|
def DeleteEmptyDirList(self, fileList):
|
for file in fileList:
|
self.DeleteEmptyDir(file)
|
|
def DeleteUnusedFile(self, fileList):
|
for file in fileList:
|
if os.path.exists(file) == False:
|
continue
|
print "deleting " + file
|
try :
|
if os.path.isdir(file):
|
shutil.rmtree(file)
|
if os.path.isfile(file):
|
os.remove(file)
|
except :
|
print "deleting error (" + file + ")"
|
|
def PrintFileTime(self, file):
|
statinfo = os.stat(file)
|
strucatime = time.localtime(statinfo.st_atime)
|
print "atime: " + str(statinfo.st_atime) + " (" + str(strucatime.tm_year) + "." + str(strucatime.tm_mon) + "." + str(strucatime.tm_mday) + " " + str(strucatime.tm_hour) + ":" + str(strucatime.tm_min) + ":" + str(strucatime.tm_sec) + ")"
|
strucctime = time.localtime(statinfo.st_ctime)
|
print "ctime: " + str(statinfo.st_ctime) + " (" + str(strucctime.tm_year) + "." + str(strucctime.tm_mon) + "." + str(strucctime.tm_mday) + " " + str(strucctime.tm_hour) + ":" + str(strucctime.tm_min) + ":" + str(strucctime.tm_sec) + ")"
|
strucmtime = time.localtime(statinfo.st_mtime)
|
print "mtime: " + str(statinfo.st_mtime) + " (" + str(strucmtime.tm_year) + "." + str(strucmtime.tm_mon) + "." + str(strucmtime.tm_mday) + " " + str(strucmtime.tm_hour) + ":" + str(strucmtime.tm_min) + ":" + str(strucmtime.tm_sec) + ")"
|
|
def TouchFileTime(self, file):
|
#currentTime = time.time()
|
#os.utime(file, (currentTime, currentTime))
|
os.utime(file, None)
|
|
def TouchFileListTime(self, fileList):
|
for file in fileList:
|
self.TouchFileTime(file)
|
|
def PrintFileList(self, fileList):
|
for file in fileList:
|
print file
|
print " Count - " + str(len(fileList))
|
|
def SortFileList(self, fileList):
|
fileList.sort()
|
|
def PrintFileListTime(self, fileList):
|
for file in fileList:
|
print file
|
self.PrintFileTime(file)
|
|
def GetUsedModuleList(self):
|
if (len(self.usedModuleList) == 0):
|
self.usedModuleList = self.GetFileList(sys.argv[1], [], self.CheckUsedModule)
|
self.SortFileList(self.usedModuleList)
|
|
def GetUsedLibraryList(self):
|
if (len(self.usedLibraryList) == 0):
|
self.usedLibraryList = self.GetFileList(sys.argv[1], [], self.CheckUsedLibrary)
|
self.SortFileList(self.usedLibraryList)
|
|
def GetMakefileList(self):
|
if (len(self.makefileList) == 0):
|
self.GetUsedModuleList()
|
self.makefileList = self.GetFileList(sys.argv[1], [], self.CheckMakefile)
|
|
def GetUsedIncludeFileList(self):
|
if (len(self.usedIncludeFileList) == 0):
|
self.GetMakefileList()
|
|
#print "\nMakefile:"
|
#fileChecker.PrintFileList (fileChecker.makefileList)
|
|
for file in self.makefileList:
|
self.ParseMakefile(file)
|
self.SortFileList(self.usedIncludeFileList)
|
|
def GetUsedModuleFileList(self):
|
if (len(self.usedModuleFileList) == 0):
|
self.GetUsedModuleList()
|
|
self.usedModuleFileList = self.GetFileList(self.sourceRoot, [], self.CheckUsedModuleFile)
|
self.SortFileList(self.usedModuleFileList)
|
|
def GetUsedLibraryFileList(self):
|
if (len(self.usedLibraryFileList) == 0):
|
self.GetUsedLibraryList()
|
|
self.usedLibraryFileList = self.GetFileList(self.sourceRoot, [], self.CheckUsedLibraryFile)
|
self.SortFileList(self.usedLibraryFileList)
|
|
def GetUsedFileList(self):
|
if (len(self.usedFileList) == 0):
|
self.GetAllFileList()
|
self.GetUnusedFileList()
|
|
self.usedFileList = []
|
for file in self.allFileList:
|
if (file not in self.unusedFileList) and self.IsInPackageList(file):
|
self.usedFileList.append(file)
|
|
self.SortFileList(self.usedFileList)
|
|
def GetUsedPackageList(self):
|
self.GetUsedModuleList()
|
self.GetUsedLibraryList()
|
self.GetUsedIncludeFileList()
|
self.SortFileList(self.usedPackageList)
|
|
def GetAllModuleList(self):
|
if (len(self.allModuleList) == 0):
|
self.GetUsedModuleList()
|
|
self.allModuleList = self.GetFileList(self.sourceRoot, [], self.CheckAllModule)
|
self.SortFileList(self.allModuleList)
|
|
def GetAllLibraryList(self):
|
if (len(self.allLibraryList) == 0):
|
self.GetUsedLibraryList()
|
|
self.allLibraryList = self.GetFileList(self.sourceRoot, [], self.CheckAllLibrary)
|
self.SortFileList(self.allLibraryList)
|
|
def GetAllIncludeFileList(self):
|
if (len(self.allIncludeFileList) == 0):
|
self.GetUsedModuleList()
|
|
self.allIncludeFileList = self.GetFileList(self.sourceRoot, [], self.CheckIncludeFile)
|
self.SortFileList(self.allIncludeFileList)
|
|
def GetAllModuleFileList(self):
|
if (len(self.allFileList) == 0):
|
self.GetUsedModuleList()
|
self.GetUnusedModuleList()
|
|
self.allModuleFileList = self.GetFileList(self.sourceRoot, [], self.CheckAllModuleFile)
|
self.SortFileList(self.allModuleFileList)
|
|
def GetAllLibraryFileList(self):
|
if (len(self.allFileList) == 0):
|
self.GetUsedLibraryList()
|
self.GetUnusedLibraryList()
|
|
self.allLibraryFileList = self.GetFileList(self.sourceRoot, [], self.CheckAllLibraryFile)
|
self.SortFileList(self.allLibraryFileList)
|
|
def GetAllFileList(self):
|
if (len(self.allFileList) == 0):
|
self.GetUsedModuleList()
|
|
self.allFileList = self.GetFileList(self.sourceRoot, [], self.CheckAllFile)
|
self.SortFileList(self.allFileList)
|
|
def GetAllPackageList(self):
|
if (len(self.allPackageList) == 0):
|
self.GetAllFileList()
|
prefixLength = len(self.sourceRoot)
|
for file in self.allFileList:
|
finalPath = os.path.join (self.sourceRoot, file[prefixLength + 1:])
|
self.AddPackageList(finalPath, self.allPackageList)
|
self.SortFileList(self.allPackageList)
|
|
def GetUnusedModuleList(self):
|
if (len(self.unusedModuleList) == 0):
|
self.GetUsedModuleList()
|
|
self.unusedModuleList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedModule)
|
|
def GetUnusedLibraryList(self):
|
if (len(self.unusedLibraryList) == 0):
|
self.GetUsedLibraryList()
|
|
self.unusedLibraryList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedLibrary)
|
|
def GetUnusedIncludeFileList(self):
|
if (len(self.unusedIncludeFileList) == 0):
|
self.GetUsedIncludeFileList()
|
self.GetAllIncludeFileList()
|
|
self.unusedIncludeFileList = []
|
for file in self.allIncludeFileList:
|
if file not in self.usedIncludeFileList:
|
self.unusedIncludeFileList.append(file)
|
|
self.SortFileList(self.unusedIncludeFileList)
|
|
def GetUnusedModuleFileList(self):
|
if (len(self.unusedModuleFileList) == 0):
|
self.GetUnusedModuleList ()
|
|
self.unusedModuleFileList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedModuleFile)
|
self.SortFileList(self.unusedModuleFileList)
|
|
def GetUnusedLibraryFileList(self):
|
if (len(self.unusedLibraryFileList) == 0):
|
self.GetUnusedLibraryList ()
|
|
self.unusedLibraryFileList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedLibraryFile)
|
self.SortFileList(self.unusedLibraryFileList)
|
|
def GetUnusedFileList(self):
|
if (len(self.unusedFileList) == 0):
|
self.GetUnusedIncludeFileList()
|
self.GetUnusedModuleFileList()
|
self.GetUnusedLibraryFileList()
|
|
self.GetUnusedPackageList()
|
self.unusedPackageFileList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedPackageFile)
|
|
self.unusedFileList = []
|
self.unusedFileList.extend(self.unusedIncludeFileList)
|
self.unusedFileList.extend(self.unusedModuleFileList)
|
self.unusedFileList.extend(self.unusedLibraryFileList)
|
|
for file in self.unusedPackageFileList:
|
if file not in self.unusedFileList:
|
self.unusedFileList.append(file)
|
|
self.SortFileList(self.unusedFileList)
|
|
def GetUnusedPackageList(self):
|
if (len(self.unusedPackageList) == 0):
|
self.GetUsedPackageList()
|
self.GetAllPackageList()
|
|
for package in self.allPackageList:
|
if package not in self.usedPackageList:
|
self.unusedPackageList.append(package)
|
self.SortFileList(self.unusedPackageList)
|
|
#
|
# Print out the usage
|
#
|
def usage():
|
print "Usage: \n\tCheckCodeBase <Build Dir> used|unused|all"
|
print " used - used library, modules, include file, library files, module files, all used files"
|
print " unused - unused library, modules, include file, library files, module files, all unused files"
|
print " all - all library, modules, include file, library files, module files, all files"
|
print " library : the directory of a library"
|
print " module : the directory of a driver"
|
print " include file : the header files in include directory"
|
print " library file : all files in a library directory"
|
print " module file : all files in a driver directory"
|
print " all file : all files in project, including any other metadata files or batch files"
|
#print "Usage: \n\tCheckCodeBase <Build Dir> time|touch"
|
print "For Example: \n\tCheckCodeBase Build\KabylakeOpenBoardPkg\KabylakeRvp3\DEBUG_VS2015x86 used"
|
|
def main():
|
global FileChecker
|
|
fileChecker = FileChecker()
|
|
if len(sys.argv) < 3:
|
usage()
|
return 1
|
|
if cmp (sys.argv[2], "used") == 0:
|
fileChecker.GetUsedModuleList ()
|
print "\n Used Module List:"
|
fileChecker.PrintFileList (fileChecker.usedModuleList)
|
|
fileChecker.GetUsedLibraryList ()
|
print "\n Used Library List:"
|
fileChecker.PrintFileList (fileChecker.usedLibraryList)
|
|
fileChecker.GetUsedIncludeFileList()
|
print "\n Used Include File List:"
|
fileChecker.PrintFileList (fileChecker.usedIncludeFileList)
|
|
fileChecker.GetUsedModuleFileList()
|
print "\n Used Module File List:"
|
fileChecker.PrintFileList (fileChecker.usedModuleFileList)
|
|
fileChecker.GetUsedLibraryFileList()
|
print "\n Used Library File List:"
|
fileChecker.PrintFileList (fileChecker.usedLibraryFileList)
|
|
fileChecker.GetUsedFileList()
|
print "\n All Used File List:"
|
fileChecker.PrintFileList (fileChecker.usedFileList)
|
|
fileChecker.GetUsedPackageList()
|
print "\n Used Package List:"
|
fileChecker.PrintFileList (fileChecker.usedPackageList)
|
|
print "\n ==== Used Module Summary ===="
|
print " Module Count - " + str(len(fileChecker.usedModuleList))
|
print " Library Count - " + str(len(fileChecker.usedLibraryList))
|
print " Include File Count - " + str(len(fileChecker.usedIncludeFileList))
|
print " Module File Count - " + str(len(fileChecker.usedModuleFileList))
|
print " Library File Count - " + str(len(fileChecker.usedLibraryFileList))
|
print " All File Count - " + str(len(fileChecker.usedFileList))
|
|
elif cmp (sys.argv[2], "all") == 0:
|
fileChecker.GetAllModuleList()
|
print "\n All Module List:"
|
fileChecker.PrintFileList (fileChecker.allModuleList)
|
|
fileChecker.GetAllLibraryList()
|
print "\n All Library List:"
|
fileChecker.PrintFileList (fileChecker.allLibraryList)
|
|
fileChecker.GetAllIncludeFileList()
|
print "\n All Include File List:"
|
fileChecker.PrintFileList (fileChecker.allIncludeFileList)
|
|
fileChecker.GetAllModuleFileList()
|
print "\n All Module File List:"
|
fileChecker.PrintFileList (fileChecker.allModuleFileList)
|
|
fileChecker.GetAllLibraryFileList()
|
print "\n All Library File List:"
|
fileChecker.PrintFileList (fileChecker.allLibraryFileList)
|
|
fileChecker.GetAllFileList()
|
print "\n All File List:"
|
fileChecker.PrintFileList (fileChecker.allFileList)
|
|
fileChecker.GetAllPackageList()
|
print "\n All Package List:"
|
fileChecker.PrintFileList (fileChecker.allPackageList)
|
|
print "\n ==== All Module Summary ===="
|
print " Module Count - " + str(len(fileChecker.allModuleList))
|
print " Library Count - " + str(len(fileChecker.allLibraryList))
|
print " Include File Count - " + str(len(fileChecker.allIncludeFileList))
|
print " Module File Count - " + str(len(fileChecker.allModuleFileList))
|
print " Library File Count - " + str(len(fileChecker.allLibraryFileList))
|
print " All File Count - " + str(len(fileChecker.allFileList))
|
|
elif cmp (sys.argv[2], "unused") == 0:
|
fileChecker.GetUnusedModuleList()
|
print "\n Unused Module List:"
|
fileChecker.PrintFileList (fileChecker.unusedModuleList)
|
|
fileChecker.GetUnusedLibraryList()
|
print "\n Unused Library List:"
|
fileChecker.PrintFileList (fileChecker.unusedLibraryList)
|
|
fileChecker.GetUnusedIncludeFileList()
|
print "\n Unused Include List:"
|
fileChecker.PrintFileList (fileChecker.unusedIncludeFileList)
|
|
fileChecker.GetUnusedModuleFileList()
|
print "\n Unused Module File List:"
|
fileChecker.PrintFileList (fileChecker.unusedModuleFileList)
|
|
fileChecker.GetUnusedLibraryFileList()
|
print "\n Unused Library File List:"
|
fileChecker.PrintFileList (fileChecker.unusedLibraryFileList)
|
|
fileChecker.GetUnusedFileList()
|
print "\n Unused File List:"
|
fileChecker.PrintFileList (fileChecker.unusedFileList)
|
|
fileChecker.GetUnusedPackageList()
|
print "\n Unused Package List:"
|
fileChecker.PrintFileList (fileChecker.unusedPackageList)
|
|
print "\n ==== Unused Module Summary ===="
|
print " Module Count - " + str(len(fileChecker.unusedModuleList))
|
print " Library Count - " + str(len(fileChecker.unusedLibraryList))
|
print " Include File Count - " + str(len(fileChecker.unusedIncludeFileList))
|
print " Module File Count - " + str(len(fileChecker.unusedModuleFileList))
|
print " Library File Count - " + str(len(fileChecker.unusedLibraryFileList))
|
print " All File Count - " + str(len(fileChecker.unusedFileList))
|
|
elif cmp (sys.argv[2], "delete_unused") == 0:
|
fileChecker.GetUnusedModuleList()
|
fileChecker.GetUnusedLibraryList()
|
fileChecker.GetUnusedIncludeFileList()
|
fileChecker.GetUnusedPackageList()
|
|
fileChecker.DeleteUnusedFile(fileChecker.unusedPackageList)
|
fileChecker.DeleteUnusedFile(fileChecker.unusedModuleList)
|
fileChecker.DeleteUnusedFile(fileChecker.unusedLibraryList)
|
fileChecker.DeleteUnusedFile(fileChecker.unusedIncludeFileList)
|
|
fileChecker.allDirList = fileChecker.GetFileList(fileChecker.sourceRoot, [], fileChecker.CheckAllDir)
|
fileChecker.DeleteEmptyDirList(fileChecker.allDirList)
|
|
elif cmp (sys.argv[2], "time") == 0:
|
fileChecker.allDirList = fileChecker.GetFileList(sys.argv[1], [], fileChecker.CheckFile)
|
fileChecker.PrintFileListTime(fileChecker.allDirList)
|
|
elif cmp (sys.argv[2], "touch") == 0:
|
fileChecker.allDirList = fileChecker.GetFileList(sys.argv[1], [], fileChecker.CheckFile)
|
fileChecker.TouchFileListTime(fileChecker.allDirList)
|
else:
|
print "Unknown - " + sys.argv[2]
|
|
if __name__ == '__main__':
|
sys.exit(main())
|
