# This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/.
import functools import os import shutil import subprocess import sys
import buildconfig
def relativize(path, base=None): # For absolute path in Unix builds, we need relative paths because # Windows programs run via Wine don't like these Unix absolute paths # (they look like command line arguments). if path.startswith("/"): return os.path.relpath(path, base) # For Windows absolute paths, we can just use the unmodified path. # And if the path starts with '-', it's a command line argument. if os.path.isabs(path) or path.startswith("-"): return path # Remaining case is relative paths, which may be relative to a different # directory (os.getcwd()) than the needed `base`, so we "rebase" it. return os.path.relpath(path, base)
@functools.lru_cache(maxsize=None) def files_in(path): return {p.lower(): os.path.join(path, p) for p in os.listdir(path)}
def search_path(paths, path): for p in paths:
f = os.path.join(p, path) if os.path.isfile(f): return f # try an case-insensitive match
maybe_match = files_in(p).get(path.lower()) if maybe_match: return maybe_match raise RuntimeError(f"Cannot find {path}")
# Filter-out -std= flag from the preprocessor command, as we're not preprocessing # C or C++, and the command would fail with the flag. def filter_preprocessor(cmd):
prev = None for arg in cmd: if arg == "-Xclang":
prev = arg continue ifnot arg.startswith("-std="): if prev: yield prev yield arg
prev = None
# Preprocess all the direct and indirect inputs of midl, and put all the # preprocessed inputs in the given `base` directory. Returns a tuple containing # the path of the main preprocessed input, and the modified flags to use instead # of the flags given as argument. def preprocess(base, input, flags): import argparse import re from collections import deque
IMPORT_RE = re.compile(r'import\s*"([^"]+)";')
parser = argparse.ArgumentParser()
parser.add_argument("-I", action="append")
parser.add_argument("-D", action="append")
parser.add_argument("-acf")
args, remainder = parser.parse_known_args(flags)
preprocessor = (
list(filter_preprocessor(buildconfig.substs["CXXCPP"])) # Ideally we'd use the real midl version, but querying it adds a # significant overhead to configure. In practice, the version number # doesn't make a difference at the moment.
+ ["-D__midl=801"]
+ [f"-D{d}"for d in args.D or ()]
+ [f"-I{i}"for i in args.I or ()]
)
includes = ["."] + buildconfig.substs["INCLUDE"].split(";") + (args.I or [])
seen = set()
queue = deque([input]) if args.acf:
queue.append(args.acf)
output = os.path.join(base, os.path.basename(input)) whileTrue: try:
input = queue.popleft() except IndexError: break if os.path.basename(input) in seen: continue
seen.add(os.path.basename(input))
input = search_path(includes, input) # If there is a .acf file corresponding to the .idl we're processing, # we also want to preprocess that file because midl might look for it too. if input.lower().endswith(".idl"): try:
acf = search_path(
[os.path.dirname(input)], os.path.basename(input)[:-4] + ".acf"
) if acf:
queue.append(acf) except RuntimeError: pass
command = preprocessor + [input]
preprocessed = os.path.join(base, os.path.basename(input))
subprocess.run(command, stdout=open(preprocessed, "wb"), check=True) # Read the resulting file, and search for imports, that we'll want to # preprocess as well. with open(preprocessed, "r") as fh: for line in fh: ifnot line.startswith("import"): continue
m = IMPORT_RE.match(line) ifnot m: continue
imp = m.group(1)
queue.append(imp)
flags = [] # Add -I<base> first in the flags, so that midl resolves imports to the # preprocessed files we created. for i in [base] + (args.I or []):
flags.extend(["-I", i]) # Add the preprocessed acf file if one was given on the command line. if args.acf:
flags.extend(["-acf", os.path.join(base, os.path.basename(args.acf))])
flags.extend(remainder) return output, flags
def midl(out, input, *flags):
out.avoid_writing_to_file()
midl_flags = buildconfig.substs["MIDL_FLAGS"]
base = os.path.dirname(out.name) or"."
tmpdir = None try: # If the build system is asking to not use the preprocessor to midl, # we need to do the preprocessing ourselves. if"-no_cpp"in midl_flags: # Normally, we'd use tempfile.TemporaryDirectory, but in this specific # case, we actually want a deterministic directory name, because it's # recorded in the code midl generates.
tmpdir = os.path.join(base, os.path.basename(input) + ".tmp")
os.makedirs(tmpdir, exist_ok=True) try:
input, flags = preprocess(tmpdir, input, flags) except subprocess.CalledProcessError as e: return e.returncode
midl = buildconfig.substs["MIDL"]
wine = buildconfig.substs.get("WINE") if midl.lower().endswith(".exe") and wine:
command = [wine, midl] else:
command = [midl]
command.extend(midl_flags)
command.extend([relativize(f, base) for f in flags])
command.append("-Oicf")
command.append(relativize(input, base))
print("Executing:", " ".join(command))
result = subprocess.run(command, cwd=base) return result.returncode finally: if tmpdir:
shutil.rmtree(tmpdir)
# midl outputs dlldata to a single dlldata.c file by default. This prevents running # midl in parallel in the same directory for idl files that would generate dlldata.c # because of race conditions updating the file. Instead, we ask midl to create # separate files, and we merge them manually. def merge_dlldata(out, *inputs):
inputs = [open(i) for i in inputs]
read_a_line = [True] * len(inputs) whileTrue:
lines = [
f.readline() if read_a_line[n] else lines[n] for n, f in enumerate(inputs)
]
unique_lines = set(lines) if len(unique_lines) == 1: # All the lines are identical ifnot lines[0]: break
out.write(lines[0])
read_a_line = [True] * len(inputs) elif (
len(unique_lines) == 2 and len([l for l in unique_lines if"#define" in l]) == 1
): # Most lines are identical. When they aren't, it's typically because some # files have an extra #define that others don't. When that happens, we # print out the #define, and get a new input line from the files that had # a #define on the next iteration. We expect that next line to match what # the other files had on this iteration. # Note: we explicitly don't support the case where there are different # defines across different files, except when there's a different one # for each file, in which case it's handled further below.
a = unique_lines.pop() if"#define" in a:
out.write(a) else:
out.write(unique_lines.pop())
read_a_line = ["#define" in l for l in lines] elif len(unique_lines) != len(lines): # If for some reason, we don't get lines that are entirely different # from each other, we have some unexpected input.
print( "Error while merging dlldata. Last lines read: {}".format(lines),
file=sys.stderr,
) return 1 else: for line in lines:
out.write(line)
read_a_line = [True] * len(inputs)
return 0
¤ Dauer der Verarbeitung: 0.14 Sekunden
(vorverarbeitet)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
