[pygnulib] initial merge (including some small bug fixes)

1 files changed, 1186 insertions, 0 deletions

diff --git a/pygnulib/GLConfig.py b/pygnulib/GLConfig.py
new file mode 100644
index 0000000000..ef997179cd
--- /dev/null
+++ b/pygnulib/GLConfig.py
@@ -0,0 +1,1186 @@
+#!/usr/bin/python
+# encoding: UTF-8
+
+#===============================================================================
+# Define global imports
+#===============================================================================
+import os
+import re
+import sys
+import copy
+import codecs
+import tempfile
+import subprocess as sp
+from . import constants
+from .GLError import GLError
+
+
+#===============================================================================
+# Define module information
+#===============================================================================
+__author__ = constants.__author__
+__license__ = constants.__license__
+__copyright__ = constants.__copyright__
+
+
+#===============================================================================
+# Define global constants
+#===============================================================================
+PYTHON3 = constants.PYTHON3
+NoneType = type(None)
+APP = constants.APP
+DIRS = constants.DIRS
+ENCS = constants.ENCS
+UTILS = constants.UTILS
+FILES = constants.FILES
+MODES = constants.MODES
+TESTS = constants.TESTS
+compiler = constants.compiler
+joinpath = constants.joinpath
+cleaner = constants.cleaner
+relpath = constants.relativize
+string = constants.string
+isabs = os.path.isabs
+isdir = os.path.isdir
+isfile = os.path.isfile
+normpath = os.path.normpath
+
+
+#===============================================================================
+# Define GLConfig class
+#===============================================================================
+class GLConfig(object):
+  '''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.'''
+  
+  def __init__(self, destdir=None, localdir=None, auxdir=None,
+    sourcebase=None, m4base=None, pobase=None, docbase=None, testsbase=None,
+    modules=None, avoids=None, files=None, testflags=None, libname=None,
+    lgpl=None, makefile=None, libtool=None, conddeps=None, macro_prefix=None,
+    podomain=None, witness_c_macro=None, vc_files=None, symbolic=None,
+    lsymbolic=None, modcache=None, configure_ac=None, ac_version=None,
+    libtests=None, single_configure=None, verbose=None, dryrun=None,
+    errors=None):
+    '''GLConfig.__init__(arguments) -> GLConfig
+    
+    Create new GLConfig instance.'''
+    self.table = dict()
+    self.table['tempdir'] = tempfile.mkdtemp()
+    # destdir
+    self.resetDestDir()
+    if destdir != None:
+      self.setDestDir(destdir)
+    # localdir
+    self.resetLocalDir()
+    if localdir != None:
+      self.setLocalDir(localdir)
+    # 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)
+    # testflags
+    self.resetTestFlags()
+    if testflags != None:
+      self.setTestFlags(testflags)
+    # libname
+    self.resetLibName()
+    if libname != None:
+      self.setLibName(libname)
+    # lgpl
+    self.resetLGPL()
+    if lgpl != None:
+      self.setLGPL(lgpl)
+    # makefile
+    self.resetMakefile()
+    if makefile != None:
+      self.setMakefile(makefile)
+    # libtool
+    self.resetLibtool()
+    if libtool != None:
+      if type(libtool) is bool:
+        if not libtool:
+          self.disableLibtool()
+        else: # if libtool
+          self.enableLibtool()
+      else: # if type(libtool) is not bool
+        raise(TypeError('libtool must be a bool, not %s' % \
+          type(libtool).__name__))
+    # conddeps
+    self.resetCondDeps()
+    if conddeps != None:
+      if type(conddeps) is bool:
+        if not conddeps:
+          self.disableCondDeps()
+        else: # if conddeps
+          self.enableCondDeps()
+      else: # if type(conddeps) is not bool
+        raise(TypeError('conddeps must be a bool, not %s' % \
+          type(conddeps).__name__))
+    # 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:
+      if type(witness_c_macro) is bool:
+        if not witness_c_macro:
+          self.setWitnessCMacro()
+        else: # if witness_c_macro
+          self.resetWitnessCMacro()
+      else: # if type(witness_c_macro) is not bool
+        raise(TypeError('witness_c_macro must be a bool, not %s' % \
+          type(witness_c_macro).__name__))
+    # vc_files
+    self.resetVCFiles()
+    if vc_files != None:
+      if type(vc_files) is bool:
+        if not vc_files:
+          self.disableVCFiles()
+        else: # if vc_files
+          self.enableVCFiles()
+      else: # if type(vc_files) is not bool
+        raise(TypeError('vc_files must be a bool, not %s' % \
+          type(vc_files).__name__))
+    # symbolic
+    self.resetSymbolic()
+    if symbolic != None:
+      if type(symbolic) is bool:
+        if not symbolic:
+          self.disableSymbolic()
+        else: # if symbolic
+          self.enableSymbolic()
+      else: # if type(symbolic) is not bool
+        raise(TypeError('symbolic must be a bool, not %s' % \
+          type(symbolic).__name__))
+    # lsymbolic
+    self.resetLSymbolic()
+    if lsymbolic != None:
+      if type(lsymbolic) is bool:
+        if not lsymbolic:
+          self.disableLSymbolic()
+        else: # if lsymbolic
+          self.enableLSymbolic()
+      else: # if type(lsymbolic) is not bool
+        raise(TypeError('lsymbolic must be a bool, not %s' % \
+          type(lsymbolic).__name__))
+    # modcache
+    self.resetModuleCaching()
+    if modcache != None:
+      if type(modcache) is bool:
+        if not modcache:
+          self.disableModuleCaching()
+        else: # if modcache
+          self.enableModuleCaching()
+      else: # if type(modcache) is not bool
+        raise(TypeError('modcache must be a bool, not %s' % \
+          type(modcache).__name__))
+    # 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:
+      if type(libtests) is bool:
+        if not libtests:
+          self.disableLibtests()
+        else: # if libtests
+          self.enableLibtests()
+      else: # if type(libtests) is not bool
+        raise(TypeError('libtests must be a bool, not %s' % \
+          type(libtests).__name__))
+    # single_configure
+    self.resetSingleConfigure()
+    if single_configure != None:
+      if type(single_configure) is bool:
+        if not single_configure:
+          self.disableSingleConfigure()
+        else: # if single_configure
+          self.enableSingleConfigure()
+      else: # if type(single_configure) is not bool
+        raise(TypeError('single_configure must be a bool, not %s' % \
+          type(single_configure).__name__))
+    # verbose
+    self.resetVerbosity()
+    if verbose != None:
+      self.setVerbosity(verbose)
+    # dryrun
+    self.resetDryRun()
+    if dryrun != None:
+      if type(dryrun) is bool:
+        if not dryrun:
+          self.disableDryRun()
+        else: # if dryrun
+          self.enableDryRun()
+      else: # if type(dryrun) is not bool
+        raise(TypeError('dryrun must be a bool, not %s' % \
+          type(dryrun).__name__))
+    # errors
+    self.resetErrors()
+    if errors != None:
+      if type(errors) is bool:
+        if not errors:
+          self.disableErrors()
+        else: # if errors
+          self.enableErrors()
+      else: # if type(errors) is not bool
+        raise(TypeError('errors must be a bool, not %s' % \
+          type(errors).__name__))
+    
+  # Define special methods.
+  def __repr__(self):
+    '''x.__repr__() <==> repr(x)'''
+    return('<pygnulib.GLConfig>')
+    
+  def __getitem__(self, y):
+    '''x.__getitem__(y) <==> x[y]'''
+    if y in self.table:
+      result = self.table[y]
+      if type(y) is list:
+        result = list(self.table[y])
+      if y == "auxdir":
+        if self.table['auxdir']:
+          return self.table['auxdir']
+        return "build-aux"
+      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))
+    
+  def copy(self):
+    '''Return the copy of the configuration.'''
+    table = copy.deepcopy(self)
+    return(table)
+    
+  def update(self, dictionary):
+    '''Specify the dictionary whose keys will be used to update config.'''
+    if type(dictionary) is not GLConfig:
+      raise(TypeError('dictionary must be a GLConfig, not %s' % \
+        type(dictionary).__name__))
+    dictionary = dict(dictionary.table)
+    result = dict()
+    for key in dictionary:
+      src = self.table[key]
+      dest = dictionary[key]
+      result[key] = src
+      if src != dest:
+        if self.isdefault(key, src):
+          result[key] = dest
+        else: # if not self.isdefault(key, src)
+          result[key] == src
+          if not self.isdefault(key, dest):
+            if key in ['modules', 'avoids', 'tests']:
+              dest = sorted(set(src +dest))
+            result[key] = dest
+    self.table = dict(result)
+    
+  def update_key(self, dictionary, key):
+    '''Update the given key using value from the given dictionary.'''
+    if key in self.table:
+      if type(dictionary) is not GLConfig:
+        raise(TypeError('dictionary must be a GLConfig, not %s' % \
+          type(dictionary).__name__))
+      dictionary = dict(dictionary.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):
+    '''Return default value for the given key.'''
+    if key in self.table:
+      if key == 'libname':
+        return(string('libgnu'))
+      elif key == 'macro_prefix':
+        return(string('gl'))
+      elif key == 'include_guard_prefix':
+        return(string('GL'))
+      elif key == 'ac_version':
+        return(2.59)
+      elif key == 'verbosity':
+        return(0)
+      elif key == 'copyrights':
+        return(True)
+      elif key in ['modules', 'avoids', 'tests', 'testflags']:
+        return(list())
+      elif key in ['libtool', 'lgpl', 'conddeps', 'modcache', 'symbolic',
+      'lsymbolic', 'libtests', 'dryrun']:
+        return(False)
+      if key == 'vc_files':
+        return(None)
+      elif key == 'errors':
+        return(True)
+      else: # otherwise
+        return(string())
+    else: # if key not in self.table
+      raise(KeyError('GLConfig does not contain key: %s' % repr(key)))
+    
+  def isdefault(self, key, value):
+    '''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):
+    '''Return list of keys.'''
+    return(list(self.table.keys()))
+    
+  def values(self):
+    '''Return list of 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'])
+    
+  def setDestDir(self, destdir):
+    '''Specify the target directory. For --import, this specifies where your
+    configure.ac can be found. Defaults to current directory.'''
+    if type(destdir) is bytes or type(destdir) is string:
+      if type(destdir) is bytes:
+        destdir = string(destdir, ENCS['system'])
+      if destdir:
+        self.table['destdir'] = os.path.normpath(destdir)
+    else: # if destdir has not bytes/string type
+      raise(TypeError('destdir must be a string, not %s' % \
+        type(destdir).__name__))
+    
+  def resetDestDir(self):
+    '''Reset the target directory. For --import, this specifies where your
+    configure.ac can be found. Defaults to current directory.'''
+    self.table['destdir'] = string()
+    
+    
+  # Define localdir methods.
+  def getLocalDir(self):
+    '''Return a local override directory where to look up files before looking
+    in gnulib's directory.'''
+    return(self.table['localdir'])
+    
+  def setLocalDir(self, localdir):
+    '''Specify a local override directory where to look up files before looking
+    in gnulib's directory.'''
+    if type(localdir) is bytes or type(localdir) is string:
+      if type(localdir) is bytes:
+        localdir = string(localdir, ENCS['system'])
+      if localdir:
+        self.table['localdir'] = localdir
+    else: # if localdir has not bytes/string type
+      raise(TypeError('localdir must be a string, not %s' % \
+        type(localdir).__name__))
+    
+  def resetLocalDir(self):
+    '''Reset a local override directory where to look up files before looking
+    in gnulib's directory.'''
+    self.table['localdir'] = string()
+    
+    
+  # Define auxdir methods.
+  def getAuxDir(self):
+    '''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):
+    '''Specify directory relative to --dir where auxiliary build tools are
+    placed. Default comes from configure.ac or configure.in.'''
+    if type(auxdir) is bytes or type(auxdir) is string:
+      if type(auxdir) is bytes:
+        auxdir = string(auxdir, ENCS['system'])
+      if auxdir:
+        self.table['auxdir'] = auxdir
+    else: # if type of auxdir is not bytes or string
+      raise(TypeError('auxdir must be a string, not %s' % \
+        type(auxdir).__name__))
+    
+  def resetAuxDir(self):
+    '''Reset directory relative to --dir where auxiliary build tools are
+    placed. Default comes from configure.ac or configure.in.'''
+    self.table['auxdir'] = string()
+    
+    
+  # Define sourcebase methods.
+  def getSourceBase(self):
+    '''Return directory relative to destdir where source code is placed.'''
+    return(self.table['sourcebase'])
+    
+  def setSourceBase(self, sourcebase):
+    '''Specify directory relative to destdir where source code is placed.'''
+    if type(sourcebase) is bytes or type(sourcebase) is string:
+      if type(sourcebase) is bytes:
+        sourcebase = string(sourcebase, ENCS['system'])
+      if sourcebase:
+        self.table['sourcebase'] = sourcebase
+    else: # if type of sourcebase is not bytes or string
+      raise(TypeError('sourcebase must be a string, not %s' % \
+        type(sourcebase).__name__))
+    
+  def resetSourceBase(self):
+    '''Return directory relative to destdir where source code is placed.'''
+    self.table['sourcebase'] = string()
+    
+    
+  # Define m4base methods.
+  def getM4Base(self):
+    '''Return directory relative to destdir where *.m4 macros are placed.'''
+    return(self.table['m4base'])
+    
+  def setM4Base(self, m4base):
+    '''Specify directory relative to destdir where *.m4 macros are placed.'''
+    if type(m4base) is bytes or type(m4base) is string:
+      if type(m4base) is bytes:
+        m4base = string(m4base, ENCS['system'])
+      if m4base:
+        self.table['m4base'] = m4base
+    else: # if type of m4base is not bytes or string
+      raise(TypeError('m4base must be a string, not %s' % \
+        type(m4base).__name__))
+    
+  def resetM4Base(self):
+    '''Reset directory relative to destdir where *.m4 macros are placed.'''
+    self.table['m4base'] = string()
+    
+    
+  # Define pobase methods.
+  def getPoBase(self):
+    '''Return directory relative to destdir where *.po files are placed.'''
+    return(self.table['pobase'])
+    
+  def setPoBase(self, pobase):
+    '''Specify directory relative to destdir where *.po files are placed.'''
+    if type(pobase) is bytes or type(pobase) is string:
+      if type(pobase) is bytes:
+        pobase = string(pobase, ENCS['system'])
+      if pobase:
+        self.table['pobase'] = pobase
+    else: # if type of pobase is not bytes or string
+      raise(TypeError('pobase must be a string, not %s' % \
+        type(pobase).__name__))
+    
+  def resetPoBase(self):
+    '''Reset directory relative to destdir where *.po files are placed.'''
+    self.table['pobase'] = string()
+    
+    
+  # Define docbase methods.
+  def getDocBase(self):
+    '''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):
+    '''Specify directory relative to destdir where doc files are placed.
+    Default value for this variable is 'doc').'''
+    if type(docbase) is bytes or type(docbase) is string:
+      if type(docbase) is bytes:
+        docbase = string(docbase, ENCS['system'])
+      if docbase:
+        self.table['docbase'] = docbase
+    else: # if type of docbase is not bytes or string
+      raise(TypeError('docbase must be a string, not %s' % \
+        type(docbase).__name__))
+    
+  def resetDocBase(self):
+    '''Reset directory relative to destdir where doc files are placed.
+    Default value for this variable is 'doc').'''
+    self.table['docbase'] = string()
+    
+    
+  # Define testsbase methods.
+  def getTestsBase(self):
+    '''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):
+    '''Specify directory relative to destdir where unit tests are placed.
+    Default value for this variable is 'tests').'''
+    if type(testsbase) is bytes or type(testsbase) is string:
+      if type(testsbase) is bytes:
+        testsbase = string(testsbase, ENCS['system'])
+      if testsbase:
+        self.table['testsbase'] = testsbase
+    else: # if type of testsbase is not bytes or string
+      raise(TypeError('testsbase must be a string, not %s' % \
+        type(testsbase).__name__))
+    
+  def resetTestsBase(self):
+    '''Reset directory relative to destdir where unit tests are placed.
+    Default value for this variable is 'tests').'''
+    self.table['testsbase'] = string()
+    
+    
+  # Define modules methods.
+  def addModule(self, module):
+    '''Add the module to the modules list.'''
+    if type(module) is bytes or type(module) is string:
+      if type(module) is bytes:
+        module = module.decode(ENCS['default'])
+      if module not in self.table['modules']:
+        self.table['modules'] += [module]
+    else: # if module has not bytes or string type
+      raise(TypeError('module must be a string, not %s' % \
+        type(module).__name__))
+    
+  def removeModule(self, module):
+    '''Remove the module from the modules list.'''
+    if type(module) is bytes or type(module) is string:
+      if type(module) is bytes:
+        module = module.decode(ENCS['default'])
+      if module in self.table['modules']:
+        self.table['modules'].remove(module)
+    else: # if module has not bytes or string type
+      raise(TypeError('module must be a string, not %s' % \
+        type(module).__name__))
+    
+  def getModules(self):
+    '''Return the modules list.'''
+    return(list(self.table['modules']))
+    
+  def setModules(self, modules):
+    '''Set the modules list.'''
+    if type(modules) is list or type(modules) is tuple:
+      old_modules = self.table['modules']
+      self.table['modules'] = list()
+      for module in modules:
+        try: # Try to add each module
+          self.addModule(module)
+        except TypeError as error:
+          self.table['modules'] = old_modules
+          raise(TypeError('each module must be a string'))
+        except GLError as error:
+          self.table['modules'] = old_modules
+          raise(GLError(error.errno, error.errinfo))
+    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):
+    '''Reset the list of the modules.'''
+    self.table['modules'] = list()
+    
+    
+  # Define avoids methods.
+  def addAvoid(self, module):
+    '''Avoid including the given module. Useful if you have code that provides
+    equivalent functionality.'''
+    if type(module) is bytes or type(module) is string:
+      if type(module) is bytes:
+        module = module.decode(ENCS['default'])
+      if module not in self.table['avoids']:
+        self.table['avoids'].append(module)
+    else: # if module has not bytes or string type
+      raise(TypeError('avoid must be a string, not %s' % \
+        type(module).__name__))
+    
+  def removeAvoid(self, module):
+    '''Remove the given module from the list of avoided modules.'''
+    if type(module) is bytes or type(module) is string:
+      if type(module) is bytes:
+        module = module.decode(ENCS['default'])
+      if module in self.table['avoids']:
+        self.table['avoids'].remove(module)
+    else: # if module has not bytes or string type
+      raise(TypeError('avoid must be a string, not %s' % \
+        type(module).__name__))
+    
+  def getAvoids(self):
+    '''Return the list of the avoided modules.'''
+    return(list(self.table['avoids']))
+    
+  def setAvoids(self, modules):
+    '''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'] = list()
+      for module in modules:
+        try: # Try to add each module
+          self.addAvoid(module)
+        except TypeError as error:
+          self.table['avoids'] = old_avoids
+          raise(TypeError('each module must be a string'))
+        except GLError as error:
+          self.table['avoids'] = old_avoids
+          raise(GLError(error.errno, error.errinfo))
+    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):
+    '''Reset the list of the avoided modules.'''
+    self.table['avoids'] = list()
+    
+    
+  # Define files methods.
+  def addFile(self, file):
+    '''Add file to the list of files.'''
+    if type(file) is bytes or type(file) is string:
+      if type(file) is bytes:
+        file = file.decode(ENCS['default'])
+      if file not in self.table['files']:
+        self.table['files'].append(file)
+    else: # if file has not bytes or string type
+      raise(TypeError('file must be a string, not %s' % \
+        type(file).__name__))
+    
+  def removeFile(self, file):
+    '''Remove the given file from the list of files.'''
+    if type(file) is bytes or type(file) is string:
+      if type(file) is bytes:
+        file = file.decode(ENCS['default'])
+      if file in self.table['files']:
+        self.table['files'].remove(file)
+    else: # if file has not bytes or string type
+      raise(TypeError('file must be a string, not %s' % \
+        type(file).__name__))
+    
+  def getFiles(self):
+    '''Return the list of the fileed files.'''
+    return(list(self.table['files']))
+    
+  def setFiles(self, files):
+    '''Specify the list of files.'''
+    if type(files) is list or type(files) is tuple:
+      old_files = self.table['files']
+      self.table['files'] = list()
+      for file in files:
+        try: # Try to add each file
+          self.addFile(file)
+        except TypeError as error:
+          self.table['files'] = old_files
+          raise(TypeError('each file must be a string'))
+        except GLError as error:
+          self.table['files'] = old_files
+          raise(GLError(error.errno, error.errinfo))
+    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):
+    '''Reset the list of files.'''
+    self.table['files'] = list()
+    
+    
+  # Define tests/testflags methods
+  def checkTestFlag(self, flag):
+    '''Return the status of the test flag.'''
+    if flag in TESTS.values():
+      return(flag in self.table['testflags'])
+    else: # if flag is not in TESTS
+      raise(TypeError('unknown flag: %s' % repr(flag)))
+    
+  def enableTestFlag(self, flag):
+    '''Enable test flag. You can get flags from TESTS variable.'''
+    if flag in TESTS.values():
+      if flag not in self.table['testflags']:
+        self.table['testflags'].append(flag)
+    else: # if flag is not in TESTS
+      raise(TypeError('unknown flag: %s' % repr(flag)))
+    
+  def disableTestFlag(self, flag):
+    '''Disable test flag. You can get flags from TESTS variable.'''
+    if flag in TESTS.values():
+      if flag in self.table['testflags']:
+        self.table['testflags'].remove(flag)
+    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']))
+    
+  def setTestFlags(self, testflags):
+    '''Specify test flags. You can get flags from TESTS variable.'''
+    if type(testflags) is list or type(testflags) is tuple:
+      old_testflags = self.table['testflags']
+      self.table['testflags'] = list()
+      for flag in testflags:
+        try: # Try to enable each flag
+          self.enableTestFlag(flag)
+        except TypeError as error:
+          raise(TypeError('each flag must be one of TESTS integers'))
+      self.table['testflags'] = testflags
+    else: # if type of testflags is not list or tuple
+      raise(TypeError('testflags must be a list or a tuple, not %s' % \
+        type(testflags).__name__))
+    
+  def resetTestFlags(self):
+    '''Reset test flags (only default flag will be enabled).'''
+    self.table['testflags'] = list()
+    self.table['tests'] = self.table['testflags']
+    
+    
+  # Define libname methods.
+  def getLibName(self):
+    '''Return the library name.'''
+    return(self.table['libname'])
+    
+  def setLibName(self, libname):
+    '''Specify the library name.'''
+    if type(libname) is bytes or type(libname) is string:
+      if type(libname) is bytes:
+        libname = string(libname, ENCS['system'])
+      if libname:
+        self.table['libname'] = libname
+    else: # if type of libname is not bytes or string
+      raise(TypeError('libname must be a string, not %s' % \
+        type(module).__name__))
+    
+  def resetLibName(self):
+    '''Reset the library name to 'libgnu'.'''
+    self.table['libname'] = string('libgnu')
+    
+    
+  # Define libtool methods.
+  def checkLibtool(self):
+    '''Check if user enabled libtool rules.'''
+    return(self.table['libtool'])
+    
+  def enableLibtool(self):
+    '''Enable libtool rules.'''
+    self.table['libtool'] = True
+    
+  def disableLibtool(self):
+    '''Disable libtool rules.'''
+    self.table['libtool'] = False
+    
+  def resetLibtool(self):
+    '''Reset libtool rules.'''
+    self.table['libtool'] = False
+    
+    
+  # Define conddeps methods.
+  def checkCondDeps(self):
+    '''Check if user enabled cond. dependencies.'''
+    return(self.table['conddeps'])
+    
+  def enableCondDeps(self):
+    '''Enable cond. dependencies (may save configure time and object code).'''
+    self.table['conddeps'] = True
+    
+  def disableCondDeps(self):
+    '''Disable cond. dependencies (may save configure time and object code).'''
+    self.table['conddeps'] = False
+    
+  def resetCondDeps(self):
+    '''Reset cond. dependencies (may save configure time and object code).'''
+    self.table['conddeps'] = False
+    
+    
+  # Define lgpl methods.
+  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'])
+    
+  def setLGPL(self, lgpl):
+    '''Abort if modules aren't available under the LGPL.
+    Default value is False, which means that lgpl is disabled.'''
+    if (type(lgpl) is int and 2 <= lgpl <= 3) or type(lgpl) is bool:
+      self.table['lgpl'] = lgpl
+    else: # if lgpl is not False, 2 or 3
+      raise(TypeError('invalid LGPL version: %s' % repr(lgpl)))
+    
+  def resetLGPL(self):
+    '''Disable abort if modules aren't available under the LGPL.
+    Default value is False, which means that lgpl is disabled.'''
+    self.table['lgpl'] = False
+    
+    
+  # Define macro_prefix methods.
+  def getIncludeGuardPrefix(self):
+    '''Return include_guard_prefix to use inside GLEmiter class.'''
+    return(self.table['include_guard_prefix'])
+    
+  def getMacroPrefix(self):
+    '''Return the prefix of the macros 'gl_EARLY' and 'gl_INIT'.
+    Default macro_prefix is 'gl'.'''
+    return(self.table['macro_prefix'])
+    
+  def setMacroPrefix(self, macro_prefix):
+    '''Specify the prefix of the macros 'gl_EARLY' and 'gl_INIT'.
+    Default macro_prefix is 'gl'.'''
+    if type(macro_prefix) is bytes or type(macro_prefix) is string:
+      if type(macro_prefix) is bytes:
+        macro_prefix = string(macro_prefix, ENCS['system'])
+      if macro_prefix:
+        self.table['macro_prefix'] = macro_prefix
+    else: # if type of macro_prefix is not bytes or string
+      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()
+    if type(include_guard_prefix) is bytes:
+      include_guard_prefix = include_guard_prefix.decode(ENCS['default'])
+    self.table['include_guard_prefix'] = include_guard_prefix
+    
+  def resetMacroPrefix(self):
+    '''Reset the prefix of the macros 'gl_EARLY' and 'gl_INIT'.
+    Default macro_prefix is 'gl'.'''
+    self.table['macro_prefix'] = string('gl')
+    include_guard_prefix = string('GL')
+    if type(include_guard_prefix) is bytes:
+      include_guard_prefix = include_guard_prefix.decode(ENCS['default'])
+    self.table['include_guard_prefix'] = include_guard_prefix
+    
+    
+  # Define makefile methods.
+  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'])
+    
+  def setMakefile(self, makefile):
+    '''Specify the name of makefile in automake syntax in the source-base and
+    tests-base directories. Default is 'Makefile.am'.'''
+    if type(makefile) is bytes or type(makefile) is string:
+      if type(makefile) is bytes:
+        makefile = string(makefile, ENCS['system'])
+      if makefile:
+        self.table['makefile'] = makefile
+    else: # if type of makefile is not bytes or string
+      raise(TypeError('makefile must be a string, not %s' %
+        type(makefile).__name__))
+    
+  def resetMakefile(self):
+    '''Reset the name of makefile in automake syntax in the source-base and
+    tests-base directories. Default is 'Makefile.am'.'''
+    self.table['makefile'] = string()
+    
+    
+  # Define podomain methods.
+  def getPoDomain(self):
+    '''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):
+    '''Specify the prefix of the i18n domain. Usually use the package name.
+    A suffix '-gnulib' is appended.'''
+    if type(podomain) is bytes or type(podomain) is string:
+      if type(podomain) is bytes:
+        podomain = string(podomain, ENCS['system'])
+      if podomain:
+        self.table['podomain'] = podomain
+    else: # if type of podomain is not bytes or string
+      raise(TypeError('podomain must be a string, not %s' % \
+        type(podomain).__name__))
+    
+  def resetPoDomain(self):
+    '''Reset the prefix of the i18n domain. Usually use the package name.
+    A suffix '-gnulib' is appended.'''
+    self.table['podomain'] = string()
+    
+    
+  # Define witness_c_macro methods.
+  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'])
+    
+  def setWitnessCMacro(self, witness_c_macro):
+    '''Specify the C macro that is defined when the sources in this directory
+    are compiled or used.'''
+    if type(witness_c_macro) is bytes or type(witness_c_macro) is string:
+      if type(witness_c_macro) is bytes:
+        witness_c_macro = string(witness_c_macro, ENCS['system'])
+      if witness_c_macro:
+        self.table['witness_c_macro'] = witness_c_macro
+    else: # if type of witness_c_macro is not bytes or string
+      raise(TypeError('witness_c_macro must be a string, not %s' %
+        type(witness_c_macro).__name__))
+    
+  def resetWitnessCMacro(self):
+    '''Return the C macro that is defined when the sources in this directory
+    are compiled or used.'''
+    self.table['witness_c_macro'] = string()
+    
+    
+  # Define vc_files methods.
+  def checkVCFiles(self):
+    '''Check if update of the version control files is enabled or disabled.'''
+    return(self.table['vc_files'])
+    
+  def enableVCFiles(self):
+    '''Enable update of the version control files.'''
+    self.table['vc_files'] = True
+    
+  def disableVCFiles(self):
+    '''Disable update of the version control files.'''
+    self.table['vc_files'] = False
+    
+  def resetVCFiles(self):
+    '''Reset update of the version control files and set it to None.'''
+    self.table['vc_files'] = None
+    
+    
+  # Define modcache methods.
+  def checkModuleCaching(self):
+    '''Get status of module caching optimization.'''
+    return(self.table['modcache'])
+    
+  def enableModuleCaching(self):
+    '''Enable module caching optimization.'''
+    self.table['modcache'] = True
+    
+  def disableModuleCaching(self):
+    '''Disable module caching optimization.'''
+    self.table['modcache'] = False
+    
+  def resetModuleCaching(self):
+    '''Reset module caching optimization.'''
+    self.table['modcache'] = False
+    
+    
+  # Define configure_ac methods.
+  def getAutoconfFile(self):
+    '''Return path of autoconf file relative to destdir.'''
+    return(self.table['configure_ac'])
+    
+  def setAutoconfFile(self, configure_ac):
+    '''Specify path of autoconf file relative to destdir.'''
+    if type(configure_ac) is bytes or type(configure_ac) is string:
+      if type(configure_ac) is bytes:
+        configure_ac = string(configure_ac, ENCS['system'])
+      if configure_ac:
+        self.table['configure_ac'] = \
+          relpath(self.table['destdir'],configure_ac)
+    else: # if type of configure_ac is not bytes or string
+      raise(TypeError('configure_ac must be a string, not %s' % \
+        type(configure_ac).__name__))
+    
+  def resetAutoconfFile(self):
+    '''Reset path of autoconf file relative to destdir.'''
+    configure_ac = string()
+    if isfile(joinpath(self.table['destdir'], 'configure.ac')):
+      configure_ac = joinpath(self.table['destdir'], 'configure.ac')
+    elif 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):
+    '''Return preferred autoconf version. Default value is 2.59.'''
+    return(self.table['ac_version'])
+    
+  def setAutoconfVersion(self, ac_version):
+    '''Specify preferred autoconf version. Default value is 2.59.'''
+    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):
+    '''Specify preferred autoconf version. Default value is 2.59.'''
+    self.table['ac_version'] = 2.59
+    
+    
+  # Define symbolic methods.
+  def checkCopyrights(self):
+    '''Check if copyright notices in files should be replaced.'''
+    return(self.table['copyrights'])
+  
+  def checkSymbolic(self):
+    '''Check if pygnulib will make symbolic links instead of copying files.'''
+    return(self.table['symbolic'])
+    
+  def enableSymbolic(self):
+    '''Enable creation of the symbolic links instead of copying files.'''
+    self.table['symbolic'] = True
+    self.table['copyrights'] = False
+    
+  def disableSymbolic(self):
+    '''Enable creation of the symbolic links instead of copying files.'''
+    self.table['symbolic'] = False
+    self.table['copyrights'] = True
+    
+  def resetSymbolic(self):
+    '''Reset creation of the symbolic links instead of copying files.'''
+    self.table['symbolic'] = False
+    self.table['copyrights'] = True
+    
+    
+  # Define lsymbolic methods.
+  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'])
+    
+  def enableLSymbolic(self):
+    '''Enable creation of symbolic links instead of copying files, only for
+    files from the local override directory.'''
+    self.table['lsymbolic'] = True
+    
+  def disableLSymbolic(self):
+    '''Disable creation of symbolic links instead of copying files, only for
+    files from the local override directory.'''
+    self.table['lsymbolic'] = False
+    
+  def resetLSymbolic(self):
+    '''Reset creation of symbolic links instead of copying files, only for
+    files from the local override directory.'''
+    self.table['lsymbolic'] = False
+    
+    
+  # Define verbosity methods.
+  def getVerbosity(self):
+    '''Get verbosity level.'''
+    return(self.table['verbosity'])
+    
+  def decreaseVerbosity(self):
+    '''Decrease verbosity level.'''
+    if self.table['verbosity'] > MODES['verbose-min']:
+      self.table['verbosity'] -= 1
+    
+  def increaseVerbosity(self):
+    '''Increase verbosity level.'''
+    if self.table['verbosity'] < MODES['verbose-max']:
+      self.table['verbosity'] += 1
+    
+  def setVerbosity(self, verbose):
+    '''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):
+    '''Reset verbosity level.'''
+    self.table['verbosity'] = 0
+    
+    
+  # Define libtests methods.
+  def checkLibtests(self):
+    '''Return True if a testsbase/libtests.a is needed.'''
+    return(self.table['libtests'])
+    
+  def enableLibtests(self):
+    '''If libtests is enabled, then testsbase/libtests.a is needed.'''
+    self.table['libtests'] = True
+    
+  def disableLibtests(self):
+    '''If libtests is disabled, then testsbase/libtests.a is not needed.'''
+    self.table['libtests'] = False
+    
+  def resetLibtests(self):
+    '''Reset status of testsbase/libtests.a.'''
+    self.table['libtests'] = False
+    
+    
+  # Define single_configure methods.
+  def checkSingleConfigure(self):
+    '''Check whether single configure file should be generated.'''
+    return(self.table['single_configure'])
+    
+  def enableSingleConfigure(self):
+    '''Enable generation of the single configure file.'''
+    self.table['single_configure'] = True
+    
+  def disableSingleConfigure(self):
+    '''Disable generation of the single configure file.'''
+    self.table['single_configure'] = False
+    
+  def resetSingleConfigure(self):
+    '''Reset status of the single configure file generation.'''
+    self.table['single_configure'] = False
+    
+    
+  # Define dryrun methods.
+  def checkDryRun(self):
+    '''Check whether dryrun is enabled.'''
+    return(self.table['dryrun'])
+    
+  def enableDryRun(self):
+    '''Enable dryrun mode.'''
+    self.table['dryrun'] = True
+    
+  def disableDryRun(self):
+    '''Disable dryrun mode.'''
+    self.table['dryrun'] = False
+    
+  def resetDryRun(self):
+    '''Reset status of dryrun mode.'''
+    self.table['dryrun'] = False
+    
+    
+  # Define errors methods.
+  def checkErrors(self):
+    '''Check if GLError will be raised in non-critical situations.'''
+    return(self.table['errors'])
+  
+  def enableErrors(self):
+    '''Raise GLError in non-critical situations.'''
+    self.table['errors'] = True
+    
+  def disableErrors(self):
+    '''Do not raise GLError in non-critical situations.'''
+    self.table['errors'] = False
+    
+  def resetErrors(self):
+    '''Reset status of raising GLError in non-critical situations.'''
+    self.table['errors'] = False
+