--- /dev/null
+#!/usr/bin/env python3
+# ################################################################
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under both the BSD-style license (found in the
+# LICENSE file in the root directory of this source tree) and the GPLv2 (found
+# in the COPYING file in the root directory of this source tree).
+# You may select, at your option, one of the above-listed licenses.
+# ##########################################################################
+
+import argparse
+import contextlib
+import os
+import re
+import shutil
+import sys
+from typing import Optional
+
+
+INCLUDED_SUBDIRS = ["common", "compress", "decompress"]
+
+SKIPPED_FILES = [
+ "common/mem.h",
+ "common/zstd_deps.h",
+ "common/pool.c",
+ "common/pool.h",
+ "common/threading.c",
+ "common/threading.h",
+ "common/zstd_trace.h",
+ "compress/zstdmt_compress.h",
+ "compress/zstdmt_compress.c",
+]
+
+XXHASH_FILES = [
+ "common/xxhash.c",
+ "common/xxhash.h",
+]
+
+
+class FileLines(object):
+ def __init__(self, filename):
+ self.filename = filename
+ with open(self.filename, "r") as f:
+ self.lines = f.readlines()
+
+ def write(self):
+ with open(self.filename, "w") as f:
+ f.write("".join(self.lines))
+
+
+class PartialPreprocessor(object):
+ """
+ Looks for simple ifdefs and ifndefs and replaces them.
+ Handles && and ||.
+ Has fancy logic to handle translating elifs to ifs.
+ Only looks for macros in the first part of the expression with no
+ parens.
+ Does not handle multi-line macros (only looks in first line).
+ """
+ def __init__(self, defs: [(str, Optional[str])], replaces: [(str, str)], undefs: [str]):
+ MACRO_GROUP = r"(?P<macro>[a-zA-Z_][a-zA-Z_0-9]*)"
+ ELIF_GROUP = r"(?P<elif>el)?"
+ OP_GROUP = r"(?P<op>&&|\|\|)?"
+
+ self._defs = {macro:value for macro, value in defs}
+ self._replaces = {macro:value for macro, value in replaces}
+ self._defs.update(self._replaces)
+ self._undefs = set(undefs)
+
+ self._define = re.compile(r"\s*#\s*define")
+ self._if = re.compile(r"\s*#\s*if")
+ self._elif = re.compile(r"\s*#\s*(?P<elif>el)if")
+ self._else = re.compile(r"\s*#\s*(?P<else>else)")
+ self._endif = re.compile(r"\s*#\s*endif")
+
+ self._ifdef = re.compile(fr"\s*#\s*if(?P<not>n)?def {MACRO_GROUP}\s*")
+ self._if_defined = re.compile(
+ fr"\s*#\s*{ELIF_GROUP}if\s+(?P<not>!)?\s*defined\s*\(\s*{MACRO_GROUP}\s*\)\s*{OP_GROUP}"
+ )
+ self._if_defined_value = re.compile(
+ fr"\s*#\s*{ELIF_GROUP}if\s+defined\s*\(\s*{MACRO_GROUP}\s*\)\s*"
+ fr"(?P<op>&&)\s*"
+ fr"(?P<openp>\()?\s*"
+ fr"(?P<macro2>[a-zA-Z_][a-zA-Z_0-9]*)\s*"
+ fr"(?P<cmp>[=><!]+)\s*"
+ fr"(?P<value>[0-9]*)\s*"
+ fr"(?P<closep>\))?\s*"
+ )
+ self._if_true = re.compile(
+ fr"\s*#\s*{ELIF_GROUP}if\s+{MACRO_GROUP}\s*{OP_GROUP}"
+ )
+
+ self._c_comment = re.compile(r"/\*.*?\*/")
+ self._cpp_comment = re.compile(r"//")
+
+ def _log(self, *args, **kwargs):
+ print(*args, **kwargs)
+
+ def _strip_comments(self, line):
+ # First strip c-style comments (may include //)
+ while True:
+ m = self._c_comment.search(line)
+ if m is None:
+ break
+ line = line[:m.start()] + line[m.end():]
+
+ # Then strip cpp-style comments
+ m = self._cpp_comment.search(line)
+ if m is not None:
+ line = line[:m.start()]
+
+ return line
+
+ def _fixup_indentation(self, macro, replace: [str]):
+ if len(replace) == 0:
+ return replace
+ if len(replace) == 1 and self._define.match(replace[0]) is None:
+ # If there is only one line, only replace defines
+ return replace
+
+
+ all_pound = True
+ for line in replace:
+ if not line.startswith('#'):
+ all_pound = False
+ if all_pound:
+ replace = [line[1:] for line in replace]
+
+ min_spaces = len(replace[0])
+ for line in replace:
+ spaces = 0
+ for i, c in enumerate(line):
+ if c != ' ':
+ # Non-preprocessor line ==> skip the fixup
+ if not all_pound and c != '#':
+ return replace
+ spaces = i
+ break
+ min_spaces = min(min_spaces, spaces)
+
+ replace = [line[min_spaces:] for line in replace]
+
+ if all_pound:
+ replace = ["#" + line for line in replace]
+
+ return replace
+
+ def _handle_if_block(self, macro, idx, is_true, prepend):
+ """
+ Remove the #if or #elif block starting on this line.
+ """
+ REMOVE_ONE = 0
+ KEEP_ONE = 1
+ REMOVE_REST = 2
+
+ if is_true:
+ state = KEEP_ONE
+ else:
+ state = REMOVE_ONE
+
+ line = self._inlines[idx]
+ is_if = self._if.match(line) is not None
+ assert is_if or self._elif.match(line) is not None
+ depth = 0
+
+ start_idx = idx
+
+ idx += 1
+ replace = prepend
+ finished = False
+ while idx < len(self._inlines):
+ line = self._inlines[idx]
+ # Nested if statement
+ if self._if.match(line):
+ depth += 1
+ idx += 1
+ continue
+ # We're inside a nested statement
+ if depth > 0:
+ if self._endif.match(line):
+ depth -= 1
+ idx += 1
+ continue
+
+ # We're at the original depth
+
+ # Looking only for an endif.
+ # We've found a true statement, but haven't
+ # completely elided the if block, so we just
+ # remove the remainder.
+ if state == REMOVE_REST:
+ if self._endif.match(line):
+ if is_if:
+ # Remove the endif because we took the first if
+ idx += 1
+ finished = True
+ break
+ idx += 1
+ continue
+
+ if state == KEEP_ONE:
+ m = self._elif.match(line)
+ if self._endif.match(line):
+ replace += self._inlines[start_idx + 1:idx]
+ idx += 1
+ finished = True
+ break
+ if self._elif.match(line) or self._else.match(line):
+ replace += self._inlines[start_idx + 1:idx]
+ state = REMOVE_REST
+ idx += 1
+ continue
+
+ if state == REMOVE_ONE:
+ m = self._elif.match(line)
+ if m is not None:
+ if is_if:
+ idx += 1
+ b = m.start('elif')
+ e = m.end('elif')
+ assert e - b == 2
+ replace.append(line[:b] + line[e:])
+ finished = True
+ break
+ m = self._else.match(line)
+ if m is not None:
+ if is_if:
+ idx += 1
+ while self._endif.match(self._inlines[idx]) is None:
+ replace.append(self._inlines[idx])
+ idx += 1
+ idx += 1
+ finished = True
+ break
+ if self._endif.match(line):
+ if is_if:
+ # Remove the endif because no other elifs
+ idx += 1
+ finished = True
+ break
+ idx += 1
+ continue
+ if not finished:
+ raise RuntimeError("Unterminated if block!")
+
+ replace = self._fixup_indentation(macro, replace)
+
+ self._log(f"\tHardwiring {macro}")
+ if start_idx > 0:
+ self._log(f"\t\t {self._inlines[start_idx - 1][:-1]}")
+ for x in range(start_idx, idx):
+ self._log(f"\t\t- {self._inlines[x][:-1]}")
+ for line in replace:
+ self._log(f"\t\t+ {line[:-1]}")
+ if idx < len(self._inlines):
+ self._log(f"\t\t {self._inlines[idx][:-1]}")
+
+ return idx, replace
+
+ def _preprocess_once(self):
+ outlines = []
+ idx = 0
+ changed = False
+ while idx < len(self._inlines):
+ line = self._inlines[idx]
+ sline = self._strip_comments(line)
+ m = self._ifdef.fullmatch(sline)
+ if_true = False
+ if m is None:
+ m = self._if_defined_value.fullmatch(sline)
+ if m is None:
+ m = self._if_defined.match(sline)
+ if m is None:
+ m = self._if_true.match(sline)
+ if_true = (m is not None)
+ if m is None:
+ outlines.append(line)
+ idx += 1
+ continue
+
+ groups = m.groupdict()
+ macro = groups['macro']
+ op = groups.get('op')
+
+ if not (macro in self._defs or macro in self._undefs):
+ outlines.append(line)
+ idx += 1
+ continue
+
+ defined = macro in self._defs
+
+ # Needed variables set:
+ # resolved: Is the statement fully resolved?
+ # is_true: If resolved, is the statement true?
+ ifdef = False
+ if if_true:
+ if not defined:
+ outlines.append(line)
+ idx += 1
+ continue
+
+ defined_value = self._defs[macro]
+ is_int = True
+ try:
+ defined_value = int(defined_value)
+ except TypeError:
+ is_int = False
+ except ValueError:
+ is_int = False
+
+ resolved = is_int
+ is_true = (defined_value != 0)
+
+ if resolved and op is not None:
+ if op == '&&':
+ resolved = not is_true
+ else:
+ assert op == '||'
+ resolved = is_true
+
+ else:
+ ifdef = groups.get('not') is None
+ elseif = groups.get('elif') is not None
+
+ macro2 = groups.get('macro2')
+ cmp = groups.get('cmp')
+ value = groups.get('value')
+ openp = groups.get('openp')
+ closep = groups.get('closep')
+
+ is_true = (ifdef == defined)
+ resolved = True
+ if op is not None:
+ if op == '&&':
+ resolved = not is_true
+ else:
+ assert op == '||'
+ resolved = is_true
+
+ if macro2 is not None and not resolved:
+ assert ifdef and defined and op == '&&' and cmp is not None
+ # If the statement is true, but we have a single value check, then
+ # check the value.
+ defined_value = self._defs[macro]
+ are_ints = True
+ try:
+ defined_value = int(defined_value)
+ value = int(value)
+ except TypeError:
+ are_ints = False
+ except ValueError:
+ are_ints = False
+ if (
+ macro == macro2 and
+ ((openp is None) == (closep is None)) and
+ are_ints
+ ):
+ resolved = True
+ if cmp == '<':
+ is_true = defined_value < value
+ elif cmp == '<=':
+ is_true = defined_value <= value
+ elif cmp == '==':
+ is_true = defined_value == value
+ elif cmp == '!=':
+ is_true = defined_value != value
+ elif cmp == '>=':
+ is_true = defined_value >= value
+ elif cmp == '>':
+ is_true = defined_value > value
+ else:
+ resolved = False
+
+ if op is not None and not resolved:
+ # Remove the first op in the line + spaces
+ if op == '&&':
+ opre = op
+ else:
+ assert op == '||'
+ opre = r'\|\|'
+ needle = re.compile(fr"(?P<if>\s*#\s*(el)?if\s+).*?(?P<op>{opre}\s*)")
+ match = needle.match(line)
+ assert match is not None
+ newline = line[:match.end('if')] + line[match.end('op'):]
+
+ self._log(f"\tHardwiring partially resolved {macro}")
+ self._log(f"\t\t- {line[:-1]}")
+ self._log(f"\t\t+ {newline[:-1]}")
+
+ outlines.append(newline)
+ idx += 1
+ continue
+
+ # Skip any statements we cannot fully compute
+ if not resolved:
+ outlines.append(line)
+ idx += 1
+ continue
+
+ prepend = []
+ if macro in self._replaces:
+ assert not ifdef
+ assert op is None
+ value = self._replaces.pop(macro)
+ prepend = [f"#define {macro} {value}\n"]
+
+ idx, replace = self._handle_if_block(macro, idx, is_true, prepend)
+ outlines += replace
+ changed = True
+
+ return changed, outlines
+
+ def preprocess(self, filename):
+ with open(filename, 'r') as f:
+ self._inlines = f.readlines()
+ changed = True
+ iters = 0
+ while changed:
+ iters += 1
+ changed, outlines = self._preprocess_once()
+ self._inlines = outlines
+
+ with open(filename, 'w') as f:
+ f.write(''.join(self._inlines))
+
+
+class Freestanding(object):
+ def __init__(
+ self, zstd_deps: str, mem: str, source_lib: str, output_lib: str,
+ external_xxhash: bool, xxh64_state: Optional[str],
+ xxh64_prefix: Optional[str], rewritten_includes: [(str, str)],
+ defs: [(str, Optional[str])], replaces: [(str, str)],
+ undefs: [str], excludes: [str], seds: [str], spdx: bool,
+ ):
+ self._zstd_deps = zstd_deps
+ self._mem = mem
+ self._src_lib = source_lib
+ self._dst_lib = output_lib
+ self._external_xxhash = external_xxhash
+ self._xxh64_state = xxh64_state
+ self._xxh64_prefix = xxh64_prefix
+ self._rewritten_includes = rewritten_includes
+ self._defs = defs
+ self._replaces = replaces
+ self._undefs = undefs
+ self._excludes = excludes
+ self._seds = seds
+ self._spdx = spdx
+
+ def _dst_lib_file_paths(self):
+ """
+ Yields all the file paths in the dst_lib.
+ """
+ for root, dirname, filenames in os.walk(self._dst_lib):
+ for filename in filenames:
+ filepath = os.path.join(root, filename)
+ yield filepath
+
+ def _log(self, *args, **kwargs):
+ print(*args, **kwargs)
+
+ def _copy_file(self, lib_path):
+ suffixes = [".c", ".h", ".S"]
+ if not any((lib_path.endswith(suffix) for suffix in suffixes)):
+ return
+ if lib_path in SKIPPED_FILES:
+ self._log(f"\tSkipping file: {lib_path}")
+ return
+ if self._external_xxhash and lib_path in XXHASH_FILES:
+ self._log(f"\tSkipping xxhash file: {lib_path}")
+ return
+
+ src_path = os.path.join(self._src_lib, lib_path)
+ dst_path = os.path.join(self._dst_lib, lib_path)
+ self._log(f"\tCopying: {src_path} -> {dst_path}")
+ shutil.copyfile(src_path, dst_path)
+
+ def _copy_source_lib(self):
+ self._log("Copying source library into output library")
+
+ assert os.path.exists(self._src_lib)
+ os.makedirs(self._dst_lib, exist_ok=True)
+ self._copy_file("zstd.h")
+ self._copy_file("zstd_errors.h")
+ for subdir in INCLUDED_SUBDIRS:
+ src_dir = os.path.join(self._src_lib, subdir)
+ dst_dir = os.path.join(self._dst_lib, subdir)
+
+ assert os.path.exists(src_dir)
+ os.makedirs(dst_dir, exist_ok=True)
+
+ for filename in os.listdir(src_dir):
+ lib_path = os.path.join(subdir, filename)
+ self._copy_file(lib_path)
+
+ def _copy_zstd_deps(self):
+ dst_zstd_deps = os.path.join(self._dst_lib, "common", "zstd_deps.h")
+ self._log(f"Copying zstd_deps: {self._zstd_deps} -> {dst_zstd_deps}")
+ shutil.copyfile(self._zstd_deps, dst_zstd_deps)
+
+ def _copy_mem(self):
+ dst_mem = os.path.join(self._dst_lib, "common", "mem.h")
+ self._log(f"Copying mem: {self._mem} -> {dst_mem}")
+ shutil.copyfile(self._mem, dst_mem)
+
+ def _hardwire_preprocessor(self, name: str, value: Optional[str] = None, undef=False):
+ """
+ If value=None then hardwire that it is defined, but not what the value is.
+ If undef=True then value must be None.
+ If value='' then the macro is defined to '' exactly.
+ """
+ assert not (undef and value is not None)
+ for filepath in self._dst_lib_file_paths():
+ file = FileLines(filepath)
+
+ def _hardwire_defines(self):
+ self._log("Hardwiring macros")
+ partial_preprocessor = PartialPreprocessor(self._defs, self._replaces, self._undefs)
+ for filepath in self._dst_lib_file_paths():
+ partial_preprocessor.preprocess(filepath)
+
+ def _remove_excludes(self):
+ self._log("Removing excluded sections")
+ for exclude in self._excludes:
+ self._log(f"\tRemoving excluded sections for: {exclude}")
+ begin_re = re.compile(f"BEGIN {exclude}")
+ end_re = re.compile(f"END {exclude}")
+ for filepath in self._dst_lib_file_paths():
+ file = FileLines(filepath)
+ outlines = []
+ skipped = []
+ emit = True
+ for line in file.lines:
+ if emit and begin_re.search(line) is not None:
+ assert end_re.search(line) is None
+ emit = False
+ if emit:
+ outlines.append(line)
+ else:
+ skipped.append(line)
+ if end_re.search(line) is not None:
+ assert begin_re.search(line) is None
+ self._log(f"\t\tRemoving excluded section: {exclude}")
+ for s in skipped:
+ self._log(f"\t\t\t- {s}")
+ emit = True
+ skipped = []
+ if not emit:
+ raise RuntimeError("Excluded section unfinished!")
+ file.lines = outlines
+ file.write()
+
+ def _rewrite_include(self, original, rewritten):
+ self._log(f"\tRewriting include: {original} -> {rewritten}")
+ regex = re.compile(f"\\s*#\\s*include\\s*(?P<include>{original})")
+ for filepath in self._dst_lib_file_paths():
+ file = FileLines(filepath)
+ for i, line in enumerate(file.lines):
+ match = regex.match(line)
+ if match is None:
+ continue
+ s = match.start('include')
+ e = match.end('include')
+ file.lines[i] = line[:s] + rewritten + line[e:]
+ file.write()
+
+ def _rewrite_includes(self):
+ self._log("Rewriting includes")
+ for original, rewritten in self._rewritten_includes:
+ self._rewrite_include(original, rewritten)
+
+ def _replace_xxh64_prefix(self):
+ if self._xxh64_prefix is None:
+ return
+ self._log(f"Replacing XXH64 prefix with {self._xxh64_prefix}")
+ replacements = []
+ if self._xxh64_state is not None:
+ replacements.append(
+ (re.compile(r"([^\w]|^)(?P<orig>XXH64_state_t)([^\w]|$)"), self._xxh64_state)
+ )
+ if self._xxh64_prefix is not None:
+ replacements.append(
+ (re.compile(r"([^\w]|^)(?P<orig>XXH64)[\(_]"), self._xxh64_prefix)
+ )
+ for filepath in self._dst_lib_file_paths():
+ file = FileLines(filepath)
+ for i, line in enumerate(file.lines):
+ modified = False
+ for regex, replacement in replacements:
+ match = regex.search(line)
+ while match is not None:
+ modified = True
+ b = match.start('orig')
+ e = match.end('orig')
+ line = line[:b] + replacement + line[e:]
+ match = regex.search(line)
+ if modified:
+ self._log(f"\t- {file.lines[i][:-1]}")
+ self._log(f"\t+ {line[:-1]}")
+ file.lines[i] = line
+ file.write()
+
+ def _parse_sed(self, sed):
+ assert sed[0] == 's'
+ delim = sed[1]
+ match = re.fullmatch(f's{delim}(.+){delim}(.*){delim}(.*)', sed)
+ assert match is not None
+ regex = re.compile(match.group(1))
+ format_str = match.group(2)
+ is_global = match.group(3) == 'g'
+ return regex, format_str, is_global
+
+ def _process_sed(self, sed):
+ self._log(f"Processing sed: {sed}")
+ regex, format_str, is_global = self._parse_sed(sed)
+
+ for filepath in self._dst_lib_file_paths():
+ file = FileLines(filepath)
+ for i, line in enumerate(file.lines):
+ modified = False
+ while True:
+ match = regex.search(line)
+ if match is None:
+ break
+ replacement = format_str.format(match.groups(''), match.groupdict(''))
+ b = match.start()
+ e = match.end()
+ line = line[:b] + replacement + line[e:]
+ modified = True
+ if not is_global:
+ break
+ if modified:
+ self._log(f"\t- {file.lines[i][:-1]}")
+ self._log(f"\t+ {line[:-1]}")
+ file.lines[i] = line
+ file.write()
+
+ def _process_seds(self):
+ self._log("Processing seds")
+ for sed in self._seds:
+ self._process_sed(sed)
+
+ def _process_spdx(self):
+ if not self._spdx:
+ return
+ self._log("Processing spdx")
+ SPDX_C = "// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause\n"
+ SPDX_H_S = "/* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */\n"
+ for filepath in self._dst_lib_file_paths():
+ file = FileLines(filepath)
+ if file.lines[0] == SPDX_C or file.lines[0] == SPDX_H_S:
+ continue
+ for line in file.lines:
+ if "SPDX-License-Identifier" in line:
+ raise RuntimeError(f"Unexpected SPDX license identifier: {file.filename} {repr(line)}")
+ if file.filename.endswith(".c"):
+ file.lines.insert(0, SPDX_C)
+ elif file.filename.endswith(".h") or file.filename.endswith(".S"):
+ file.lines.insert(0, SPDX_H_S)
+ else:
+ raise RuntimeError(f"Unexpected file extension: {file.filename}")
+ file.write()
+
+
+
+ def go(self):
+ self._copy_source_lib()
+ self._copy_zstd_deps()
+ self._copy_mem()
+ self._hardwire_defines()
+ self._remove_excludes()
+ self._rewrite_includes()
+ self._replace_xxh64_prefix()
+ self._process_seds()
+ self._process_spdx()
+
+
+def parse_optional_pair(defines: [str]) -> [(str, Optional[str])]:
+ output = []
+ for define in defines:
+ parsed = define.split('=')
+ if len(parsed) == 1:
+ output.append((parsed[0], None))
+ elif len(parsed) == 2:
+ output.append((parsed[0], parsed[1]))
+ else:
+ raise RuntimeError(f"Bad define: {define}")
+ return output
+
+
+def parse_pair(rewritten_includes: [str]) -> [(str, str)]:
+ output = []
+ for rewritten_include in rewritten_includes:
+ parsed = rewritten_include.split('=')
+ if len(parsed) == 2:
+ output.append((parsed[0], parsed[1]))
+ else:
+ raise RuntimeError(f"Bad rewritten include: {rewritten_include}")
+ return output
+
+
+
+def main(name, args):
+ parser = argparse.ArgumentParser(prog=name)
+ parser.add_argument("--zstd-deps", default="zstd_deps.h", help="Zstd dependencies file")
+ parser.add_argument("--mem", default="mem.h", help="Memory module")
+ parser.add_argument("--source-lib", default="../../lib", help="Location of the zstd library")
+ parser.add_argument("--output-lib", default="./freestanding_lib", help="Where to output the freestanding zstd library")
+ parser.add_argument("--xxhash", default=None, help="Alternate external xxhash include e.g. --xxhash='<xxhash.h>'. If set xxhash is not included.")
+ parser.add_argument("--xxh64-state", default=None, help="Alternate XXH64 state type (excluding _) e.g. --xxh64-state='struct xxh64_state'")
+ parser.add_argument("--xxh64-prefix", default=None, help="Alternate XXH64 function prefix (excluding _) e.g. --xxh64-prefix=xxh64")
+ parser.add_argument("--rewrite-include", default=[], dest="rewritten_includes", action="append", help="Rewrite an include REGEX=NEW (e.g. '<stddef\\.h>=<linux/types.h>')")
+ parser.add_argument("--sed", default=[], dest="seds", action="append", help="Apply a sed replacement. Format: `s/REGEX/FORMAT/[g]`. REGEX is a Python regex. FORMAT is a Python format string formatted by the regex dict.")
+ parser.add_argument("--spdx", action="store_true", help="Add SPDX License Identifiers")
+ parser.add_argument("-D", "--define", default=[], dest="defs", action="append", help="Pre-define this macro (can be passed multiple times)")
+ parser.add_argument("-U", "--undefine", default=[], dest="undefs", action="append", help="Pre-undefine this macro (can be passed multiple times)")
+ parser.add_argument("-R", "--replace", default=[], dest="replaces", action="append", help="Pre-define this macro and replace the first ifndef block with its definition")
+ parser.add_argument("-E", "--exclude", default=[], dest="excludes", action="append", help="Exclude all lines between 'BEGIN <EXCLUDE>' and 'END <EXCLUDE>'")
+ args = parser.parse_args(args)
+
+ # Always remove threading
+ if "ZSTD_MULTITHREAD" not in args.undefs:
+ args.undefs.append("ZSTD_MULTITHREAD")
+
+ args.defs = parse_optional_pair(args.defs)
+ for name, _ in args.defs:
+ if name in args.undefs:
+ raise RuntimeError(f"{name} is both defined and undefined!")
+
+ # Always set tracing to 0
+ if "ZSTD_NO_TRACE" not in (arg[0] for arg in args.defs):
+ args.defs.append(("ZSTD_NO_TRACE", None))
+ args.defs.append(("ZSTD_TRACE", "0"))
+
+ args.replaces = parse_pair(args.replaces)
+ for name, _ in args.replaces:
+ if name in args.undefs or name in args.defs:
+ raise RuntimeError(f"{name} is both replaced and (un)defined!")
+
+ args.rewritten_includes = parse_pair(args.rewritten_includes)
+
+ external_xxhash = False
+ if args.xxhash is not None:
+ external_xxhash = True
+ args.rewritten_includes.append(('"(\\.\\./common/)?xxhash.h"', args.xxhash))
+
+ if args.xxh64_prefix is not None:
+ if not external_xxhash:
+ raise RuntimeError("--xxh64-prefix may only be used with --xxhash provided")
+
+ if args.xxh64_state is not None:
+ if not external_xxhash:
+ raise RuntimeError("--xxh64-state may only be used with --xxhash provided")
+
+ Freestanding(
+ args.zstd_deps,
+ args.mem,
+ args.source_lib,
+ args.output_lib,
+ external_xxhash,
+ args.xxh64_state,
+ args.xxh64_prefix,
+ args.rewritten_includes,
+ args.defs,
+ args.replaces,
+ args.undefs,
+ args.excludes,
+ args.seds,
+ args.spdx,
+ ).go()
+
+if __name__ == "__main__":
+ main(sys.argv[0], sys.argv[1:])
notaz.gp2x.de / pcsx_rearmed.git / blobdiff