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