* pygnulib/*.py: Remove parentheses around return value expressions.
2022-07-29 Bruno Haible <bruno@clisp.org>
+ gnulib-tool.py: Modernize coding style.
+ * pygnulib/*.py: Remove parentheses around return value expressions.
+
gnulib-tool.py: Modernize the file headers.
* pygnulib/*.py: Remove '#!/usr/bin/python' (not needed) and
'encoding: UTF-8' lines (default in Python 3). Add copyright notice.
# Define special methods.
def __repr__(self):
'''x.__repr__() <==> repr(x)'''
- return('<pygnulib.GLConfig>')
+ return '<pygnulib.GLConfig>'
def __getitem__(self, y):
'''x.__getitem__(y) <==> x[y]'''
if self.table['auxdir']:
return self.table['auxdir']
return "build-aux"
- return(self.table[y])
+ return self.table[y]
else: # if y not in self.table
raise(KeyError('GLConfig does not contain key: %s' % repr(y)))
def dictionary(self):
'''Return the configuration as a dict object.'''
- return(dict(self.table))
+ return dict(self.table)
def copy(self):
'''Return the copy of the configuration.'''
table = copy.deepcopy(self)
- return(table)
+ return table
def update(self, dictionary):
'''Specify the dictionary whose keys will be used to update config.'''
'''Return default value for the given key.'''
if key in self.table:
if key == 'libname':
- return(string('libgnu'))
+ return string('libgnu')
elif key == 'macro_prefix':
- return(string('gl'))
+ return string('gl')
elif key == 'include_guard_prefix':
- return(string('GL'))
+ return string('GL')
elif key == 'ac_version':
- return(2.59)
+ return 2.59
elif key == 'verbosity':
- return(0)
+ return 0
elif key == 'copyrights':
- return(True)
+ return True
elif key in ['modules', 'avoids', 'tests', 'testflags']:
- return(list())
+ return list()
elif key in ['libtool', 'lgpl', 'conddeps', 'modcache', 'symbolic',
'lsymbolic', 'libtests', 'dryrun']:
- return(False)
+ return False
if key == 'vc_files':
- return(None)
+ return None
elif key == 'errors':
- return(True)
+ return True
else: # otherwise
- return(string())
+ return string()
else: # if key not in self.table
raise(KeyError('GLConfig does not contain key: %s' % repr(key)))
'''Check whether the value for the given key is a default value.'''
if key in self.table:
default = self.default(key)
- return(value == default)
+ return value == default
else: # if key not in self.table
raise(KeyError('GLConfig does not contain key: %s' % repr(key)))
def keys(self):
'''Return list of keys.'''
- return(list(self.table.keys()))
+ return list(self.table.keys())
def values(self):
'''Return list of values.'''
- return(list(self.table.values()))
+ return list(self.table.values())
# Define destdir methods.
def getDestDir(self):
'''Return the target directory. For --import, this specifies where your
configure.ac can be found. Defaults to current directory.'''
- return(self.table['destdir'])
+ return self.table['destdir']
def setDestDir(self, destdir):
'''Specify the target directory. For --import, this specifies where your
def getLocalDir(self):
'''Return a local override directory where to look up files before looking
in gnulib's directory.'''
- return(self.table['localdir'])
+ return self.table['localdir']
def setLocalDir(self, localdir):
'''Specify a local override directory where to look up files before looking
# Define sourcebase methods.
def getSourceBase(self):
'''Return directory relative to destdir where source code is placed.'''
- return(self.table['sourcebase'])
+ return self.table['sourcebase']
def setSourceBase(self, sourcebase):
'''Specify directory relative to destdir where source code is placed.'''
# Define m4base methods.
def getM4Base(self):
'''Return directory relative to destdir where *.m4 macros are placed.'''
- return(self.table['m4base'])
+ return self.table['m4base']
def setM4Base(self, m4base):
'''Specify directory relative to destdir where *.m4 macros are placed.'''
# Define pobase methods.
def getPoBase(self):
'''Return directory relative to destdir where *.po files are placed.'''
- return(self.table['pobase'])
+ return self.table['pobase']
def setPoBase(self, pobase):
'''Specify directory relative to destdir where *.po files are placed.'''
def getDocBase(self):
'''Return directory relative to destdir where doc files are placed.
Default value for this variable is 'doc').'''
- return(self.table['docbase'])
+ return self.table['docbase']
def setDocBase(self, docbase):
'''Specify directory relative to destdir where doc files are placed.
def getTestsBase(self):
'''Return directory relative to destdir where unit tests are placed.
Default value for this variable is 'tests').'''
- return(self.table['testsbase'])
+ return self.table['testsbase']
def setTestsBase(self, testsbase):
'''Specify directory relative to destdir where unit tests are placed.
def getModules(self):
'''Return the modules list.'''
- return(list(self.table['modules']))
+ return list(self.table['modules'])
def setModules(self, modules):
'''Set the modules list.'''
def getAvoids(self):
'''Return the list of the avoided modules.'''
- return(list(self.table['avoids']))
+ return list(self.table['avoids'])
def setAvoids(self, modules):
'''Specify the modules which will be avoided.'''
def getFiles(self):
'''Return the list of the fileed files.'''
- return(list(self.table['files']))
+ return list(self.table['files'])
def setFiles(self, files):
'''Specify the list of files.'''
def checkTestFlag(self, flag):
'''Return the status of the test flag.'''
if flag in TESTS.values():
- return(flag in self.table['testflags'])
+ return flag in self.table['testflags']
else: # if flag is not in TESTS
raise(TypeError('unknown flag: %s' % repr(flag)))
def getTestFlags(self):
'''Return test flags. You can get flags from TESTS variable.'''
- return(list(self.table['testflags']))
+ return list(self.table['testflags'])
def setTestFlags(self, testflags):
'''Specify test flags. You can get flags from TESTS variable.'''
# Define libname methods.
def getLibName(self):
'''Return the library name.'''
- return(self.table['libname'])
+ return self.table['libname']
def setLibName(self, libname):
'''Specify the library name.'''
# Define libtool methods.
def checkLibtool(self):
'''Check if user enabled libtool rules.'''
- return(self.table['libtool'])
+ return self.table['libtool']
def enableLibtool(self):
'''Enable libtool rules.'''
# Define conddeps methods.
def checkCondDeps(self):
'''Check if user enabled cond. dependencies.'''
- return(self.table['conddeps'])
+ return self.table['conddeps']
def enableCondDeps(self):
'''Enable cond. dependencies (may save configure time and object code).'''
def getLGPL(self):
'''Check for abort if modules aren't available under the LGPL.
Default value is False, which means that lgpl is disabled.'''
- return(self.table['lgpl'])
+ return self.table['lgpl']
def setLGPL(self, lgpl):
'''Abort if modules aren't available under the LGPL.
def getIncludeGuardPrefix(self):
'''Return include_guard_prefix to use inside GLEmiter class.'''
- return(self.table['include_guard_prefix'])
+ return self.table['include_guard_prefix']
def getModuleIndicatorPrefix(self):
'''Return module_indicator_prefix to use inside GLEmiter class.'''
- return(self.getIncludeGuardPrefix())
+ return self.getIncludeGuardPrefix()
# Define macro_prefix methods.
def getMacroPrefix(self):
'''Return the prefix of the macros 'gl_EARLY' and 'gl_INIT'.
Default macro_prefix is 'gl'.'''
- return(self.table['macro_prefix'])
+ return self.table['macro_prefix']
def setMacroPrefix(self, macro_prefix):
'''Specify the prefix of the macros 'gl_EARLY' and 'gl_INIT'.
def getMakefile(self):
'''Return the name of makefile in automake syntax in the source-base and
tests-base directories. Default is 'Makefile.am'.'''
- return(self.table['makefile'])
+ return self.table['makefile']
def setMakefile(self, makefile):
'''Specify the name of makefile in automake syntax in the source-base and
def getPoDomain(self):
'''Return the prefix of the i18n domain. Usually use the package name.
A suffix '-gnulib' is appended.'''
- return(self.table['podomain'])
+ return self.table['podomain']
def setPoDomain(self, podomain):
'''Specify the prefix of the i18n domain. Usually use the package name.
def getWitnessCMacro(self):
'''Return the C macro that is defined when the sources in this directory
are compiled or used.'''
- return(self.table['witness_c_macro'])
+ return self.table['witness_c_macro']
def setWitnessCMacro(self, witness_c_macro):
'''Specify the C macro that is defined when the sources in this directory
# Define vc_files methods.
def checkVCFiles(self):
'''Check if update of the version control files is enabled or disabled.'''
- return(self.table['vc_files'])
+ return self.table['vc_files']
def enableVCFiles(self):
'''Enable update of the version control files.'''
# Define modcache methods.
def checkModuleCaching(self):
'''Get status of module caching optimization.'''
- return(self.table['modcache'])
+ return self.table['modcache']
def enableModuleCaching(self):
'''Enable module caching optimization.'''
# Define configure_ac methods.
def getAutoconfFile(self):
'''Return path of autoconf file relative to destdir.'''
- return(self.table['configure_ac'])
+ return self.table['configure_ac']
def setAutoconfFile(self, configure_ac):
'''Specify path of autoconf file relative to destdir.'''
# Define ac_version methods.
def getAutoconfVersion(self):
'''Return preferred autoconf version. Default value is 2.59.'''
- return(self.table['ac_version'])
+ return self.table['ac_version']
def setAutoconfVersion(self, ac_version):
'''Specify preferred autoconf version. Default value is 2.59.'''
# Define symbolic methods.
def checkCopyrights(self):
'''Check if copyright notices in files should be replaced.'''
- return(self.table['copyrights'])
+ return self.table['copyrights']
def checkSymbolic(self):
'''Check if pygnulib will make symbolic links instead of copying files.'''
- return(self.table['symbolic'])
+ return self.table['symbolic']
def enableSymbolic(self):
'''Enable creation of the symbolic links instead of copying files.'''
def checkLSymbolic(self):
'''Check if pygnulib will make symbolic links instead of copying files, only
for files from the local override directory.'''
- return(self.table['lsymbolic'])
+ return self.table['lsymbolic']
def enableLSymbolic(self):
'''Enable creation of symbolic links instead of copying files, only for
# Define verbosity methods.
def getVerbosity(self):
'''Get verbosity level.'''
- return(self.table['verbosity'])
+ return self.table['verbosity']
def decreaseVerbosity(self):
'''Decrease verbosity level.'''
# Define libtests methods.
def checkLibtests(self):
'''Return True if a testsbase/libtests.a is needed.'''
- return(self.table['libtests'])
+ return self.table['libtests']
def enableLibtests(self):
'''If libtests is enabled, then testsbase/libtests.a is needed.'''
# Define single_configure methods.
def checkSingleConfigure(self):
'''Check whether single configure file should be generated.'''
- return(self.table['single_configure'])
+ return self.table['single_configure']
def enableSingleConfigure(self):
'''Enable generation of the single configure file.'''
# Define dryrun methods.
def checkDryRun(self):
'''Check whether dryrun is enabled.'''
- return(self.table['dryrun'])
+ return self.table['dryrun']
def enableDryRun(self):
'''Enable dryrun mode.'''
# Define errors methods.
def checkErrors(self):
'''Check if GLError will be raised in non-critical situations.'''
- return(self.table['errors'])
+ return self.table['errors']
def enableErrors(self):
'''Raise GLError in non-critical situations.'''
def __repr__(self):
'''x.__repr__() <==> repr(x)'''
result = '<pygnulib.GLEmiter %s>' % hex(id(self))
- return(result)
+ return result
def copyright_notice(self):
'''GLEmiter.copyright_notice() -> string
# Generated by gnulib-tool.\n"""
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(constants.nlconvert(emit))
+ return constants.nlconvert(emit)
def autoconfSnippet(self, module, fileassistant, toplevel,
disable_libtool, disable_gettext, replace_auxdir, indentation):
emit = constants.nlconvert(emit)
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(emit)
+ return emit
def autoconfSnippets(self, modules, moduletable, fileassistant,
verifier, toplevel, disable_libtool, disable_gettext, replace_auxdir):
emit = constants.nlconvert(emit)
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(emit)
+ return emit
def po_Makevars(self):
'''GLEmiter.po_Makevars() -> string
USE_MSGCTXT = no\n"""
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(constants.nlconvert(emit))
+ return constants.nlconvert(emit)
def po_POTFILES_in(self, files):
'''GLEmiter.po_POTFILES_in(files) -> string
emit += '\n'
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(constants.nlconvert(emit))
+ return constants.nlconvert(emit)
def initmacro_start(self, macro_prefix_arg):
'''GLEmiter.initmacro_start(macro_prefix_arg) -> string
emit = emit.replace('%V1%', macro_prefix_arg)
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(constants.nlconvert(emit))
+ return constants.nlconvert(emit)
def initmacro_end(self, macro_prefix_arg):
'''GLEmiter.initmacro_end(macro_prefix_arg) -> string
emit = emit.replace('%V1%', macro_prefix_arg)
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(constants.nlconvert(emit))
+ return constants.nlconvert(emit)
def initmacro_done(self, macro_prefix_arg, sourcebase_arg):
'''GLEmiter.initmacro_done(macro_prefix_arg, sourcebase_arg) -> string
emit = emit.replace('%V2%', sourcebase_arg)
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(constants.nlconvert(emit))
+ return constants.nlconvert(emit)
def lib_Makefile_am(self, destfile, modules,
moduletable, makefiletable, actioncmd, for_test):
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
result = tuple([emit, uses_subdirs])
- return(result)
+ return result
def tests_Makefile_am(self, destfile, modules, makefiletable,
witness_macro, for_test):
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
result = tuple([emit, uses_subdirs])
- return(result)
+ return result
else: # if PYTHON3
self.message = ('[Errno %d] %s' %
(self.errno, errors[self.errno - 1]))
- return(self.message)
+ return self.message
def __repr__(self):
'''x.__repr__ <==> repr(x)'''
result = '<pygnulib.GLFileSystem %s>' % hex(id(self))
- return(result)
+ return result
def lookup(self, name):
'''GLFileSystem.lookup(name) -> tuple
result = (path_gnulib, False)
else: # if path_gnulib does not exist
raise(GLError(1, name))
- return(result)
+ return result
#===============================================================================
def __repr__(self):
'''x.__repr__() <==> repr(x)'''
result = '<pygnulib.GLFileAssistant %s>' % hex(id(self))
- return(result)
+ return result
def tmpfilename(self, path):
'''GLFileAssistant.tmpfilename() -> string
os.makedirs(dirname)
if type(result) is bytes:
result = bytes.decode(ENCS['default'])
- return(result)
+ return result
def setOriginal(self, original):
'''GLFileAssistant.setOriginal(original)
def getFiles(self):
'''Return list of the added files.'''
- return(list(self.added))
+ return list(self.added)
def add(self, lookedup, tmpflag, tmpfile):
'''GLFileAssistant.add(lookedup, tmpflag, tmpfile)
else: # if self.config['dryrun']
os.remove(tmpfile)
result = tuple([basename, backupname, result_flag])
- return(result)
+ return result
def __repr__(self):
'''x.__repr__ <==> repr(x)'''
result = '<pygnulib.GLImport %s>' % hex(id(self))
- return(result)
+ return result
def rewrite_old_files(self, files):
'''GLImport.rewrite_old_files(files) -> list
path = file
result += [os.path.normpath(path)]
result = sorted(set(result))
- return(list(result))
+ return list(result)
def rewrite_new_files(self, files):
'''GLImport.rewrite_new_files(files)
path = file
result += [os.path.normpath(path)]
result = sorted(set(result))
- return(list(result))
+ return list(result)
def actioncmd(self):
'''Return command-line invocation comment.'''
actioncmd += ' --no-vc-files'
actioncmd += ' ' # Add a space
actioncmd += ' '.join(modules)
- return(actioncmd)
+ return actioncmd
def gnulib_cache(self):
'''GLImport.gnulib_cache() -> string
emit += 'gl_VC_FILES([%s])\n' % vc_files
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(constants.nlconvert(emit))
+ return constants.nlconvert(emit)
def gnulib_comp(self, files):
'''GLImport.gnulib_comp(files) -> string
emit += '])\n'
if type(emit) is bytes:
emit = emit.decode(ENCS['default'])
- return(emit)
+ return emit
def _done_dir_(self, directory, dirs_added, dirs_removed):
'''GLImport._done_dir_(directory, dirs_added, dirs_removed)
# Return the result.
result = tuple([filetable, transformers])
- return(result)
+ return result
def execute(self, filetable, transformers):
'''Perform operations on the lists of files, which are given in a special
def __repr__(self):
'''x.__repr__ <==> repr(x)'''
result = '<pygnulib.GLInfo %s>' % hex(id(self))
- return(result)
+ return result
def package(self):
'''Return formatted string which contains name of the package.'''
result = 'GNU gnulib'
- return(result)
+ return result
def authors(self):
'''Return formatted string which contains authors.
result += 'and %s' % item
else:
result += '%s, ' % item
- return(result)
+ return result
def license(self):
'''Return formatted string which contains license and its description.'''
result += 'This is free software: you are free'
result += ' to change and redistribute it.\n'
result += 'There is NO WARRANTY, to the extent permitted by law.'
- return(result)
+ return result
def copyright(self):
'''Return formatted string which contains copyright.
The special __copyright__ variable is used (type is str).'''
result = 'Copyright (C) %s' % __copyright__
- return(result)
+ return result
def date(self):
'''Return formatted string which contains date and time in GMT format.'''
proc = sp.check_output(args)
result = string(proc, "UTF-8")
result = result.rstrip(os.linesep)
- return(result)
+ return result
def usage(self):
'''Show help message.'''
-S, --more-symlinks Deprecated; equivalent to --symlink.
Report bugs to <bug-gnulib@gnu.org>.'''
- return(result)
+ return result
def version(self):
'''Return formatted string which contains git version.'''
result = result.strip()
if result == 'UNKNOWN':
result = string()
- return(result)
+ return result
raise(TypeError('indices must be integers, not %s' %
type(y).__name__))
result = self.table[y]
- return(dict(result))
+ return dict(result)
def editor(self, dir, var, val):
'''GLMakefileTable.editor(dir, var, val)
'''GLMakefileTable.count() -> int
Count number of edits which were applied.'''
- return(len(self.table))
+ return len(self.table)
def __repr__(self):
'''x.__repr__ <==> repr(x)'''
result = '<pygnulib.GLModuleSystem %s>' % hex(id(self))
- return(result)
+ return result
def exists(self, module):
'''GLModuleSystem.exists(module) -> bool
]): # Close all(iterable) function
if module not in badnames:
result = True
- return(result)
+ return result
def find(self, module):
'''GLModuleSystem.find(module) -> GLModule
if self.exists(module):
path, istemp = self.filesystem.lookup(joinpath('modules', module))
result = GLModule(self.config, path, istemp)
- return(result)
+ return result
else: # if not self.exists(module)
if self.config['errors']:
raise(GLError(3, module))
os.remove(path)
listing = [line for line in result.split('\n') if line.strip()]
listing = sorted(set(listing))
- return(listing)
+ return listing
#===============================================================================
if type(module) is GLModule:
if self.module == module.module:
result = True
- return(result)
+ return result
def __ne__(self, module):
'''x.__ne__(y) <==> x!=y'''
if type(module) is GLModule:
if self.module != module.module:
result = True
- return(result)
+ return result
def __ge__(self, module):
'''x.__ge__(y) <==> x>=y'''
if type(module) is GLModule:
if self.module >= module.module:
result = True
- return(result)
+ return result
def __gt__(self, module):
'''x.__gt__(y) <==> x>y'''
if type(module) is GLModule:
if self.module > module.module:
result = True
- return(result)
+ return result
def __hash__(self):
'''x.__hash__() <==> hash(x)'''
module = hash(self.module)
patched = hash(self.patched)
result = module ^ patched
- return(result)
+ return result
def __le__(self, module):
'''x.__le__(y) <==> x<=y'''
if type(module) is GLModule:
if self.module <= module.module:
result = True
- return(result)
+ return result
def __lt__(self, module):
'''x.__lt__(y) <==> x<y'''
if type(module) is GLModule:
if self.module < module.module:
result = True
- return(result)
+ return result
def __str__(self):
'''x.__str__() <==> str(x)'''
result = self.getName()
- return(result)
+ return result
def __repr__(self):
'''x.__repr__ <==> repr(x)'''
result = '<pygnulib.GLModule %s %s>' % \
(repr(self.getName()), hex(id(self)))
- return(result)
+ return result
def getName(self):
'''GLModule.getName() -> string
Return the name of the module.'''
pattern = compiler(joinpath('modules', '(.*?)$'))
result = pattern.findall(self.module)[0]
- return(result)
+ return result
def isPatched(self):
'''GLModule.isPatched() -> bool
Check whether module was created after applying patch.'''
- return(self.patched)
+ return self.patched
def isTests(self):
'''GLModule.isTests() -> bool
Check whether module is a -tests version of module.'''
result = self.getName().endswith('-tests')
- return(result)
+ return result
def isNonTests(self):
'''GLModule.isTests() -> bool
Check whether module is not a -tests version of module.'''
result = not(self.isTests())
- return(result)
+ return result
def getTestsName(self):
'''Return -tests version of the module name.'''
result = self.getName()
if not result.endswith('-tests'):
result += '-tests'
- return(result)
+ return result
def getTestsModule(self):
'''Return -tests version of the module as GLModule.'''
result = self.modulesystem.find(self.getTestsName())
- return(result)
+ return result
def getShellFunc(self):
'''GLModule.getShellFunc() -> string
result = 'func_%s_gnulib_m4code_%s' % (macro_prefix, module)
if type(result) is bytes:
result = result.decode(ENCS['default'])
- return(result)
+ return result
def getShellVar(self):
'''GLModule.getShellVar() -> string
result = '%s_gnulib_enabled_%s' % (macro_prefix, module)
if type(result) is bytes:
result = result.decode(ENCS['default'])
- return(result)
+ return result
def getConditionalName(self):
'''GLModule.getConditionalName() -> string
result = '%s_GNULIB_ENABLED_%s' % (macro_prefix, name)
if type(result) is bytes:
result = result.decode(ENCS['default'])
- return(result)
+ return result
def getDescription(self):
'''GLModule.getDescription() -> string
result = result[-1]
result = result.strip()
self.cache['description'] = result
- return(self.cache['description'])
+ return self.cache['description']
def getComment(self):
'''GLModule.getComment() -> string
result = result[-1]
result = result.strip()
self.cache['comment'] = result
- return(self.cache['comment'])
+ return self.cache['comment']
def getStatus(self):
'''GLModule.getStatus() -> string
parts += [line]
result = [part.strip() for part in parts if part.strip()]
self.cache['status'] = list(result)
- return(list(self.cache['status']))
+ return list(self.cache['status'])
def getNotice(self):
'''GLModule.getNotice() -> string
parts += [line]
result = ''.join(parts)
self.cache['notice'] = result
- return(self.cache['notice'])
+ return self.cache['notice']
def getApplicability(self):
'''GLModule.getApplicability() -> string
result = result.decode(ENCS['default'])
result = result.strip()
self.cache['applicability'] = result
- return(self.cache['applicability'])
+ return self.cache['applicability']
def getFiles(self):
'''GLModule.getFiles() -> list
result += [joinpath('m4', 'zzgnulib.m4')]
result += [joinpath('m4', 'gnulib-common.m4')]
self.cache['files'] = list(result)
- return(list(self.cache['files']))
+ return list(self.cache['files'])
def getDependencies(self):
'''GLModule.getDependencies() -> list
condition = condition.decode(ENCS['default'])
result += [tuple([self.modulesystem.find(module), condition])]
self.cache['dependencies'] = result
- return(list(self.cache['dependencies']))
+ return list(self.cache['dependencies'])
def getAutoconfSnippet_Early(self):
'''GLModule.getAutoconfSnippet_Early() -> string
parts += [line]
result = ''.join(parts)
self.cache['autoconf-early'] = result
- return(self.cache['autoconf-early'])
+ return self.cache['autoconf-early']
def getAutoconfSnippet(self):
'''GLModule.getAutoconfSnippet() -> string
parts += [line]
result = ''.join(parts)
self.cache['autoconf'] = result
- return(self.cache['autoconf'])
+ return self.cache['autoconf']
def getAutomakeSnippet(self):
'''getAutomakeSnippet() -> string
else: # if not conditional.strip()
result += '\n'
result += self.getAutomakeSnippet_Unconditional()
- return(result)
+ return result
def getAutomakeSnippet_Conditional(self):
'''GLModule.getAutomakeSnippet_Conditional() -> string
parts += [line]
result = ''.join(parts)
self.cache['makefile-conditional'] = result
- return(self.cache['makefile-conditional'])
+ return self.cache['makefile-conditional']
def getAutomakeSnippet_Unconditional(self):
'''GLModule.getAutomakeSnippet_Unconditional() -> string
result += '\n\n'
result = constants.nlconvert(result)
self.cache['makefile-unconditional'] = result
- return(self.cache['makefile-unconditional'])
+ return self.cache['makefile-unconditional']
def getInclude(self):
'''GLModule.getInclude() -> string
pattern = compiler('^(["<].*?[>"])', re.S | re.M)
result = pattern.sub('#include \\1', result)
self.cache['include'] = result
- return(self.cache['include'])
+ return self.cache['include']
def getLink(self):
'''GLModule.getLink() -> string
parts = [part.strip() for part in parts if part.strip()]
# result = ' '.join(parts)
self.cache['link'] = parts
- return(self.cache['link'])
+ return self.cache['link']
def getLicense(self):
'''GLModule.getLicense(self) -> string
sys.stderr.write('module %s lacks a license\n' % str(self))
if not license:
license = 'GPL'
- return(license)
+ return license
def getLicense_Raw(self):
'''GLModule.getLicense_Raw() -> string
result = result[-1]
result = result.strip()
self.cache['license'] = result
- return(self.cache['license'])
+ return self.cache['license']
def getMaintainer(self):
'''GLModule.getMaintainer() -> string
result = ''.join(parts)
result = result.strip()
self.cache['maintainer'] = result
- return(self.cache['maintainer'])
+ return self.cache['maintainer']
#===============================================================================
def __repr__(self):
'''x.__repr__() <==> repr(x)'''
result = '<pygnulib.GLModuleTable %s>' % hex(id(self))
- return(result)
+ return result
def __getitem__(self, y):
'''x.__getitem__(y) <==> x[y]'''
if y in ['base', 'final', 'main', 'tests', 'avoids']:
if y == 'base':
- return(self.getBaseModules())
+ return self.getBaseModules()
elif y == 'final':
- return(self.getFinalModules())
+ return self.getFinalModules()
elif y == 'main':
- return(self.getMainModules())
+ return self.getMainModules()
elif y == 'tests':
- return(self.getTestsModules())
+ return self.getTestsModules()
else: # if y == 'avoids'
- return(self.getAvoids())
+ return self.getAvoids()
else: # if y is not in list
raise(KeyError('GLModuleTable does not contain key: %s' % repr(y)))
raise(TypeError('module must be a GLModule, not %s' %
type(module).__name__))
result = str(module) in self.dependers
- return(result)
+ return result
def getCondition(self, parent, module):
'''GLModuleTable.getCondition(module) -> string or True
result = None
if key in self.conditionals:
result = self.conditionals[key]
- return(result)
+ return result
def transitive_closure(self, modules):
'''GLModuleTable.transitive_closure(modules) -> list
inmodules = sorted(set(inmodules))
modules = sorted(set(outmodules))
self.modules = modules
- return(list(modules))
+ return list(modules)
def transitive_closure_separately(self, basemodules, finalmodules):
'''GLModuleTable.transitive_closure_separately(*args, **kwargs) -> tuple
set(self.config['testflags'] + [TESTS['tests']]))
self.config.setTestFlags(testflags)
result = tuple([main_modules, tests_modules])
- return(result)
+ return result
def add_dummy(self, modules):
'''GLModuleTable.add_dummy(modules) -> list
if not have_lib_sources:
dummy = self.modulesystem.find('dummy')
modules = sorted(set(modules + [dummy]))
- return(list(modules))
+ return list(modules)
def filelist(self, modules):
'''GLModuleTable.filelist(modules) -> list
for file in listing:
if file not in filelist:
filelist += [file]
- return(filelist)
+ return filelist
def filelist_separately(self, main_modules, tests_modules):
'''GLModuleTable.filelist_separately(**kwargs) -> list
for file in tests_filelist
] # Finish to sort filelist
result = tuple([main_filelist, tests_filelist])
- return(result)
+ return result
def getAvoids(self):
'''GLModuleTable.getAvoids() -> list
Return list of avoids.'''
- return(list(self.avoids))
+ return list(self.avoids)
def setAvoids(self, modules):
'''GLModuleTable.setAvoids(modules)
'''GLModuleTable.getBaseModules() -> list
Return list of base modules.'''
- return(list(self.base_modules))
+ return list(self.base_modules)
def setBaseModules(self, modules):
'''GLModuleTable.setBaseModules(modules)
'''GLModuleTable.getFinalModules() -> list
Return list of final modules.'''
- return(list(self.final_modules))
+ return list(self.final_modules)
def setFinalModules(self, modules):
'''GLModuleTable.setFinalModules(modules)
'''GLModuleTable.getMainModules() -> list
Return list of main modules.'''
- return(list(self.main_modules))
+ return list(self.main_modules)
def setMainModules(self, modules):
'''GLModuleTable.setMainModules(modules)
'''GLModuleTable.getTestsModules() -> list
Return list of tests modules.'''
- return(list(self.tests_modules))
+ return list(self.tests_modules)
def setTestsModules(self, modules):
'''GLModuleTable.setTestsModules(modules)
path = file
result += [os.path.normpath(path)]
result = sorted(set(result))
- return(list(result))
+ return list(result)
def execute(self):
'''GLTestDir.execute()
pattern = re.compile(pattern, re.UNICODE | flags)
else: # if PYTHON3
pattern = re.compile(pattern, flags)
- return(pattern)
+ return pattern
def cleaner(sequence):
sequence = [False if value == 'false' else value for value in sequence]
sequence = [True if value == 'true' else value for value in sequence]
sequence = [value.strip() for value in sequence]
- return(sequence)
+ return sequence
def joinpath(head, *tail):
result = os.path.normpath(os.path.join(head, *tail))
if type(result) is bytes:
result = result.decode(ENCS['default'])
- return(result)
+ return result
def relativize(dir1, dir2):
dir0 = joinpath(dir0, first)
dir1 = dir1[dir1.find(os.path.sep) + 1:]
result = os.path.normpath(dir2)
- return(result)
+ return result
def link_relative(src, dest):
(added_prefix, added_suffix), filename)
listing += [result]
result = separator.join(listing)
- return(result)
+ return result
def substart(orig, repl, data):
result = data
if data.startswith(orig):
result = repl + data[len(orig):]
- return(result)
+ return result
def subend(orig, repl, data):
result = data
if data.endswith(orig):
result = data[:-len(orig)] + repl
- return(result)
+ return result
def nlconvert(text):
text = text.replace('\r\n', '\n')
if system == 'windows':
text = text.replace('\n', '\r\n')
- return(text)
+ return text
def nlremove(text):
lines = [line for line in text.split('\n') if line != '']
text = '\n'.join(lines)
text = nlconvert(text)
- return(text)
+ return text
def remove_backslash_newline(text):