#!/usr/bin/python
# encoding: UTF-8
import codecs
import collections
import functools
import os
import re
import stat
import sys
import tempfile
import traceback
import subprocess as sp
from pygnulib.error import CommandLineError
from pygnulib.error import UnknownModuleError
from pygnulib.config import BaseConfig
from pygnulib.config import CachedConfig
from pygnulib.config import LGPL_LICENSES
from pygnulib.config import LGPLv3_LICENSE
from pygnulib.config import LGPLv2_LICENSE
from pygnulib.config import GPLv2_LICENSE
from pygnulib.generator import gnulib_cache
from pygnulib.generator import gnulib_comp
from pygnulib.generator import lib_makefile
from pygnulib.generator import po_make_vars
from pygnulib.generator import tests_makefile
from pygnulib.module import DummyModule
from pygnulib.module import Database
from pygnulib.parser import CommandLine as CommandLineParser
from pygnulib.misc import Executable
from pygnulib.vfs import BaseVFS
from pygnulib.vfs import GnulibGitVFS
from pygnulib.vfs import backup as vfs_backup
from pygnulib.vfs import compare as vfs_compare
from pygnulib.vfs import copy as vfs_copy
from pygnulib.vfs import exists as vfs_exists
from pygnulib.vfs import hardlink as vfs_hardlink
from pygnulib.vfs import lookup as vfs_lookup
from pygnulib.vfs import move as vfs_move
from pygnulib.vfs import iostream as vfs_iostream
from pygnulib.vfs import symlink as vfs_symlink
from pygnulib.vfs import unlink as vfs_unlink
class GnulibExecutable(Executable):
def __init__(self, name, var, prefix, environ=os.environ, encoding=None):
if not isinstance(var, str):
raise TypeError("var: str expected")
if not isinstance(prefix, str):
raise TypeError("prefix: str expected")
var = environ.get(var, None)
prefix = environ.get(prefix, None)
path = os.path.normpath(name)
if not var and prefix:
path = f"{prefix}{path}"
elif var and not prefix:
path = os.path.normpath(var)
super().__init__(path=path, encoding=encoding)
AUTOCONF = GnulibExecutable("autoconf", "AUTOCONF", "AUTOCONFPATH")
AUTOHEADER = GnulibExecutable("autoheader", "AUTOHEADER", "AUTOCONFPATH")
ACLOCAL = GnulibExecutable("aclocal", "ACLOCAL", "AUTOMAKEPATH")
AUTOMAKE = GnulibExecutable("automake", "AUTOMAKE", "AUTOMAKEPATH")
AUTORECONF = GnulibExecutable("autoreconf", "AUTORECONF", "AUTOCONFPATH")
LIBTOOLIZE = GnulibExecutable("libtoolize", "LIBTOOLIZE", "LIBTOOLPATH")
RSYNC = GnulibExecutable("rsync", "RSYNC", "RSYNCPATH")
WGET = GnulibExecutable("wget", "WGET", "WGETPATH")
PATCH = GnulibExecutable("patch", "PATCH", "PATCHPATH")
SUBSTITUTION = {
"build-aux": "auxdir",
"doc": "doc_base",
"lib": "source_base",
"m4": "m4_base",
"tests": "tests_base",
"tests=lib": "tests_base",
"po": "po_base",
"top": "",
}
EXECUTABLES = {
"AUTOCONF": "AUTOCONFPATH",
"AUTOHEADER": "AUTOCONFPATH",
"ACLOCAL": "AUTOMAKEPATH",
"AUTOMAKE": "AUTOMAKEPATH",
"AUTORECONF": "AUTOCONFPATH",
"LIBTOOLIZE": "LIBTOOLPATH",
}
for (_var, _prefix) in tuple(EXECUTABLES.items()):
_name = _var.lower()
del EXECUTABLES[_var]
EXECUTABLES[_name] = GnulibExecutable(_name, _var, _prefix)
TP_URL = "http://translationproject.org/latest/"
TP_RSYNC_URI = "translationproject.org::tp/latest/"
def list_hook(gnulib, *args, **kwargs):
(_, _) = (args, kwargs)
for module in sorted(gnulib.modules()):
print(module.name, file=sys.stdout)
return os.EX_OK
def extract_hook(program, gnulib, mode, namespace, *args, **kwargs):
(_, _) = (args, kwargs)
mode = mode.replace("extract-", "")
mode += "s" if mode == "maintainer" else ""
for module in namespace["modules"]:
try:
module = gnulib.module(module)
print(module[mode], file=sys.stdout)
except UnknownModuleError as error:
print("{0}:".format(program), "warning:", error, file=sys.stderr)
return os.EX_OK
def import_hook(script, gnulib, namespace, explicit, verbosity, options, *args, **kwargs):
(_, _) = (args, kwargs)
config = BaseConfig(**namespace)
cache = CachedConfig(root=config.root, m4_base=config.m4_base)
database = Database(gnulib.module, config)
# Print some information about modules.
print("Module list with included dependencies (indented):", file=sys.stdout)
BOLD_ON = BOLD_OFF = ""
mode = os.fstat(sys.stdout.fileno()).st_mode
if not (stat.S_ISFIFO(mode) or stat.S_ISREG(mode)):
BOLD_ON = "\033[1m"
BOLD_OFF = "\033[0m"
for module in database.final_modules:
manual = module in database.explicit_modules
prefix = " " if manual else " "
bold_on = BOLD_ON if manual else ""
bold_off = BOLD_OFF if manual else ""
print("{0}{1}{2}{3}".format(prefix, bold_on, module.name, bold_off), file=sys.stdout)
if verbosity >= 1:
print("Main module list:", file=sys.stdout)
for module in database.main_modules:
if module is not DummyModule():
print(" {0}".format(module.name), file=sys.stdout)
if database.main_modules:
print("", file=sys.stdout)
print("Tests-related module list:", file=sys.stdout)
for module in database.test_modules:
print(" {0}".format(module.name), file=sys.stdout)
if database.test_modules:
print("", file=sys.stdout)
# Determine license incompatibilities, if any.
incompatibilities = set()
if config.licenses & LGPL_LICENSES:
acceptable = {
"GPLed build tool",
"public domain",
"unlimited",
"unmodifiable license text",
}
acceptable |= set(config.licenses)
for (name, licenses) in ((module.name, module.licenses) for module in database.main_modules):
if not (acceptable & set(licenses)):
incompatibilities.add((name, licenses))
if incompatibilities:
print("{0}: *** incompatible license on modules:".format(script), file=sys.stderr)
for (name, licenses) in sorted(incompatibilities):
print(" " * 16, "{0:50}{1}".format(name, " ".join(sorted(licenses))), file=sys.stderr)
print("{0}: *** Stop.".format(script), file=sys.stderr)
return os.EX_DATAERR
# Show banner notice of every module.
if verbosity >= -1:
for module in database.main_modules:
notice = module.notice
if notice.strip():
print("Notice from module {0}:".format(module.name), file=sys.stdout)
print("\n".join(" " + line for line in notice.splitlines()), file=sys.stdout)
# Determine the final file list.
test_files = set()
main_files = set(database.main_files)
for file in database.test_files:
if file.startswith("lib/"):
file = "tests=lib/{}".format(file[len("lib/"):])
test_files.add(file)
files = (main_files | test_files)
if verbosity >= 0:
print("File list:", file=sys.stdout)
for file in sorted(files):
if file.startswith("tests=lib/"):
name = file[len("tests=lib/"):]
src = "lib/" + name
dst = "tests/" + name
print(" ", src, " -> ", dst, file=sys.stdout, sep="")
else:
print(" ", file, file=sys.stdout, sep="")
dry_run = options["dry_run"]
gnulib_copymode = config.copymode
local_copymode = config.local_copymode
def transfer_file(local, src_vfs, src_name, dst_vfs, dst_name):
args = (src_vfs, src_name, dst_vfs, dst_name)
if src_vfs is None:
return vfs_copy(*args)
action = {
None: vfs_copy,
"hardlink": vfs_hardlink,
"symlink": vfs_symlink,
}[local_copymode if local else gnulib_copymode]
try:
return action(*args)
except OSError as error:
if error.errno == errno.EXDEV:
return vfs_copy(*args)
raise error
def remove_file(project, file):
action = ("Removing", "Remove")[dry_run]
fmt = (action + " file {name} (backup in {name}~)")
if not dry_run:
try:
vfs_backup(project, file)
vfs_unlink(project, file)
except FileNotFoundError:
pass
print(fmt.format(name=project[file]), file=sys.stdout)
def update_file(local, src_vfs, src_name, dst_vfs, dst_name, present):
if not vfs_compare(src_vfs, src_name, dst_vfs, dst_name):
action = (("Replacing", "Replace"), ("Updating", "Update"))[present][dry_run]
message = ("(non-gnulib code backed up in {name}~) !!", "(backup in {name}~)")[present]
fmt = (action + " file {name} " + message)
if not dry_run:
vfs_backup(dst_vfs, dst_name)
transfer_file(local, src_vfs, src_name, dst_vfs, dst_name)
print(fmt.format(name=dst_vfs[dst_name]), file=sys.stdout)
def add_file(local, src_vfs, src_name, dst_vfs, dst_name, present):
action = ("Copying", "Copy")[dry_run]
fmt = (action + " file {name}")
if not dry_run:
transfer_file(local, src_vfs, src_name, dst_vfs, dst_name)
print(fmt.format(name=dst_vfs[dst_name]), file=sys.stdout)
# Adjust the VFS mappings.
overrides = []
project = BaseVFS(config.root)
overrides = {BaseVFS(override) for override in config.overrides}
for (alias, key) in SUBSTITUTION.items():
path = config[key] if key else "."
if path is not None:
project[alias] = path
for override in overrides:
override[alias] = path
gnulib["tests=lib"] = "lib"
# Determine all relevant file lists.
old_files = set(cache.files)
if "m4/gnulib-tool.m4" in project:
old_files |= set(["m4/gnulib-tool.m4"])
new_files = (files | set(["m4/gnulib-tool.m4"]))
# Determine required transformations.
transformations = []
for module in database.main_modules:
if module.name == "config-h":
# Assume config.h exists, and that -DHAVE_CONFIG_H is omitted.
def transformation(pattern, path, string):
if path.startswith("lib") or path.startswith("tests=lib"):
return pattern.sub(r"#if 1", string)
return string
pattern = re.compile(r"^#ifdef\s+HAVE_CONFIG_H\s*$", re.M)
transformations.append(functools.partial(transformation, pattern))
break
licenses = set(config.licenses)
if licenses == (GPLv2_LICENSE | LGPLv3_LICENSE):
def transformation(pattern, path, string):
repl = (
" This program is free software: you can redistribute it and/or",
" modify it under the terms of either:",
"",
" * the GNU Lesser General Public License as published by the Free",
" Software Foundation; either version 3 of the License, or (at your",
" option) any later version.",
"",
" or",
"",
" * the GNU General Public License as published by the Free",
" Software Foundation; either version 2 of the License, or (at your",
" option) any later version.",
"",
" or both in parallel, as here.",
"",
" This program is distributed in the hope that it will be useful,",
" but WITHOUT ANY WARRANTY; without even the implied warranty of",
" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the",
" GNU General Public License for more details.",
"",
" You should have received a copy of the GNU General Public License",
" along with this program. If not, see .",
)
if path.startswith("lib") or path.startswith("lib=tests"):
return pattern.sub("\n".join(repl), string)
return string
pattern = re.compile((r"^\s*(This program is free software.*?)\s*\*/$"), re.S | re.M)
transformations.append(functools.partial(transformation, pattern))
elif licenses == LGPLv3_LICENSE:
transformations += [
lambda path, string:
string.replace("GNU General", "GNU Lesser General")
if path.startswith("lib") else string,
lambda path, string:
string.replace("General Public License", "Lesser General Public License")
if path.startswith("lib") else string,
lambda path, string:
string.replace("Lesser Lesser General Public License", "Lesser General Public License")
if path.startswith("lib") else string,
]
elif licenses == LGPLv2_LICENSE:
transformations += [
lambda path, string:
string.replace("GNU General", "GNU Lesser General")
if path.startswith("lib") else string,
lambda path, string:
string.replace("General Public License", "Lesser General Public License")
if path.startswith("lib") else string,
lambda path, string:
string.replace("Lesser Lesser General Public License", "Lesser General Public License")
if path.startswith("lib") else string,
]
transformation = lambda pattern, path, string: pattern.sub(r"version 2.1\1", string)
def transformation(pattern, path, string):
if path.startswith("lib") or path.startswith("lib=tests"):
return pattern.sub(r"version 2.1\1", string)
return string
pattern = re.compile(r"version\s+[23]([\s,])")
transformations.append(functools.partial(transformation, pattern))
else:
transformations += [
lambda path, string:
string.replace("GNU Lesser General", "GNU General")
if path.startswith("lib") else string,
lambda path, string:
string.replace("Lesser General Public License", "General Public License")
if path.startswith("lib") else string,
lambda path, string:
string.replace("GNU Library General", "GNU General")
if path.startswith("lib") else string,
lambda path, string:
string.replace("Library General Public License", "General Public License")
if path.startswith("lib") else string,
]
def transformation(pattern, path, string):
if path.startswith("lib") or path.startswith("lib=tests"):
return pattern.sub(r"version 3\1", string)
return string
pattern = re.compile(r"version\s+2(?:\.1){0,1}([\s,])")
transformations.append(functools.partial(transformation, pattern))
if config.copyrights:
for root in {"build-aux", "tests=lib"}:
def transformation(root, pattern, path, string):
if path.startswith(root):
string = string.replace("GNU Lesser General", "GNU General")
string = string.replace("Lesser General Public License", "General Public License")
string = string.replace("GNU Library General", "GNU General")
string = string.replace("Library General Public License", "General Public License")
string = pattern.sub(r"version 3\1", string)
return string
transformations.append(functools.partial(transformation, root, pattern))
# First the files that are in old_files, but not in new_files.
# Then the files that are in new_files, but not in old_files.
# Then the files that are in new_files and in old_files.
removed_files = old_files.difference(new_files)
added_files = new_files.difference(old_files)
kept_files = (old_files & new_files)
for file in sorted(removed_files):
remove_file(project, file)
for (present, files) in ((False, added_files), (True, kept_files)):
for dst in sorted(files):
(vfs, src) = vfs_lookup(dst, gnulib, overrides, patch=PATCH)
action = update_file if vfs_exists(project, dst) else add_file
with vfs_iostream(vfs, src, "rb", "UTF-8") as istream:
dst_data = src_data = istream.read()
for transformation in transformations:
dst_data = transformation(dst, dst_data)
temporary = False
local = (vfs and vfs != gnulib)
if src_data != dst_data:
with tempfile.NamedTemporaryFile("w", encoding="UTF-8", delete=False) as ostream:
ostream.write(dst_data)
src = ostream.name
temporary = True
local = False
action(local, vfs, src, project, dst, present)
if temporary:
os.unlink(src)
mkedits = []
if config.makefile_name in {None, "Makefile.am"}:
dirname = os.path.dirname(config.source_base)
basename = os.path.basename(config.source_base)
dirname += ("", os.path.sep)[bool(dirname)]
mkedits.append((dirname, "SUBDIRS", basename))
if "po_base" in explicit:
dirname = os.path.dirname(config.po_base)
basename = os.path.basename(config.po_base)
dirname = "" if dirname == "." else dirname
mkedits.append((dirname, "SUBDIRS", basename))
if config.tests and config.makefile_name in {None, "Makefile.am"}:
dirname = os.path.dirname(config.tests_base)
basename = os.path.basename(config.tests_base)
dirname = "" if dirname == "." else (dirname + os.path.sep)
mkedits.append((dirname, "SUBDIRS", basename))
mkedits.append(("", "ACLOCAL_AMFLAGS", "-I {}".format(config.m4_base)))
# Find the first parent directory of m4_base that contains or will contain a Makefile.am.
(dir1, dir2) = (config.m4_base, "")
makefile_name = config.makefile_name
makefile_name = "Makefile.am" if makefile_name is None else makefile_name
source_base_makefile = os.path.join(config.source_base, makefile_name)
tests_base_makefile = os.path.join(config.tests_base, makefile_name)
while dir1 != "./":
path = os.path.join(dir1, "Makefile.am")
if vfs_exists(project, os.path.join(config.root, dir1, "Makefile.am")) \
or (config.tests and path in (source_base_makefile, tests_base_makefile)):
break
dir2 = os.path.join(os.path.basename(dir1), dir2)
dir1 = os.path.dirname(dir1)
if not dir1:
dir1 = "."
mkedits.append((dir1, "EXTRA_DIST", os.path.join(dir2, "gnulib-cache.m4")))
# Generate the contents of library makefile.
path = os.path.join("lib", makefile_name)
with tempfile.NamedTemporaryFile("w", encoding="UTF-8", delete=False) as tmp:
arguments = {
"path": project[path],
"config": config,
"explicit": explicit,
"database": database,
"mkedits": mkedits,
"testing": False,
}
for line in lib_makefile(**arguments, autoconf=AUTOCONF):
print(line, file=tmp)
(src, dst) = (tmp.name, path)
present = vfs_exists(project, dst)
action = update_file if present else add_file
action(False, None, src, project, dst, present)
os.unlink(tmp.name)
if not present:
added_files.add(dst)
# Generate po makefile and directories.
url = (TP_RSYNC_URI + "gnulib/")
if "po_base" in explicit:
for file in ("Makefile.in.in", "remove-potcdate.sin"):
path = os.path.join("build-aux", "po", file)
match = tuple(override for override in overrides if file in override)
override = match[0] if match else gnulib
(vfs, src) = vfs_lookup(path, gnulib, override, patch=PATCH)
dst = os.path.join("po", file)
present = vfs_exists(project, dst)
action = update_file if present else add_file
action(bool(match), vfs, src, project, dst, present)
if not present:
added_files.add(dst)
# Create po makefile parameterization, part 1.
with tempfile.NamedTemporaryFile("w", encoding="UTF-8", delete=False) as tmp:
for line in po_make_vars(config):
print(line, file=tmp)
(src, dst) = (tmp.name, "po/Makevars")
present = vfs_exists(project, dst)
action = update_file if present else add_file
action(False, None, src, project, dst, present)
os.unlink(tmp.name)
if not present:
added_files.add(dst)
# Create po makefile parameterization, part 2.
with tempfile.NamedTemporaryFile("w", encoding="UTF-8", delete=False) as tmp:
for line in po_make_vars(config):
print(line, file=tmp)
(src, dst) = (tmp.name, "po/POTFILESGenerator.in")
present = vfs_exists(project, dst)
action = update_file if present else add_file
action(False, None, src, project, dst, present)
os.unlink(tmp.name)
if not present:
added_files.add(dst)
po_root = os.path.join(project.absolute, project["po"])
fmt = ("{} gnulib PO files from " + TP_URL)
print(fmt.format("Fetching", "Fetch")[dry_run], file=sys.stdout)
if not dry_run:
# Prefer rsync over wget if it is available, since it consumes
# less network bandwidth, due to compression.
url = (TP_RSYNC_URI + "gnulib/")
cmdargs = ("rsync", "--delete", "--exclude", "*.s1", "-Lrtz", url, ".")
with sp.Popen(cmdargs, cwd=po_root, stdout=sp.PIPE, stderr=sp.PIPE) as process:
(stdout, stderr) = process.communicate()
stdout = stdout.decode("UTF-8")
stderr = stderr.decode("UTF-8")
returncode = process.returncode
if process.returncode == 0:
raise sp.CalledProcessError(returncode, cmdargs, stdout, stderr)
print(stdout, file=sys.stdout)
print(stderr, file=sys.stderr)
# Create po/LINGUAS.
languages = set()
for root, _, files in os.walk(po_root):
languages.update(file[:-3] for file in files if file.endswith(".po"))
with tempfile.NamedTemporaryFile("w", encoding="UTF-8", delete=False) as tmp:
tmp.write("# Set of available languages.\n")
for line in sorted(languages):
print(line, file=tmp)
(src, dst) = (tmp.name, "po/LINGUAS")
present = vfs_exists(project, dst)
action = update_file if present else add_file
action(False, None, src, project, dst, present)
os.unlink(tmp.name)
if not present:
added_files.add(dst)
# Create m4/gnulib-cache.m4.
with tempfile.NamedTemporaryFile("w", encoding="UTF-8", delete=False) as tmp:
for line in gnulib_cache(config, explicit):
print(line, file=tmp)
(src, dst) = (tmp.name, "m4/gnulib-cache.m4")
present = vfs_exists(project, dst)
action = update_file if present else add_file
action(False, None, src, project, dst, present)
os.unlink(tmp.name)
if not present:
added_files.add(dst)
# Create m4/gnulib-comp.m4.
with tempfile.NamedTemporaryFile("w", encoding="UTF-8", delete=False) as tmp:
arguments = {
"config": config,
"explicit": explicit,
"database": database,
}
for line in gnulib_comp(**arguments):
print(line, file=tmp)
(src, dst) = (tmp.name, "m4/gnulib-comp.m4")
present = vfs_exists(project, dst)
action = update_file if present else add_file
action(False, None, src, project, dst, present)
os.unlink(tmp.name)
if not present:
added_files.add(dst)
# Generate the contents of tests makefile.
if config.tests:
path = os.path.join(config.tests_base, config.makefile_name)
with tempfile.NamedTemporaryFile("w", encoding="UTF-8", delete=False) as tmp:
arguments = {
"path": path,
"config": config,
"explicit": explicit,
"modules": database.test_modules,
"mkedits": mkedits,
"testing": False,
"libtests": database.libtests,
}
for line in tests_makefile(**arguments):
print(line, file=tmp)
(src, dst) = (tmp.name, path)
present = vfs_exists(project, dst)
action = update_file if present else add_file
action(False, None, src, project, dst, present)
os.unlink(tmp.name)
if not present:
added_files.add(dst)
# Generate version control files.
if config.vc_files:
table = collections.defaultdict(list)
for path in added_files:
(directory, name) = os.path.split(path)
table[directory].append(["+", name])
for path in removed_files:
(directory, name) = os.path.split(path)
table[directory].append(["-", name])
# Treat gnulib-comp.m4 like an added file, even if it already existed.
table["m4"].append(["+", "gnulib-comp.m4"])
visited = set()
tmp_table = dict(table)
for directory in tmp_table:
if project[directory] in visited:
del table[directory]
visited.add(project[directory])
table = dict(table)
for directory in sorted(table):
kinds = []
kinds += ([], [".gitignore"])[os.path.isdir(os.path.join(project.root, ".git"))]
kinds += ([], [".cvsignore"])[os.path.isdir(os.path.join(project.root, "CVS"))]
kinds += ([], [".gitignore"])[os.path.isfile(os.path.join(project.root, project[directory], ".gitignore"))]
kinds += ([], [".cvsignore"])[os.path.isdir(os.path.join(project.root, project[directory], "CVS"))]
kinds += ([], [".cvsignore"])[os.path.isfile(os.path.join(project.root, project[directory], ".cvsignore"))]
for kind in set(kinds):
anchor = {
".gitignore": "/",
".cvsignore": "",
}[kind]
path = os.path.join(directory, kind)
try:
with vfs_iostream(project, path, "rb", "UTF-8") as stream:
origin = [line.strip() for line in stream.readlines()]
present = True
except FileNotFoundError:
origin = []
present = False
include = set()
exclude = set()
for (action, name) in table[directory]:
name = f"{anchor}{name}"
already = name in origin
if action == "-" and not already:
exclude.add(name)
elif action == "+" and not already:
include.add(name)
result = []
for entry in origin:
if entry not in exclude:
result.append(entry)
for entry in sorted(include):
if entry not in origin:
result.append(entry)
if (set(origin) != set(result)):
action = (("Creating", "Create"), ("Updating", "Update"))[present][dry_run]
fmt = (action + " {name}" + ("", " (backup in {name}~)")[present])
print(fmt.format(name=project[path]), file=sys.stdout)
if not dry_run:
if present:
vfs_backup(project, path)
with vfs_iostream(project, path, "wb", "UTF-8") as stream:
for entry in result:
print(entry, file=stream)
print("Finished.", file=sys.stdout)
print("", file=sys.stdout)
# Mention the required include directives.
# First the #include <...> directives without #ifs, sorted for convenience,
# then the #include "..." directives without #ifs, sorted for convenience,
# then the #include directives that are surrounded by #ifs. Not sorted.
print("You may need to add #include directives for the following .h files.", file=sys.stdout)
table = {"quotes": set(), "angles": set(), "other": list()}
for module in sorted(set(database.explicit_modules) & set(database.main_modules)):
directives = "\n".join(module.include_directives)
if directives.startswith("\""):
table["quotes"].add(directives)
elif directives.startswith("<"):
table["angles"].add(directives)
else:
table["other"].append(directives)
for key in ("angles", "quotes"):
value = sorted(table[key])
for item in value:
print(f" #include {item}", file=sys.stdout)
for item in table["other"]:
for line in item.splitlines():
print(f" {line}", file=sys.stdout)
# Mention the required linker directives.
lines = []
for module in database.main_modules:
lines += module.link_directives
if lines:
print("", file=sys.stdout)
print("You may need to use the following Makefile variables when linking.", file=sys.stdout)
print("Use them in _LDADD when linking a program, or", file=sys.stdout)
print("in _a_LDFLAGS or _la_LDFLAGS when linking a library.", file=sys.stdout)
for line in sorted(set(lines)):
print(f" {line}", file=sys.stdout)
# Mention other necessary actions.
print("", file=sys.stdout)
print("Don't forget to", file=sys.stdout)
if config.makefile_name is None:
config.makefile_name = "Makefile.am"
if config.makefile_name == "Makefile.am":
fmt = " - add \"{source_base}/Makefile\" to AC_CONFIG_FILES in {ac_file},"
else:
fmt = " - \"include {makefile_name}\" from within \"{source_base}/Makefile.am\","
print(fmt.format(**config), file=sys.stdout)
if config.po_base:
fmt = " - add \"{po_base}/Makefile.in\" to AC_CONFIG_FILES in {ac_file},"
print(fmt.format(**config), file=sys.stdout)
if config.tests:
if config.makefile_name == "Makefile.am":
fmt = " - add \"{tests_base}/Makefile\" to AC_CONFIG_FILES in {ac_file},"
else:
fmt = " - \"include {makefile_name}\" from within \"{tests_base}/Makefile.am\","
print(fmt.format(**config), file=sys.stdout)
for (directory, key, value) in mkedits:
path = os.path.normpath(os.path.join(directory, "Makefile.am"))
print(f" - mention \"{value}\" in {key} in {path},", file=sys.stdout)
position_early_after = "AC_PROG_CC"
with vfs_iostream(project, config.ac_file, "rb", "UTF-8") as stream:
contents = stream.read()
AC_PROG_CC_STDC = re.compile(r"^\s*AC_PROG_CC_STDC", re.S | re.M)
AC_PROG_CC_C99 = re.compile(r"^\s*AC_PROG_CC_C99", re.S | re.M)
if AC_PROG_CC_STDC.findall(contents):
position_early_after = "AC_PROG_CC_STDC"
elif AC_PROG_CC_C99.findall(contents):
position_early_after = "AC_PROG_CC_C99"
fmt = " - invoke {macro_prefix}_EARLY in {ac_file}, right after {position_early_after},"
print(fmt.format(**config, position_early_after=position_early_after), file=sys.stdout)
fmt = " - invoke {macro_prefix}_INIT in {ac_file}."
print(fmt.format(**config), file=sys.stdout)
return os.EX_OK
def add_import_hook(script, gnulib, namespace, explicit, verbosity, options, *args, **kwargs):
(_, _) = (args, kwargs)
modules = set(namespace.pop("modules"))
config = CachedConfig(**namespace)
namespace = {k:v for (k, v) in config.items()}
namespace["modules"] = (config.modules | modules)
return import_hook(script, gnulib, namespace, verbosity, options)
def remove_import_hook(script, gnulib, namespace, explicit, verbosity, options, *args, **kwargs):
(_, _) = (args, kwargs)
modules = set(namespace.pop("modules"))
config = CachedConfig(**namespace)
namespace = {k:v for (k, v) in config.items()}
namespace["modules"] = (config.modules - modules)
return import_hook(script, gnulib, namespace, verbosity, options)
def update_hook(script, gnulib, namespace, explicit, verbosity, options, *args, **kwargs):
(_, _) = (args, kwargs)
config = CachedConfig(**namespace)
namespace = {k:v for (k, v) in config.items()}
return import_hook(script, gnulib, namespace, verbosity, options)
HOOKS = {
"list": list_hook,
"extract": extract_hook,
"import": import_hook,
"add-import": add_import_hook,
"remove-import": remove_import_hook,
"update": update_hook,
}
def main(script, gnulib, program, arguments, environ):
gnulib = GnulibGitVFS(gnulib)
parser = CommandLineParser(program)
try:
(namespace, mode, verbosity, options) = parser.parse(arguments)
except CommandLineError as error:
print(parser.usage, file=sys.stderr)
print(error, file=sys.stderr)
return os.EX_USAGE
if mode == "help":
print(parser.help, file=sys.stdout)
return os.EX_OK
kwargs = {
"script": script,
"program": program,
"gnulib": gnulib,
"mode": mode,
"namespace": namespace,
"explicit": namespace.keys(),
"verbosity": verbosity,
"options": options,
}
for (action, hook) in HOOKS.items():
if mode.startswith(action):
return hook(**kwargs)
return os.EX_SOFTWARE
if __name__ == "__main__":
script = sys.argv[0]
gnulib = os.path.dirname(__file__)
program = os.path.basename(script)
log = os.path.join(os.getcwd(), "{0}.log".format(program))
arguments = list(sys.argv[1:])
environ = dict(os.environ)
try:
result = main(script, gnulib, program, arguments, environ)
except StopIteration as error:
with codecs.open(log, "wb", "UTF-8") as stream:
program = repr(program) if " " in program else program
arguments = " ".join(repr(arg) if " " in arg else arg for arg in arguments)
print(traceback.format_exc(), file=stream)
print("COMMAND:", program, arguments, file=stream)
typeid = type(error)
module = typeid.__module__
name = typeid.__name__
if module != "builtins":
error = "{0}.{1}: {2}".format(module, name, error)
else:
error = "{0}: {1}".format(name, error)
print("{0}:".format(program), "***", error, file=sys.stderr)
print("{0}:".format(program), "***", log, file=sys.stderr)
result = os.EX_SOFTWARE
sys.exit(result)