def cleanSourceDirectory(source_dir):
extensions = (".bin", ".c", ".cpp", ".exp", ".h", ".lib", ".manifest",
".o", ".obj", ".os", ".rc", ".res", ".S")
if os.path.isdir(source_dir):
for path, _filename in listDir(source_dir):
if hasFilenameExtension(path, extensions):
deleteFile(path, must_exist=True)
else:
makePath(source_dir)
def _getWebviewFiles(module, dlls):
# TODO: Clarify non-Windows needs.
if not isWin32Windows():
return
webview_libdir = os.path.join(module.getCompileTimeDirectory(), "lib")
for filename in getFileList(webview_libdir):
filename_relative = os.path.relpath(filename, webview_libdir)
if getArchitecture() == "x86":
if "x64" in filename_relative:
continue
else:
if "x86" in filename_relative:
continue
is_dll = hasFilenameExtension(filename_relative, ".dll")
if dlls and not is_dll or not dlls and is_dll:
continue
yield filename, filename_relative
def cleanSourceDirectory(source_dir):
extensions = (
".bin",
".c",
".cpp",
".exp",
".h",
".lib",
".manifest",
".o",
".obj",
".os",
".rc",
".res",
".S",
".txt",
)
if os.path.isdir(source_dir):
for path, _filename in listDir(source_dir):
if hasFilenameExtension(path, extensions):
deleteFile(path, must_exist=True)
else:
makePath(source_dir)
def check(path):
if hasFilenameExtension(path, extensions):
deleteFile(path, must_exist=True)
def call_analyzer(f, call_list, import_calls, import_files, trace_logic):
""" Analyze the call hierarchy to determine valid called names.
Notes:
Always called with a CALL record type.
Recursive function calling itself for every level change. Each CALL on
each level will be followed by exactly one RESULT (or EXCEPTION),
potentially with interspersed CALL / RESULT pairs at lower levels.
Args:
f: file to read from (created by the script wrapped in hinting logic)
call_list: list representing a CALL record
import_calls: list to receive computed import names
import_files: list to receive imported files
trace_logic: bool to switch on tracing the logic
Returns:
No direct returns, output will be written to call_file.
"""
global line_number
def normalize_file(t):
# step 1: remove any platform tags from shared libraries
folder = os.path.dirname(t) # folder part
datei = os.path.basename(t) # filename
_, ext = os.path.splitext(datei) # extension
if ext in (".pyd", ".so"): # shared library?
datei_arr = datei.split(".") # split
if len(datei_arr) > 2: # platform tag present?
datei = ".".join(datei_arr[:-2]) # yes, omit
else:
datei = ".".join(datei_arr[:-1]) # just omit ext
t = os.path.join(folder, datei) # rebuild filename for step 2
# step 2: turn slashes into '.', remove __init__.py and extensions
t = t.replace("\\", ".").replace("/", ".").replace("$PYTHONPATH.", "")
if t.endswith(".__init__.py"):
t = t[:-12]
return t
if t.endswith(".py"):
t = t[:-3]
return t
if ext not in (".pyd", ".so"):
sys.exit("found unknown Python module type '%s'" % t)
return t
def write_mod(t, f): # write a call entry
import_calls.append((t, f))
if trace_logic:
print(line_number, "call:", t)
return
def write_file(t): # write a file entry
import_files.append(t)
if trace_logic:
print(line_number, "file:", t)
return
level = call_list[0] # nesting level
CALLED = call_list[2] # the imported module
implist = call_list[3] # list accompanying the import statement
text = reader(f) # read the next record
if not bool(text): # EOF should not happen here!
print("unexpected EOF at %s" % str(call_list))
sys.exit("line number %i" % line_number)
if len(text) < 3:
print("unexpected record format", text)
sys.exit("at line number %i" % line_number)
while "CALL" in text: # any CALL records will be recursed into
call_analyzer(f, text, import_calls, import_files, trace_logic)
text = reader(f)
if len(text) < 3:
return
if text[0] != level: # this record should have our level!
matching = False
else:
matching = True
if text[1] == "EXCEPTION": # no output if an exception resulted
return
if text[1] != "RESULT": # this must be a RESULT now
sys.exit("%i: expected RESULT after %s" % (line_number, str(call_list)))
RESULT = text[2] # resulting module name
if RESULT == "__main__": # skip current script
return
res_file = text[3] # resulting file name
if res_file == "built-in": # skip output for built-in stuff
return
if res_file.endswith(".dll"): # special handling for pythoncom and friends
res_file = RESULT + ".py"
if RESULT.startswith("win32com"): # special handling for win32com
res_file = "$PYTHONPATH\\win32com\\__init__.py"
if trace_logic:
print(line_number, ":", str(call_list))
print(line_number, ":", str(text))
normalized_file = normalize_file(res_file)
write_file(normalized_file)
if not matching:
print("No result matches %i, %s, %s" % (level, CALLED, str(implist)))
write_mod(RESULT, normalized_file) # this is a sure output
# members of shared modules cannot be filtered out, so allow them all
if (
hasFilenameExtension(res_file, getSharedLibrarySuffix()) # a shared module!
or normalized_file in accept_always
):
write_mod(RESULT + ".*", normalized_file)
return
if not CALLED: # case: the CALL name is empty
if not implist: # should not happen, but let's ignore this
return
for item in implist: # return RESULT.item for items in list
write_mod(RESULT + "." + item, normalized_file)
return
if (
CALLED.startswith(RESULT)
or RESULT.startswith(CALLED)
or RESULT.endswith(CALLED)
):
# CALL and RESULT names contain each other in some way
if not implist:
if CALLED != RESULT:
write_mod(CALLED, normalized_file)
return
if CALLED == RESULT:
cmod = CALLED
elif RESULT.endswith(CALLED):
cmod = RESULT
elif RESULT.startswith(CALLED):
cmod = RESULT
else:
cmod = CALLED
for item in implist: # this is a list of items
write_mod(cmod + "." + item, normalized_file)
return
""" Case:
RESULT and CALL names neither contain each other, nor is CALLED empty.
We then assume that the true call name should be RESULT.CALLED in output.
"""
cmod = RESULT + "." + CALLED # equals RESULT.CALLED
write_mod(cmod, normalized_file) # output it
if not implist: # no list there: done
return
for item in implist: # or again a list of items
write_mod(cmod + "." + item, normalized_file)
return
