1236 lines
50 KiB
Python
1236 lines
50 KiB
Python
# Copyright (C) 2002-2024 Free Software Foundation, Inc.
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# 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 <https://www.gnu.org/licenses/>.
|
|
|
|
from __future__ import annotations
|
|
|
|
#===============================================================================
|
|
# Define global imports
|
|
#===============================================================================
|
|
import os
|
|
import copy
|
|
from typing import Any
|
|
from .constants import (
|
|
MODES,
|
|
TESTS,
|
|
joinpath,
|
|
remove_trailing_slashes,
|
|
)
|
|
from .GLError import GLError
|
|
from pygnulib.enums import CopyAction
|
|
|
|
|
|
#===============================================================================
|
|
# Define GLConfig class
|
|
#===============================================================================
|
|
class GLConfig:
|
|
'''This class is used to store intermediate settings for all pygnulib
|
|
classes. It contains all necessary attributes to setup any other class.
|
|
By default all attributes are set to empty string, empty list or zero.
|
|
The most common value, however, is a None value.'''
|
|
|
|
table: dict[str, Any]
|
|
|
|
def __init__(self,
|
|
tempdir: str | None = None,
|
|
destdir: str | None = None,
|
|
localpath: list[str] | None = None,
|
|
auxdir: str | None = None,
|
|
sourcebase: str | None = None,
|
|
m4base: str | None = None,
|
|
pobase: str | None = None,
|
|
docbase: str | None = None,
|
|
testsbase: str | None = None,
|
|
modules: list[str] | None = None,
|
|
avoids: list[str] | None = None,
|
|
files: list[str] | None = None,
|
|
incobsolete: bool | None = None,
|
|
incl_test_categories: list[int] | tuple[int] | None = None,
|
|
excl_test_categories: list[int] | tuple[int] | None = None,
|
|
libname: str | None = None,
|
|
lgpl: str | bool | None = None,
|
|
gpl: str | None = None,
|
|
gnu_make: bool | None = None,
|
|
makefile_name: str | None = None,
|
|
tests_makefile_name: str | None = None,
|
|
automake_subdir: bool | None = None,
|
|
automake_subdir_tests: bool | None = None,
|
|
libtool: bool | None = None,
|
|
conddeps: bool | None = None,
|
|
macro_prefix: str | None = None,
|
|
podomain: str | None = None,
|
|
witness_c_macro: str | None = None,
|
|
vc_files: bool | None = None,
|
|
copymode: CopyAction | None = None,
|
|
lcopymode: CopyAction | None = None,
|
|
configure_ac: str | None = None,
|
|
ac_version: float | int | None = None,
|
|
libtests: bool | None = None,
|
|
single_configure: bool | None = None,
|
|
verbose: int | None = None,
|
|
dryrun: bool | None = None,
|
|
errors: bool | None = None) -> None:
|
|
'''Create new GLConfig instance.'''
|
|
self.table = dict()
|
|
self.table['tempdir'] = tempdir
|
|
# Check and store the attributes.
|
|
# Remove trailing slashes from the directory names. This is necessary
|
|
# for m4base (to avoid an error in func_import) and optional for the
|
|
# others.
|
|
# destdir
|
|
self.resetDestDir()
|
|
if destdir != None:
|
|
self.setDestDir(destdir)
|
|
# localpath
|
|
self.resetLocalPath()
|
|
if localpath != None:
|
|
self.setLocalPath(localpath)
|
|
# auxdir
|
|
self.resetAuxDir()
|
|
if auxdir != None:
|
|
self.setAuxDir(auxdir)
|
|
# sourcebase
|
|
self.resetSourceBase()
|
|
if sourcebase != None:
|
|
self.setSourceBase(sourcebase)
|
|
# m4base
|
|
self.resetM4Base()
|
|
if m4base != None:
|
|
self.setM4Base(m4base)
|
|
# pobase
|
|
self.resetPoBase()
|
|
if pobase != None:
|
|
self.setPoBase(pobase)
|
|
# docbase
|
|
self.resetDocBase()
|
|
if docbase != None:
|
|
self.setDocBase(docbase)
|
|
# testsbase
|
|
self.resetTestsBase()
|
|
if testsbase != None:
|
|
self.setTestsBase(testsbase)
|
|
# modules
|
|
self.resetModules()
|
|
if modules != None:
|
|
self.setModules(modules)
|
|
# avoids
|
|
self.resetAvoids()
|
|
if avoids != None:
|
|
self.setAvoids(avoids)
|
|
# files
|
|
self.resetFiles()
|
|
if files != None:
|
|
self.setFiles(files)
|
|
# incobsolete
|
|
self.resetIncObsolete()
|
|
if incobsolete != None:
|
|
self.setIncObsolete(incobsolete)
|
|
# test categories to include
|
|
self.resetInclTestCategories()
|
|
if incl_test_categories != None:
|
|
self.setInclTestCategories(incl_test_categories)
|
|
# test categories to exclude
|
|
self.resetExclTestCategories()
|
|
if excl_test_categories != None:
|
|
self.setExclTestCategories(excl_test_categories)
|
|
# libname
|
|
self.resetLibName()
|
|
if libname != None:
|
|
self.setLibName(libname)
|
|
# lgpl
|
|
self.resetLGPL()
|
|
if lgpl != None:
|
|
self.setLGPL(lgpl)
|
|
# gpl
|
|
self.resetGPL()
|
|
if gpl != None:
|
|
self.setGPL(gpl)
|
|
# gnu-make
|
|
self.resetGnuMake()
|
|
if gnu_make != None:
|
|
self.setGnuMake(gnu_make)
|
|
# makefile_name
|
|
self.resetMakefileName()
|
|
if makefile_name != None:
|
|
self.setMakefileName(makefile_name)
|
|
# tests_makefile_name
|
|
self.resetTestsMakefileName()
|
|
if tests_makefile_name != None:
|
|
self.setTestsMakefileName(tests_makefile_name)
|
|
# automake-subdir
|
|
self.resetAutomakeSubdir()
|
|
if automake_subdir != None:
|
|
self.setAutomakeSubdir(automake_subdir)
|
|
# automake_subdir_tests
|
|
self.resetAutomakeSubdirTests()
|
|
if automake_subdir_tests != None:
|
|
self.setAutomakeSubdirTests(automake_subdir_tests)
|
|
# libtool
|
|
self.resetLibtool()
|
|
if libtool != None:
|
|
self.setLibtool(libtool)
|
|
# conddeps
|
|
self.resetCondDeps()
|
|
if conddeps != None:
|
|
self.setCondDeps(conddeps)
|
|
# macro_prefix
|
|
self.resetMacroPrefix()
|
|
if macro_prefix != None:
|
|
self.setMacroPrefix(macro_prefix)
|
|
# podomain
|
|
self.resetPoDomain()
|
|
if podomain != None:
|
|
self.setPoDomain(podomain)
|
|
# witness_c_macro
|
|
self.resetWitnessCMacro()
|
|
if witness_c_macro != None:
|
|
self.setWitnessCMacro(witness_c_macro)
|
|
# vc_files
|
|
self.resetVCFiles()
|
|
if vc_files != None:
|
|
self.setVCFiles(vc_files)
|
|
# copymode (--symlink and --hardlink)
|
|
self.resetCopyMode()
|
|
if copymode == None:
|
|
# Default to copying.
|
|
copymode = CopyAction.Copy
|
|
self.setCopyMode(copymode)
|
|
# lcopymode (--local-symlink and --local-hardlink)
|
|
self.resetLCopyMode()
|
|
if lcopymode == None:
|
|
# Default to copying.
|
|
lcopymode = CopyAction.Copy
|
|
self.setLCopyMode(lcopymode)
|
|
# configure_ac
|
|
self.resetAutoconfFile()
|
|
if configure_ac != None:
|
|
self.setAutoconfFile(configure_ac)
|
|
# ac_version
|
|
self.resetAutoconfVersion()
|
|
if ac_version != None:
|
|
self.setAutoconfVersion(ac_version)
|
|
# libtests
|
|
self.resetLibtests()
|
|
if libtests != None:
|
|
self.setLibtests(libtests)
|
|
# single_configure
|
|
self.resetSingleConfigure()
|
|
if single_configure != None:
|
|
self.setSingleConfigure(single_configure)
|
|
# verbose
|
|
self.resetVerbosity()
|
|
if verbose != None:
|
|
self.setVerbosity(verbose)
|
|
# dryrun
|
|
self.resetDryRun()
|
|
if dryrun != None:
|
|
self.setDryRun(dryrun)
|
|
# errors
|
|
self.resetErrors()
|
|
if errors != None:
|
|
self.setErrors(errors)
|
|
|
|
# Define special methods.
|
|
def __repr__(self) -> str:
|
|
'''x.__repr__() <==> repr(x)'''
|
|
return '<pygnulib.GLConfig>'
|
|
|
|
def __getitem__(self, y: str) -> Any:
|
|
'''x.__getitem__(y) <==> x[y]'''
|
|
if y in self.table:
|
|
return self.table[y]
|
|
else: # if y not in self.table
|
|
raise KeyError('GLConfig does not contain key: %s' % repr(y))
|
|
|
|
def dictionary(self) -> dict[str, Any]:
|
|
'''Return the configuration as a dict object.'''
|
|
return dict(self.table)
|
|
|
|
def copy(self) -> GLConfig:
|
|
'''Return the copy of the configuration.'''
|
|
table = copy.deepcopy(self)
|
|
return table
|
|
|
|
def update(self, other_config: GLConfig) -> None:
|
|
'''Merges all non-default values from other_config into this config.'''
|
|
if type(other_config) is not GLConfig:
|
|
raise TypeError('other_config must be a GLConfig, not %s'
|
|
% type(other_config).__name__)
|
|
dictionary = other_config.table
|
|
result = dict()
|
|
for key in dictionary:
|
|
src = self.table[key]
|
|
dest = dictionary[key]
|
|
# Merge src and dest into a single value.
|
|
if src == dest:
|
|
value = src
|
|
else:
|
|
if self.isdefault(key, src):
|
|
value = dest
|
|
else: # if not self.isdefault(key, src)
|
|
if self.isdefault(key, dest):
|
|
value = src
|
|
else: # if not self.isdefault(key, dest)
|
|
if key in ['modules', 'avoids',
|
|
'incl_test_categories', 'excl_test_categories']:
|
|
value = sorted(set(src + dest))
|
|
else:
|
|
value = dest
|
|
result[key] = value
|
|
self.table = result
|
|
|
|
def update_key(self, other_config: GLConfig, key: str) -> None:
|
|
'''Copies the value for key from other_config into this config.'''
|
|
if key in self.table:
|
|
if type(other_config) is not GLConfig:
|
|
raise TypeError('other_config must be a GLConfig, not %s'
|
|
% type(other_config).__name__)
|
|
dictionary = other_config.table
|
|
self.table[key] = dictionary[key]
|
|
else: # if key not in self.table
|
|
raise KeyError('GLConfig does not contain key: %s' % repr(key))
|
|
|
|
def default(self, key: str) -> Any:
|
|
'''Return default value for the given key.'''
|
|
if key in self.table:
|
|
if key == 'libname':
|
|
return 'libgnu'
|
|
elif key == 'macro_prefix':
|
|
return 'gl'
|
|
elif key == 'include_guard_prefix':
|
|
return 'GL'
|
|
elif key == 'ac_version':
|
|
return 2.64
|
|
elif key == 'verbosity':
|
|
return 0
|
|
elif key in ['localpath', 'modules', 'avoids',
|
|
'incl_test_categories', 'excl_test_categories']:
|
|
return []
|
|
elif key in ['incobsolete', 'gnu_make',
|
|
'automake_subdir', 'automake_subdir_tests',
|
|
'libtests', 'dryrun']:
|
|
return False
|
|
elif key in ['copymode', 'lcopymode']:
|
|
return CopyAction.Copy
|
|
elif key in ['lgpl', 'gpl', 'libtool', 'conddeps', 'vc_files']:
|
|
return None
|
|
elif key == 'errors':
|
|
return True
|
|
else: # otherwise
|
|
return ''
|
|
else: # if key not in self.table
|
|
raise KeyError('GLConfig does not contain key: %s' % repr(key))
|
|
|
|
def isdefault(self, key: str, value: Any) -> bool:
|
|
'''Check whether the value for the given key is a default value.'''
|
|
if key in self.table:
|
|
default = self.default(key)
|
|
return value == default
|
|
else: # if key not in self.table
|
|
raise KeyError('GLConfig does not contain key: %s' % repr(key))
|
|
|
|
def keys(self) -> list[str]:
|
|
'''Return list of keys.'''
|
|
return list(self.table.keys())
|
|
|
|
def values(self) -> list[Any]:
|
|
'''Return list of values.'''
|
|
return list(self.table.values())
|
|
|
|
# Define destdir methods.
|
|
def getDestDir(self) -> str:
|
|
'''Return the target directory. For --import, this specifies where your
|
|
configure.ac can be found. Defaults to current directory.'''
|
|
return self.table['destdir']
|
|
|
|
def setDestDir(self, destdir: str) -> None:
|
|
'''Specify the target directory. For --import, this specifies where your
|
|
configure.ac can be found. Defaults to current directory.'''
|
|
if type(destdir) is str:
|
|
if destdir:
|
|
self.table['destdir'] = os.path.normpath(destdir)
|
|
else: # if destdir has not str type
|
|
raise TypeError('destdir must be a string, not %s'
|
|
% type(destdir).__name__)
|
|
|
|
def resetDestDir(self) -> None:
|
|
'''Reset the target directory. For --import, this specifies where your
|
|
configure.ac can be found. Defaults to current directory.'''
|
|
self.table['destdir'] = ''
|
|
|
|
# Define localpath methods.
|
|
def getLocalPath(self) -> list[str]:
|
|
'''Return a list of local override directories where to look up files
|
|
before looking in gnulib's directory. The first one has the highest
|
|
priority.'''
|
|
return self.table['localpath']
|
|
|
|
def setLocalPath(self, localpath: list[str]) -> None:
|
|
'''Specify a list of local override directories where to look up files
|
|
before looking in gnulib's directory. The first one has the highest
|
|
priority.'''
|
|
if type(localpath) is list:
|
|
for dir in localpath:
|
|
if type(dir) is not str:
|
|
raise TypeError('localpath element must be a string, not %s' % type(dir).__name__)
|
|
else:
|
|
raise TypeError('localpath must be a list, not %s' % type(localpath).__name__)
|
|
self.table['localpath'] = [ remove_trailing_slashes(dir)
|
|
for dir in localpath ]
|
|
|
|
def resetLocalPath(self) -> None:
|
|
'''Reset a list of local override directories where to look up files
|
|
before looking in gnulib's directory.'''
|
|
self.table['localpath'] = []
|
|
|
|
# Define auxdir methods.
|
|
def getAuxDir(self) -> str:
|
|
'''Return directory relative to --dir where auxiliary build tools are
|
|
placed. Default comes from configure.ac or configure.in.'''
|
|
if self.table['auxdir']:
|
|
return self.table['auxdir']
|
|
return 'build-aux'
|
|
|
|
def setAuxDir(self, auxdir: str) -> None:
|
|
'''Specify directory relative to --dir where auxiliary build tools are
|
|
placed. Default comes from configure.ac or configure.in.'''
|
|
if type(auxdir) is str:
|
|
if auxdir:
|
|
self.table['auxdir'] = remove_trailing_slashes(auxdir)
|
|
else: # if type of auxdir is not str
|
|
raise TypeError('auxdir must be a string, not %s'
|
|
% type(auxdir).__name__)
|
|
|
|
def resetAuxDir(self) -> None:
|
|
'''Reset directory relative to --dir where auxiliary build tools are
|
|
placed. Default comes from configure.ac or configure.in.'''
|
|
self.table['auxdir'] = ''
|
|
|
|
# Define sourcebase methods.
|
|
def getSourceBase(self) -> str:
|
|
'''Return directory relative to destdir where source code is placed.'''
|
|
return self.table['sourcebase']
|
|
|
|
def setSourceBase(self, sourcebase: str) -> None:
|
|
'''Specify directory relative to destdir where source code is placed.'''
|
|
if type(sourcebase) is str:
|
|
if sourcebase:
|
|
self.table['sourcebase'] = remove_trailing_slashes(sourcebase)
|
|
else: # if type of sourcebase is not str
|
|
raise TypeError('sourcebase must be a string, not %s'
|
|
% type(sourcebase).__name__)
|
|
|
|
def resetSourceBase(self) -> None:
|
|
'''Return directory relative to destdir where source code is placed.'''
|
|
self.table['sourcebase'] = ''
|
|
|
|
# Define m4base methods.
|
|
def getM4Base(self) -> str:
|
|
'''Return directory relative to destdir where *.m4 macros are placed.'''
|
|
return self.table['m4base']
|
|
|
|
def setM4Base(self, m4base: str) -> None:
|
|
'''Specify directory relative to destdir where *.m4 macros are placed.'''
|
|
if type(m4base) is str:
|
|
if m4base:
|
|
self.table['m4base'] = remove_trailing_slashes(m4base)
|
|
else: # if type of m4base is not str
|
|
raise TypeError('m4base must be a string, not %s'
|
|
% type(m4base).__name__)
|
|
|
|
def resetM4Base(self) -> None:
|
|
'''Reset directory relative to destdir where *.m4 macros are placed.'''
|
|
self.table['m4base'] = ''
|
|
|
|
# Define pobase methods.
|
|
def getPoBase(self) -> str:
|
|
'''Return directory relative to destdir where *.po files are placed.'''
|
|
return self.table['pobase']
|
|
|
|
def setPoBase(self, pobase: str) -> None:
|
|
'''Specify directory relative to destdir where *.po files are placed.'''
|
|
if type(pobase) is str:
|
|
if pobase:
|
|
self.table['pobase'] = remove_trailing_slashes(pobase)
|
|
else: # if type of pobase is not str
|
|
raise TypeError('pobase must be a string, not %s'
|
|
% type(pobase).__name__)
|
|
|
|
def resetPoBase(self) -> None:
|
|
'''Reset directory relative to destdir where *.po files are placed.'''
|
|
self.table['pobase'] = ''
|
|
|
|
# Define docbase methods.
|
|
def getDocBase(self) -> str:
|
|
'''Return directory relative to destdir where doc files are placed.
|
|
Default value for this variable is 'doc').'''
|
|
return self.table['docbase']
|
|
|
|
def setDocBase(self, docbase: str) -> None:
|
|
'''Specify directory relative to destdir where doc files are placed.
|
|
Default value for this variable is 'doc').'''
|
|
if type(docbase) is str:
|
|
if docbase:
|
|
self.table['docbase'] = remove_trailing_slashes(docbase)
|
|
else: # if type of docbase is not str
|
|
raise TypeError('docbase must be a string, not %s'
|
|
% type(docbase).__name__)
|
|
|
|
def resetDocBase(self) -> None:
|
|
'''Reset directory relative to destdir where doc files are placed.
|
|
Default value for this variable is 'doc').'''
|
|
self.table['docbase'] = ''
|
|
|
|
# Define testsbase methods.
|
|
def getTestsBase(self) -> str:
|
|
'''Return directory relative to destdir where unit tests are placed.
|
|
Default value for this variable is 'tests').'''
|
|
return self.table['testsbase']
|
|
|
|
def setTestsBase(self, testsbase: str) -> None:
|
|
'''Specify directory relative to destdir where unit tests are placed.
|
|
Default value for this variable is 'tests').'''
|
|
if type(testsbase) is str:
|
|
if testsbase:
|
|
self.table['testsbase'] = remove_trailing_slashes(testsbase)
|
|
else: # if type of testsbase is not str
|
|
raise TypeError('testsbase must be a string, not %s'
|
|
% type(testsbase).__name__)
|
|
|
|
def resetTestsBase(self) -> None:
|
|
'''Reset directory relative to destdir where unit tests are placed.
|
|
Default value for this variable is 'tests').'''
|
|
self.table['testsbase'] = ''
|
|
|
|
# Define modules methods.
|
|
def addModule(self, module: str) -> None:
|
|
'''Add the module to the modules list.'''
|
|
if type(module) is str:
|
|
if module not in self.table['modules']:
|
|
self.table['modules'].append(module)
|
|
else: # if module has not str type
|
|
raise TypeError('module must be a string, not %s'
|
|
% type(module).__name__)
|
|
|
|
def removeModule(self, module: str) -> None:
|
|
'''Remove the module from the modules list.'''
|
|
if type(module) is str:
|
|
if module in self.table['modules']:
|
|
self.table['modules'].remove(module)
|
|
else: # if module has not str type
|
|
raise TypeError('module must be a string, not %s'
|
|
% type(module).__name__)
|
|
|
|
def getModules(self) -> list[str]:
|
|
'''Return the modules list.'''
|
|
return list(self.table['modules'])
|
|
|
|
def setModules(self, modules: list[str] | tuple[str]) -> None:
|
|
'''Set the modules list.'''
|
|
if type(modules) is list or type(modules) is tuple:
|
|
old_modules = self.table['modules']
|
|
self.table['modules'] = []
|
|
for module in modules:
|
|
try: # Try to add each module
|
|
self.addModule(module)
|
|
except TypeError as exc:
|
|
self.table['modules'] = old_modules
|
|
raise TypeError('each module must be a string') from exc
|
|
except GLError:
|
|
self.table['modules'] = old_modules
|
|
raise
|
|
else: # if type of modules is not list or tuple
|
|
raise TypeError('modules must be a list or a tuple, not %s'
|
|
% type(modules).__name__)
|
|
|
|
def resetModules(self) -> None:
|
|
'''Reset the list of the modules.'''
|
|
self.table['modules'] = []
|
|
|
|
# Define avoids methods.
|
|
def addAvoid(self, module: str) -> None:
|
|
'''Avoid including the given module. Useful if you have code that provides
|
|
equivalent functionality.'''
|
|
if type(module) is str:
|
|
self.table['avoids'].append(module)
|
|
else: # if module has not str type
|
|
raise TypeError('avoid must be a string, not %s'
|
|
% type(module).__name__)
|
|
|
|
def removeAvoid(self, module: str) -> None:
|
|
'''Remove the given module from the list of avoided modules.'''
|
|
if type(module) is str:
|
|
if module in self.table['avoids']:
|
|
self.table['avoids'].remove(module)
|
|
else: # if module has not str type
|
|
raise TypeError('avoid must be a string, not %s'
|
|
% type(module).__name__)
|
|
|
|
def getAvoids(self) -> list[str]:
|
|
'''Return the list of the avoided modules.'''
|
|
return list(self.table['avoids'])
|
|
|
|
def setAvoids(self, modules: list[str] | tuple[str]) -> None:
|
|
'''Specify the modules which will be avoided.'''
|
|
if type(modules) is list or type(modules) is tuple:
|
|
old_avoids = self.table['avoids']
|
|
self.table['avoids'] = []
|
|
for module in modules:
|
|
try: # Try to add each module
|
|
self.addAvoid(module)
|
|
except TypeError as exc:
|
|
self.table['avoids'] = old_avoids
|
|
raise TypeError('each module must be a string') from exc
|
|
except GLError:
|
|
self.table['avoids'] = old_avoids
|
|
raise
|
|
else: # if type of modules is not list or tuple
|
|
raise TypeError('modules must be a list or a tuple, not %s'
|
|
% type(modules).__name__)
|
|
|
|
def resetAvoids(self) -> None:
|
|
'''Reset the list of the avoided modules.'''
|
|
self.table['avoids'] = []
|
|
|
|
# Define files methods.
|
|
def addFile(self, file: str) -> None:
|
|
'''Add file to the list of files.'''
|
|
if type(file) is str:
|
|
if file not in self.table['files']:
|
|
self.table['files'].append(file)
|
|
else: # if file has not str type
|
|
raise TypeError('file must be a string, not %s'
|
|
% type(file).__name__)
|
|
|
|
def removeFile(self, file: str) -> None:
|
|
'''Remove the given file from the list of files.'''
|
|
if type(file) is str:
|
|
if file in self.table['files']:
|
|
self.table['files'].remove(file)
|
|
else: # if file has not str type
|
|
raise TypeError('file must be a string, not %s'
|
|
% type(file).__name__)
|
|
|
|
def getFiles(self) -> list[str]:
|
|
'''Return the list of files.'''
|
|
return list(self.table['files'])
|
|
|
|
def setFiles(self, files: list[str] | tuple[str]) -> None:
|
|
'''Specify the list of files.'''
|
|
if type(files) is list or type(files) is tuple:
|
|
old_files = self.table['files']
|
|
self.table['files'] = []
|
|
for file in files:
|
|
try: # Try to add each file
|
|
self.addFile(file)
|
|
except TypeError as exc:
|
|
self.table['files'] = old_files
|
|
raise TypeError('each file must be a string') from exc
|
|
except GLError:
|
|
self.table['files'] = old_files
|
|
raise
|
|
else: # if type of files is not list or tuple
|
|
raise TypeError('files must be a list or a tuple, not %s'
|
|
% type(files).__name__)
|
|
|
|
def resetFiles(self) -> None:
|
|
'''Reset the list of files.'''
|
|
self.table['files'] = []
|
|
|
|
# Define incobsolete methods.
|
|
def checkIncObsolete(self) -> bool:
|
|
'''Check if user enabled inclusion of obsolete dependencies.'''
|
|
return self.table['incobsolete']
|
|
|
|
def setIncObsolete(self, value: bool) -> None:
|
|
'''Enable / disable inclusion of obsolete dependencies.'''
|
|
if type(value) is bool:
|
|
self.table['incobsolete'] = value
|
|
else: # if type(value) is not bool
|
|
raise TypeError('value must be a bool, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetIncObsolete(self) -> None:
|
|
'''Reset inclusion of obsolete dependencies.'''
|
|
self.table['incobsolete'] = False
|
|
|
|
# Define incl_test_categories methods
|
|
def checkInclTestCategory(self, category: int) -> bool:
|
|
'''Tests whether the given test category is included.'''
|
|
if category in TESTS.values():
|
|
return category in self.table['incl_test_categories']
|
|
else: # if category is not in TESTS
|
|
raise TypeError('unknown category: %s' % repr(category))
|
|
|
|
def enableInclTestCategory(self, category: int) -> None:
|
|
'''Enable the given test category.'''
|
|
if category in TESTS.values():
|
|
if category not in self.table['incl_test_categories']:
|
|
self.table['incl_test_categories'].append(category)
|
|
else: # if category is not in TESTS
|
|
raise TypeError('unknown category: %s' % repr(category))
|
|
|
|
def disableInclTestCategory(self, category: int) -> None:
|
|
'''Disable the given test category.'''
|
|
if category in TESTS.values():
|
|
if category in self.table['incl_test_categories']:
|
|
self.table['incl_test_categories'].remove(category)
|
|
else: # if category is not in TESTS
|
|
raise TypeError('unknown category: %s' % repr(category))
|
|
|
|
def setInclTestCategory(self, category: int, enable: bool) -> None:
|
|
'''Enable or disable the given test category.'''
|
|
if enable:
|
|
self.enableInclTestCategory(category)
|
|
else:
|
|
self.disableInclTestCategory(category)
|
|
|
|
def getInclTestCategories(self) -> list[int]:
|
|
'''Return the test categories that should be included.
|
|
To get the list of all test categories, use the TESTS variable.'''
|
|
return list(self.table['incl_test_categories'])
|
|
|
|
def setInclTestCategories(self, categories: list[int] | tuple[int]) -> None:
|
|
'''Specify the test categories that should be included.'''
|
|
if type(categories) is list or type(categories) is tuple:
|
|
old_categories = self.table['incl_test_categories']
|
|
self.table['incl_test_categories'] = []
|
|
for category in categories:
|
|
try: # Try to enable each category
|
|
self.enableInclTestCategory(category)
|
|
except TypeError as exc:
|
|
self.table['incl_test_categories'] = old_categories
|
|
raise TypeError('each category must be one of TESTS integers') from exc
|
|
else: # if type of categories is not list or tuple
|
|
raise TypeError('categories must be a list or a tuple, not %s'
|
|
% type(categories).__name__)
|
|
|
|
def resetInclTestCategories(self) -> None:
|
|
'''Reset test categories.'''
|
|
self.table['incl_test_categories'] = []
|
|
|
|
# Define excl_test_categories methods
|
|
def checkExclTestCategory(self, category: int) -> bool:
|
|
'''Tests whether the given test category is excluded.'''
|
|
if category in TESTS.values():
|
|
return category in self.table['excl_test_categories']
|
|
else: # if category is not in TESTS
|
|
raise TypeError('unknown category: %s' % repr(category))
|
|
|
|
def enableExclTestCategory(self, category: int) -> None:
|
|
'''Enable the given test category.'''
|
|
if category in TESTS.values():
|
|
if category not in self.table['excl_test_categories']:
|
|
self.table['excl_test_categories'].append(category)
|
|
else: # if category is not in TESTS
|
|
raise TypeError('unknown category: %s' % repr(category))
|
|
|
|
def disableExclTestCategory(self, category: int) -> None:
|
|
'''Disable the given test category.'''
|
|
if category in TESTS.values():
|
|
if category in self.table['excl_test_categories']:
|
|
self.table['excl_test_categories'].remove(category)
|
|
else: # if category is not in TESTS
|
|
raise TypeError('unknown category: %s' % repr(category))
|
|
|
|
def getExclTestCategories(self) -> list[int]:
|
|
'''Return the test categories that should be excluded.
|
|
To get the list of all test categories, use the TESTS variable.'''
|
|
return list(self.table['excl_test_categories'])
|
|
|
|
def setExclTestCategories(self, categories: list[int] | tuple[int]) -> None:
|
|
'''Specify the test categories that should be excluded.'''
|
|
if type(categories) is list or type(categories) is tuple:
|
|
old_categories = self.table['excl_test_categories']
|
|
self.table['excl_test_categories'] = []
|
|
for category in categories:
|
|
try: # Try to enable each category
|
|
self.enableExclTestCategory(category)
|
|
except TypeError as exc:
|
|
self.table['excl_test_categories'] = old_categories
|
|
raise TypeError('each category must be one of TESTS integers') from exc
|
|
else: # if type of categories is not list or tuple
|
|
raise TypeError('categories must be a list or a tuple, not %s'
|
|
% type(categories).__name__)
|
|
|
|
def resetExclTestCategories(self) -> None:
|
|
'''Reset test categories.'''
|
|
self.table['excl_test_categories'] = []
|
|
|
|
# Define libname methods.
|
|
def getLibName(self) -> str:
|
|
'''Return the library name.'''
|
|
return self.table['libname']
|
|
|
|
def setLibName(self, libname: str) -> None:
|
|
'''Specify the library name.'''
|
|
if type(libname) is str:
|
|
if libname:
|
|
self.table['libname'] = libname
|
|
else: # if type of libname is not str
|
|
raise TypeError('libname must be a string, not %s'
|
|
% type(libname).__name__)
|
|
|
|
def resetLibName(self) -> None:
|
|
'''Reset the library name to 'libgnu'.'''
|
|
self.table['libname'] = 'libgnu'
|
|
|
|
# Define libtool methods.
|
|
def checkLibtool(self) -> bool | None:
|
|
'''Check if user enabled libtool rules.'''
|
|
return self.table['libtool']
|
|
|
|
def setLibtool(self, value: bool) -> None:
|
|
'''Enable / disable libtool rules.'''
|
|
if type(value) is bool:
|
|
self.table['libtool'] = value
|
|
else: # if type(value) is not bool
|
|
raise TypeError('value must be a bool, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetLibtool(self) -> None:
|
|
'''Reset libtool rules.'''
|
|
self.table['libtool'] = None
|
|
|
|
# Define conddeps methods.
|
|
def checkCondDeps(self) -> bool | None:
|
|
'''Check if user enabled conditional dependencies.'''
|
|
return self.table['conddeps']
|
|
|
|
def setCondDeps(self, value: bool) -> None:
|
|
'''Enable / disable conditional dependencies (may save configure time and object code).'''
|
|
if type(value) is bool:
|
|
self.table['conddeps'] = value
|
|
else: # if type(value) is not bool
|
|
raise TypeError('value must be a bool, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetCondDeps(self) -> None:
|
|
'''Reset conditional dependencies (may save configure time and object code).'''
|
|
self.table['conddeps'] = None
|
|
|
|
# Define lgpl methods.
|
|
def getLGPL(self) -> str | bool | None:
|
|
'''Check for abort if modules aren't available under the LGPL.
|
|
Default value is None, which means that lgpl is disabled.'''
|
|
return self.table['lgpl']
|
|
|
|
def setLGPL(self, lgpl: str | bool | None) -> None:
|
|
'''Abort if modules aren't available under the LGPL.
|
|
Default value is None, which means that lgpl is disabled.'''
|
|
if lgpl in [None, True, '2', '3orGPLv2', '3']:
|
|
self.table['lgpl'] = lgpl
|
|
else:
|
|
raise TypeError('invalid LGPL version: %s' % repr(lgpl))
|
|
|
|
def resetLGPL(self) -> None:
|
|
'''Disable abort if modules aren't available under the LGPL.
|
|
Default value is None, which means that lgpl is disabled.'''
|
|
self.table['lgpl'] = None
|
|
|
|
# Define gpl methods.
|
|
def getGPL(self) -> str | None:
|
|
'''Check for abort if modules aren't available under the GPL.
|
|
Default value is None, which means that gpl is disabled.'''
|
|
return self.table['gpl']
|
|
|
|
def setGPL(self, gpl: str | bool | None) -> None:
|
|
'''Abort if modules aren't available under the GPL.
|
|
Default value is None, which means that gpl is disabled.'''
|
|
if gpl in [None, '2', '3']:
|
|
self.table['gpl'] = gpl
|
|
else:
|
|
raise TypeError('invalid GPL version: %s' % repr(gpl))
|
|
|
|
def resetGPL(self) -> None:
|
|
'''Disable abort if modules aren't available under the GPL.
|
|
Default value is None, which means that gpl is disabled.'''
|
|
self.table['gpl'] = None
|
|
|
|
# Define gnu-make methods.
|
|
def getGnuMake(self) -> bool:
|
|
'''Return a boolean value describing whether the --gnu-make argument
|
|
was used.'''
|
|
return self.table['gnu_make']
|
|
|
|
def setGnuMake(self, value: bool) -> None:
|
|
'''Set the --gnu-make argument as if it were invoked using the
|
|
command-line or disable it.'''
|
|
if type(value) is bool:
|
|
self.table['gnu_make'] = value
|
|
else: # if type(value) is not bool
|
|
raise TypeError('value must be a bool, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetGnuMake(self) -> None:
|
|
'''Reset the --gnu-make argument to its default. This feature must be
|
|
explicitly enabled by programs who utilize GNU Make features instead
|
|
of Autmake.'''
|
|
self.table['gnu_make'] = False
|
|
|
|
def getModuleIndicatorPrefix(self) -> str:
|
|
'''Return module_indicator_prefix to use inside GLEmiter class.'''
|
|
return self.getIncludeGuardPrefix()
|
|
|
|
# Define macro_prefix and include_guard_prefix methods.
|
|
# The include_guard_prefix is a replacement for ${gl_include_guard_prefix}.
|
|
# It is determined from the macro_prefix.
|
|
def getMacroPrefix(self) -> str:
|
|
'''Return the prefix of the macros 'gl_EARLY' and 'gl_INIT'.
|
|
Default macro_prefix is 'gl'.'''
|
|
return self.table['macro_prefix']
|
|
|
|
def getIncludeGuardPrefix(self) -> str:
|
|
'''Return the replacement for ${gl_include_guard_prefix}.'''
|
|
return self.table['include_guard_prefix']
|
|
|
|
def setMacroPrefix(self, macro_prefix: str) -> None:
|
|
'''Specify the prefix of the macros 'gl_EARLY' and 'gl_INIT'.
|
|
Default macro_prefix is 'gl'.'''
|
|
if type(macro_prefix) is str:
|
|
if macro_prefix:
|
|
self.table['macro_prefix'] = macro_prefix
|
|
else: # if type of macro_prefix is not str
|
|
raise TypeError('macro_prefix must be a string, not %s'
|
|
% type(macro_prefix).__name__)
|
|
if macro_prefix == 'gl':
|
|
include_guard_prefix = 'GL'
|
|
else: # macro_prefix != 'gl'
|
|
include_guard_prefix = 'GL_%s' % macro_prefix.upper()
|
|
self.table['include_guard_prefix'] = include_guard_prefix
|
|
|
|
def resetMacroPrefix(self) -> None:
|
|
'''Reset the prefix of the macros 'gl_EARLY' and 'gl_INIT'.
|
|
Default macro_prefix is 'gl'.'''
|
|
self.table['macro_prefix'] = 'gl'
|
|
self.table['include_guard_prefix'] = 'GL'
|
|
|
|
# Define makefile_name methods.
|
|
def getMakefileName(self) -> str:
|
|
'''Return the name of makefile in automake syntax in the sourcebase directory.
|
|
Default is 'Makefile.am'.'''
|
|
return self.table['makefile_name']
|
|
|
|
def setMakefileName(self, makefile_name: str) -> None:
|
|
'''Specify the name of makefile in automake syntax in the sourcebase directory.
|
|
Default is 'Makefile.am'.'''
|
|
if type(makefile_name) is str:
|
|
if makefile_name:
|
|
self.table['makefile_name'] = makefile_name
|
|
else: # if type of makefile_name is not str
|
|
raise TypeError('makefile_name must be a string, not %s'
|
|
% type(makefile_name).__name__)
|
|
|
|
def resetMakefileName(self) -> None:
|
|
'''Reset the name of makefile in automake syntax in the sourcebase directory.
|
|
Default is 'Makefile.am'.'''
|
|
self.table['makefile_name'] = ''
|
|
|
|
# Define tests_makefile_name methods.
|
|
def getTestsMakefileName(self) -> str:
|
|
'''Return the name of makefile in automake syntax in the testsbase directory.
|
|
Default is the the value of 'makefile_name'.'''
|
|
return self.table['tests_makefile_name']
|
|
|
|
def setTestsMakefileName(self, tests_makefile_name: str) -> None:
|
|
'''Specify the name of makefile in automake syntax in the testsbase directory.
|
|
Default is the value of 'makefile_name'.'''
|
|
if type(tests_makefile_name) is str:
|
|
if tests_makefile_name:
|
|
self.table['tests_makefile_name'] = tests_makefile_name
|
|
else: # if type of tests_makefile_name is not str
|
|
raise TypeError('tests_makefile_name must be a string, not %s'
|
|
% type(tests_makefile_name).__name__)
|
|
|
|
def resetTestsMakefileName(self) -> None:
|
|
'''Reset the name of makefile in automake syntax in the testsbase directory.
|
|
Default is the value of 'makefile_name'.'''
|
|
self.table['tests_makefile_name'] = ''
|
|
|
|
# Define automake_subdir methods.
|
|
def getAutomakeSubdir(self) -> bool:
|
|
'''Return a bool describing whether --automake-subdir is in use
|
|
or not.'''
|
|
return self.table['automake_subdir']
|
|
|
|
def setAutomakeSubdir(self, automake_subdir: bool) -> None:
|
|
'''Set the value describing whether --automake-subdir is in use.'''
|
|
if type(automake_subdir) is bool:
|
|
self.table['automake_subdir'] = automake_subdir
|
|
else: # if type of automake_subdir is not bool
|
|
raise TypeError('automake_subdir must be a bool, not %s'
|
|
% type(automake_subdir).__name__)
|
|
|
|
def resetAutomakeSubdir(self) -> None:
|
|
'''Reset the value describing whether --automake-subdir is in use.
|
|
Default is False.'''
|
|
self.table['automake_subdir'] = False
|
|
|
|
# Define automake_subdir_tests methods.
|
|
def getAutomakeSubdirTests(self) -> bool:
|
|
'''Return a bool describing whether --automake-subdir-tests is in use
|
|
or not.'''
|
|
return self.table['automake_subdir_tests']
|
|
|
|
def setAutomakeSubdirTests(self, automake_subdir_tests: bool) -> None:
|
|
'''Set the value describing whether --automake-subdir-tests is in use.'''
|
|
if type(automake_subdir_tests) is bool:
|
|
self.table['automake_subdir_tests'] = automake_subdir_tests
|
|
else: # if type of automake_subdir_tests is not bool
|
|
raise TypeError('automake_subdir_tests must be a bool, not %s'
|
|
% type(automake_subdir_tests).__name__)
|
|
|
|
def resetAutomakeSubdirTests(self) -> None:
|
|
'''Reset the value describing whether --automake-subdir-tests is in use.
|
|
Default is False.'''
|
|
self.table['automake_subdir_tests'] = False
|
|
|
|
# Define podomain methods.
|
|
def getPoDomain(self) -> str:
|
|
'''Return the prefix of the i18n domain. Usually use the package name.
|
|
A suffix '-gnulib' is appended.'''
|
|
return self.table['podomain']
|
|
|
|
def setPoDomain(self, podomain: str) -> None:
|
|
'''Specify the prefix of the i18n domain. Usually use the package name.
|
|
A suffix '-gnulib' is appended.'''
|
|
if type(podomain) is str:
|
|
if podomain:
|
|
self.table['podomain'] = podomain
|
|
else: # if type of podomain is not str
|
|
raise TypeError('podomain must be a string, not %s'
|
|
% type(podomain).__name__)
|
|
|
|
def resetPoDomain(self) -> None:
|
|
'''Reset the prefix of the i18n domain. Usually use the package name.
|
|
A suffix '-gnulib' is appended.'''
|
|
self.table['podomain'] = ''
|
|
|
|
# Define witness_c_macro methods.
|
|
def getWitnessCMacro(self) -> str:
|
|
'''Return the C macro that is defined when the sources in this directory
|
|
are compiled or used.'''
|
|
return self.table['witness_c_macro']
|
|
|
|
def setWitnessCMacro(self, witness_c_macro: str) -> None:
|
|
'''Specify the C macro that is defined when the sources in this directory
|
|
are compiled or used.'''
|
|
if type(witness_c_macro) is str:
|
|
if witness_c_macro:
|
|
self.table['witness_c_macro'] = witness_c_macro
|
|
else: # if type of witness_c_macro is not str
|
|
raise TypeError('witness_c_macro must be a string, not %s'
|
|
% type(witness_c_macro).__name__)
|
|
|
|
def resetWitnessCMacro(self) -> None:
|
|
'''Return the C macro that is defined when the sources in this directory
|
|
are compiled or used.'''
|
|
self.table['witness_c_macro'] = ''
|
|
|
|
# Define vc_files methods.
|
|
def checkVCFiles(self) -> bool | None:
|
|
'''Check if update of the version control files is enabled or disabled.'''
|
|
return self.table['vc_files']
|
|
|
|
def setVCFiles(self, value: bool) -> None:
|
|
'''Enable /disable update of the version control files.'''
|
|
if type(value) is bool:
|
|
self.table['vc_files'] = value
|
|
else: # if type(value) is not bool
|
|
raise TypeError('value must be a bool, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetVCFiles(self) -> None:
|
|
'''Reset update of the version control files and set it to None.'''
|
|
self.table['vc_files'] = None
|
|
|
|
# Define configure_ac methods.
|
|
def getAutoconfFile(self) -> str:
|
|
'''Return path of autoconf file relative to destdir.'''
|
|
return self.table['configure_ac']
|
|
|
|
def setAutoconfFile(self, configure_ac: str) -> None:
|
|
'''Specify path of autoconf file relative to destdir.'''
|
|
if type(configure_ac) is str:
|
|
if configure_ac:
|
|
self.table['configure_ac'] = configure_ac
|
|
else: # if type of configure_ac is not str
|
|
raise TypeError('configure_ac must be a string, not %s'
|
|
% type(configure_ac).__name__)
|
|
|
|
def resetAutoconfFile(self) -> None:
|
|
'''Reset path of autoconf file relative to destdir.'''
|
|
configure_ac = ''
|
|
if os.path.isfile(joinpath(self.table['destdir'], 'configure.ac')):
|
|
configure_ac = joinpath(self.table['destdir'], 'configure.ac')
|
|
elif os.path.isfile(joinpath(self.table['destdir'], 'configure.in')):
|
|
configure_ac = joinpath(self.table['destdir'], 'configure.in')
|
|
self.table['configure_ac'] = configure_ac
|
|
|
|
# Define ac_version methods.
|
|
def getAutoconfVersion(self) -> float:
|
|
'''Return preferred autoconf version. Default value is 2.64.'''
|
|
return self.table['ac_version']
|
|
|
|
def setAutoconfVersion(self, ac_version: float | int) -> None:
|
|
'''Specify preferred autoconf version. Default value is 2.64.'''
|
|
if type(ac_version) is float or type(ac_version) is int:
|
|
self.table['ac_version'] = float(ac_version)
|
|
else: # if ac_version has not int or float type
|
|
raise TypeError('ac_version must be an int or a float, not %s'
|
|
% type(ac_version).__name__)
|
|
|
|
def resetAutoconfVersion(self) -> None:
|
|
'''Specify preferred autoconf version. Default value is 2.64.'''
|
|
self.table['ac_version'] = 2.64
|
|
|
|
# Define copymode methods.
|
|
def checkCopyMode(self) -> CopyAction:
|
|
'''Check if pygnulib will copy files, create symlinks, or create hard links.'''
|
|
return self.table['copymode']
|
|
|
|
def setCopyMode(self, value: CopyAction) -> None:
|
|
'''Change the method used for copying / linking files.'''
|
|
if type(value) is CopyAction:
|
|
self.table['copymode'] = value
|
|
else: # if type(value) is not CopyAction
|
|
raise TypeError('value must be a CopyAction, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetCopyMode(self) -> None:
|
|
'''Reset the method used for creating files to copying instead of linking.'''
|
|
self.table['copymode'] = CopyAction.Copy
|
|
|
|
# Define lcopymode methods.
|
|
def checkLCopyMode(self) -> CopyAction:
|
|
'''Check if pygnulib will copy files, create symlinks, or create hard links,
|
|
only for files from the local override directories.'''
|
|
return self.table['lcopymode']
|
|
|
|
def setLCopyMode(self, value: CopyAction) -> None:
|
|
'''Change the method used for copying / linking files, only for files from
|
|
the local override directories.'''
|
|
if type(value) is CopyAction:
|
|
self.table['lcopymode'] = value
|
|
else: # if type(value) is not CopyAction
|
|
raise TypeError('value must be a CopyAction, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetLCopyMode(self) -> None:
|
|
'''Reset the method used for creating files to copying instead of linking,
|
|
only for files from the local override directories.'''
|
|
self.table['lcopymode'] = CopyAction.Copy
|
|
|
|
# Define verbosity methods.
|
|
def getVerbosity(self) -> int:
|
|
'''Get verbosity level.'''
|
|
return self.table['verbosity']
|
|
|
|
def decreaseVerbosity(self) -> None:
|
|
'''Decrease verbosity level.'''
|
|
if self.table['verbosity'] > MODES['verbose-min']:
|
|
self.table['verbosity'] -= 1
|
|
|
|
def increaseVerbosity(self) -> None:
|
|
'''Increase verbosity level.'''
|
|
if self.table['verbosity'] < MODES['verbose-max']:
|
|
self.table['verbosity'] += 1
|
|
|
|
def setVerbosity(self, verbose: int) -> None:
|
|
'''Set verbosity level to verbose, where -2 <= verbose <= 2.
|
|
If verbosity level is less than -2, verbosity level will be set to -2.
|
|
If verbosity level is greater than 2, verbosity level will be set to 2.'''
|
|
if type(verbose) is int:
|
|
if MODES['verbose-min'] <= verbose <= MODES['verbose-max']:
|
|
self.table['verbosity'] = verbose
|
|
elif verbose < MODES['verbose-min']:
|
|
self.table['verbosity'] = MODES['verbose-min']
|
|
elif verbose > MODES['verbose-max']:
|
|
self.table['verbosity'] = MODES['verbose-max']
|
|
else: # if type(verbose) is not int
|
|
raise TypeError('verbosity must be an int, not %s'
|
|
% type(verbose).__name__)
|
|
|
|
def resetVerbosity(self) -> None:
|
|
'''Reset verbosity level.'''
|
|
self.table['verbosity'] = 0
|
|
|
|
# Define libtests methods.
|
|
def checkLibtests(self) -> bool:
|
|
'''Return True if a testsbase/libtests.a is needed.'''
|
|
return self.table['libtests']
|
|
|
|
def setLibtests(self, value: bool) -> None:
|
|
'''Specifies whether testsbase/libtests.a is needed.'''
|
|
if type(value) is bool:
|
|
self.table['libtests'] = value
|
|
else: # if type(value) is not bool
|
|
raise TypeError('value must be a bool, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetLibtests(self) -> None:
|
|
'''Reset status of testsbase/libtests.a.'''
|
|
self.table['libtests'] = False
|
|
|
|
# Define single_configure methods.
|
|
def checkSingleConfigure(self) -> bool:
|
|
'''Check whether single configure file should be generated.'''
|
|
return self.table['single_configure']
|
|
|
|
def setSingleConfigure(self, value: bool) -> None:
|
|
'''Enable / disable generation of the single configure file.'''
|
|
if type(value) is bool:
|
|
self.table['single_configure'] = value
|
|
else: # if type(value) is not bool
|
|
raise TypeError('value must be a bool, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetSingleConfigure(self) -> None:
|
|
'''Reset status of the single configure file generation.'''
|
|
self.table['single_configure'] = False
|
|
|
|
# Define dryrun methods.
|
|
def checkDryRun(self) -> bool:
|
|
'''Check whether dryrun is enabled.'''
|
|
return self.table['dryrun']
|
|
|
|
def setDryRun(self, value: bool) -> None:
|
|
'''Enable / disable dryrun mode.'''
|
|
if type(value) is bool:
|
|
self.table['dryrun'] = value
|
|
else: # if type(value) is not bool
|
|
raise TypeError('value must be a bool, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetDryRun(self) -> None:
|
|
'''Reset status of dryrun mode.'''
|
|
self.table['dryrun'] = False
|
|
|
|
# Define errors methods.
|
|
def checkErrors(self) -> bool:
|
|
'''Check if GLError will be raised in non-critical situations.'''
|
|
return self.table['errors']
|
|
|
|
def setErrors(self, value: bool) -> None:
|
|
'''Enable / disable raising GLError in non-critical situations.'''
|
|
if type(value) is bool:
|
|
self.table['errors'] = value
|
|
else: # if type(value) is not bool
|
|
raise TypeError('value must be a bool, not %s'
|
|
% type(value).__name__)
|
|
|
|
def resetErrors(self) -> None:
|
|
'''Reset status of raising GLError in non-critical situations.'''
|
|
self.table['errors'] = False
|