| #!/usr/bin/python |
| # encoding: UTF-8 |
| |
| #=============================================================================== |
| # Define global imports |
| #=============================================================================== |
| import os |
| import re |
| import sys |
| import codecs |
| import hashlib |
| import subprocess as sp |
| from . import constants |
| from .GLError import GLError |
| from .GLConfig import GLConfig |
| from .GLFileSystem import GLFileSystem |
| |
| |
| #=============================================================================== |
| # 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 |
| MODES = constants.MODES |
| TESTS = constants.TESTS |
| compiler = constants.compiler |
| joinpath = constants.joinpath |
| cleaner = constants.cleaner |
| string = constants.string |
| isabs = os.path.isabs |
| isdir = os.path.isdir |
| isfile = os.path.isfile |
| normpath = os.path.normpath |
| relpath = os.path.relpath |
| filter_filelist = constants.filter_filelist |
| |
| |
| #=============================================================================== |
| # Define GLModuleSystem class |
| #=============================================================================== |
| class GLModuleSystem(object): |
| '''GLModuleSystem is used to operate with module system using dynamic |
| searching and patching.''' |
| |
| def __init__(self, config): |
| '''GLModuleSystem.__init__(config) -> GLModuleSystem |
| |
| Create new GLModuleSystem instance. Some functions use GLFileSystem class |
| to look up a file in localdir or gnulib directories, or combine it through |
| 'patch' utility.''' |
| self.args = dict() |
| if type(config) is not GLConfig: |
| raise(TypeError('config must be a GLConfig, not %s' % |
| type(config).__name__)) |
| self.config = config |
| self.filesystem = GLFileSystem(self.config) |
| |
| def __repr__(self): |
| '''x.__repr__ <==> repr(x)''' |
| result = '<pygnulib.GLModuleSystem %s>' % hex(id(self)) |
| return(result) |
| |
| def exists(self, module): |
| '''GLModuleSystem.exists(module) -> bool |
| |
| Check whether the given module exists. |
| GLConfig: localdir.''' |
| if type(module) is bytes or string: |
| if type(module) is bytes: |
| module = module.decode(ENCS['default']) |
| else: # if module has not bytes or string type |
| raise(TypeError( |
| 'module must be a string, not %s' % type(module).__name__)) |
| result = bool() |
| badnames = ['ChangeLog', 'COPYING', 'README', 'TEMPLATE', |
| 'TEMPLATE-EXTENDED', 'TEMPLATE-TESTS'] |
| if isfile(joinpath(DIRS['modules'], module)) or \ |
| all([ # Begin all(iterable) function |
| self.config['localdir'], |
| isdir(joinpath(self.config['localdir'], 'modules')), |
| isfile( |
| joinpath(self.config['localdir'], 'modules', module)) |
| ]): # Close all(iterable) function |
| if module not in badnames: |
| result = True |
| return(result) |
| |
| def find(self, module): |
| '''GLModuleSystem.find(module) -> GLModule |
| |
| Find the given module.''' |
| if type(module) is bytes or string: |
| if type(module) is bytes: |
| module = module.decode(ENCS['default']) |
| else: # if module has not bytes or string type |
| raise(TypeError( |
| 'module must be a string, not %s' % type(module).__name__)) |
| if self.exists(module): |
| path, istemp = self.filesystem.lookup(joinpath('modules', module)) |
| result = GLModule(self.config, path, istemp) |
| return(result) |
| else: # if not self.exists(module) |
| if self.config['errors']: |
| raise(GLError(3, module)) |
| else: # if not self.config['errors'] |
| sys.stderr.write('gnulib-tool: warning: ') |
| sys.stderr.write('file %s does not exist\n' % str(module)) |
| |
| def list(self): |
| '''GLModuleSystem.list() -> list |
| |
| Return the available module names as tuple. We could use a combination |
| of os.walk() function and re module. However, it takes too much time to |
| complete, so this version uses subprocess to run shell commands.''' |
| result = string() |
| listing = list() |
| localdir = self.config['localdir'] |
| find_args = ['find', 'modules', '-type', 'f', '-print'] |
| sed_args = \ |
| [ |
| 'sed', |
| '-e', r's,^modules/,,', |
| '-e', r'/^ChangeLog$/d', |
| '-e', r'/\/ChangeLog$/d', |
| '-e', r'/^COPYING$/d', |
| '-e', r'/\/COPYING$/d', |
| '-e', r'/^README$/d', |
| '-e', r'/\/README$/d', |
| '-e', r'/^TEMPLATE$/d', |
| '-e', r'/^TEMPLATE-EXTENDED$/d', |
| '-e', r'/^TEMPLATE-TESTS$/d', |
| '-e', r'/^\..*/d', |
| '-e', r'/~$/d', |
| '-e', r'/-tests$/d', |
| ] |
| |
| # Read modules from gnulib root directory. |
| os.chdir(constants.DIRS['root']) |
| find = sp.Popen(find_args, stdout=sp.PIPE) |
| result += find.stdout.read().decode("UTF-8") |
| |
| # Read modules from local directory. |
| if localdir and isdir(joinpath(localdir, 'modules')): |
| os.chdir(localdir) |
| find = sp.Popen(find_args, stdout=sp.PIPE) |
| result += find.stdout.read().decode("UTF-8") |
| sed_args += ['-e', r's,\.diff$,,'] |
| |
| # Save the list of the modules to file. |
| os.chdir(DIRS['cwd']) |
| path = joinpath(self.config['tempdir'], 'list') |
| with codecs.open(path, 'wb', 'UTF-8') as file: |
| file.write(result) |
| |
| # Filter the list of the modules. |
| stdin = codecs.open(path, 'rb', 'UTF-8') |
| sed = sp.Popen(sed_args, stdin=stdin, stdout=sp.PIPE) |
| result = sed.stdout.read().decode("UTF-8") |
| stdin.close() |
| os.remove(path) |
| listing = [line for line in result.split('\n') if line.strip()] |
| listing = sorted(set(listing)) |
| return(listing) |
| |
| |
| #=============================================================================== |
| # Define GLModule class |
| #=============================================================================== |
| class GLModule(object): |
| '''GLModule is used to create a module object from the file with the given |
| path. GLModule can get all information about module, get its dependencies, |
| files, etc.''' |
| |
| def __init__(self, config, module, patched=False): |
| '''GLModule.__init__(config, module[, patched]) -> GLModule |
| |
| Create new GLModule instance. Arguments are module and patched, where |
| module is a string representing the path to the module and patched is a |
| bool indicating that module was created after applying patch.''' |
| self.args = dict() |
| self.cache = dict() |
| self.content = string() |
| if type(config) is not GLConfig: |
| raise(TypeError('config must be a GLConfig, not %s' % |
| type(config).__name__)) |
| if type(module) is bytes or type(module) is string: |
| if type(module) is bytes: |
| module = module.decode(ENCS['default']) |
| else: # if module has not bytes or string type |
| raise(TypeError('module must be a string, not %s' % |
| type(module).__name__)) |
| if type(patched) is not bool: |
| raise(TypeError('patched must be a bool, not %s' % |
| type(module).__name__)) |
| self.module = module |
| self.patched = patched |
| self.config = config |
| self.filesystem = GLFileSystem(self.config) |
| self.modulesystem = GLModuleSystem(self.config) |
| with codecs.open(module, 'rb', 'UTF-8') as file: |
| self.content = file.read() |
| self.regex = '(?:Description:|Comment:|Status:|Notice:|Applicability:|\ |
| Files:|Depends-on:|configure\\.ac-early:|configure\\.ac:|Makefile\\.am:|\ |
| Include:|Link:|License:|Maintainer:)' |
| |
| def __eq__(self, module): |
| '''x.__eq__(y) <==> x==y''' |
| result = bool() |
| if type(module) is GLModule: |
| if self.module == module.module: |
| result = True |
| return(result) |
| |
| def __ne__(self, module): |
| '''x.__ne__(y) <==> x!=y''' |
| result = bool() |
| if type(module) is GLModule: |
| if self.module != module.module: |
| result = True |
| return(result) |
| |
| def __ge__(self, module): |
| '''x.__ge__(y) <==> x>=y''' |
| result = bool() |
| if type(module) is GLModule: |
| if self.module >= module.module: |
| result = True |
| return(result) |
| |
| def __gt__(self, module): |
| '''x.__gt__(y) <==> x>y''' |
| result = bool() |
| if type(module) is GLModule: |
| if self.module > module.module: |
| result = True |
| return(result) |
| |
| def __hash__(self): |
| '''x.__hash__() <==> hash(x)''' |
| module = hash(self.module) |
| patched = hash(self.patched) |
| result = module ^ patched |
| return(result) |
| |
| def __le__(self, module): |
| '''x.__le__(y) <==> x<=y''' |
| result = bool() |
| if type(module) is GLModule: |
| if self.module <= module.module: |
| result = True |
| return(result) |
| |
| def __lt__(self, module): |
| '''x.__lt__(y) <==> x<y''' |
| result = bool() |
| if type(module) is GLModule: |
| if self.module < module.module: |
| result = True |
| return(result) |
| |
| def __str__(self): |
| '''x.__str__() <==> str(x)''' |
| result = self.getName() |
| return(result) |
| |
| def __repr__(self): |
| '''x.__repr__ <==> repr(x)''' |
| result = '<pygnulib.GLModule %s %s>' % \ |
| (repr(self.getName()), hex(id(self))) |
| 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) |
| |
| def isPatched(self): |
| '''GLModule.isPatched() -> bool |
| |
| Check whether module was created after applying patch.''' |
| 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) |
| |
| def isNonTests(self): |
| '''GLModule.isTests() -> bool |
| |
| Check whether module is not a -tests version of module.''' |
| result = not(self.isTests()) |
| return(result) |
| |
| def getTestsName(self): |
| '''Return -tests version of the module name.''' |
| result = self.getName() |
| if not result.endswith('-tests'): |
| result += '-tests' |
| return(result) |
| |
| def getTestsModule(self): |
| '''Return -tests version of the module as GLModule.''' |
| result = self.modulesystem.find(self.getTestsName()) |
| return(result) |
| |
| def getShellFunc(self): |
| '''GLModule.getShellFunc() -> string |
| |
| Computes the shell function name that will contain the m4 macros for the |
| module.''' |
| isalnum = True |
| macro_prefix = self.config['macro_prefix'] |
| for char in str(module): |
| if char not in constants.ALPHANUMERIC: |
| isalnum = False |
| break |
| if isalnum: |
| module = str(self) |
| else: # if not isalnum |
| module = '%s\n' % str(self) |
| if type(module) is string: |
| module = module.encode(ENCS['default']) |
| module = hashlib.md5(module).hexdigest() |
| result = 'func_%s_gnulib_m4code_%s' % (macro_prefix, module) |
| if type(result) is bytes: |
| result = result.decode(ENCS['default']) |
| return(result) |
| |
| def getShellVar(self): |
| '''GLModule.getShellVar() -> string |
| |
| Compute the shell variable name the will be set to true once the m4 macros |
| for the module have been executed.''' |
| isalnum = True |
| macro_prefix = self.config['macro_prefix'] |
| for char in str(module): |
| if char not in constants.ALPHANUMERIC: |
| isalnum = False |
| break |
| if isalnum: |
| module = str(self) |
| else: # if not isalnum |
| module = '%s\n' % str(self) |
| if type(module) is string: |
| module = module.encode(ENCS['default']) |
| module = hashlib.md5(module).hexdigest() |
| result = '%s_gnulib_enabled_%s' % (macro_prefix, module) |
| if type(result) is bytes: |
| result = result.decode(ENCS['default']) |
| return(result) |
| |
| def getConditionalName(self): |
| '''GLModule.getConditionalName() -> string |
| |
| Return the automake conditional name. |
| GLConfig: macro_prefix.''' |
| macro_prefix = self.config['macro_prefix'] |
| nonascii = \ |
| [ # Begin to filter non-ascii chars |
| char for char in self.getName() if char not in \ |
| 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_' |
| ] # Finish to filter non-ascii chars |
| if nonascii: |
| name = self.getName().encode(ENCS['default']) |
| name = hashlib.md5(name).hexdigest() |
| conditional = '%s_GNULIB_ENABLED_%s' % (macro_prefix, name) |
| else: # if not nonascii |
| result = '%s_GNULIB_ENABLED_%s' (macro_prefix, name) |
| if type(result) is bytes: |
| result = result.decode(ENCS['default']) |
| return(result) |
| |
| def getDescription(self): |
| '''GLModule.getDescription() -> string |
| |
| Return description of the module.''' |
| section = 'Description:' |
| if 'description' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| pattern = '^%s[\t ]*(.*?)%s' % (section, self.regex) |
| pattern = compiler(pattern, re.S | re.M) |
| result = pattern.findall(self.content) |
| if type(result) is list: |
| if not result: |
| result = string() |
| else: # if result |
| result = result[-1] |
| result = result.strip() |
| self.cache['description'] = result |
| return(self.cache['description']) |
| |
| def getComment(self): |
| '''GLModule.getComment() -> string |
| |
| Return comment to module.''' |
| section = 'Comment:' |
| if 'comment' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| pattern = '^%s[\t ]*(.*?)%s' % (section, self.regex) |
| pattern = compiler(pattern, re.S | re.M) |
| result = pattern.findall(self.content) |
| if type(result) is list: |
| if not result: |
| result = string() |
| else: # if result |
| result = result[-1] |
| result = result.strip() |
| self.cache['comment'] = result |
| return(self.cache['comment']) |
| |
| def getStatus(self): |
| '''GLModule.getStatus() -> string |
| |
| Return module status.''' |
| section = 'Status:' |
| if 'status' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| result = [part.strip() for part in parts if part.strip()] |
| self.cache['status'] = list(result) |
| return(list(self.cache['status'])) |
| |
| def getNotice(self): |
| '''GLModule.getNotice() -> string |
| |
| Return notice to module.''' |
| section = 'Notice:' |
| if 'notice' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| result = ''.join(parts) |
| self.cache['notice'] = result |
| return(self.cache['notice']) |
| |
| def getApplicability(self): |
| '''GLModule.getApplicability() -> string |
| |
| Return applicability of module.''' |
| section = 'Applicability:' |
| if 'applicability' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| parts = [part.strip() for part in parts] |
| result = ''.join(parts) |
| if not result.strip(): |
| if self.getName().endswith('-tests'): |
| result = 'tests' |
| else: # if not self.getName().endswith('-tests') |
| result = 'main' |
| if type(result) is bytes: |
| result = result.decode(ENCS['default']) |
| result = result.strip() |
| self.cache['applicability'] = result |
| return(self.cache['applicability']) |
| |
| def getFiles(self): |
| '''GLModule.getFiles() -> list |
| |
| Return list of files. |
| GLConfig: ac_version.''' |
| ac_version = self.config['ac_version'] |
| section = 'Files:' |
| result = list() |
| if 'files' not in self.cache: |
| if section not in self.content: |
| result = list() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| result = [part.strip() for part in parts if part.strip()] |
| result += [joinpath('m4', '00gnulib.m4')] |
| result += [joinpath('m4', 'zzgnulib.m4')] |
| result += [joinpath('m4', 'gnulib-common.m4')] |
| self.cache['files'] = list(result) |
| return(list(self.cache['files'])) |
| |
| def getDependencies(self): |
| '''GLModule.getDependencies() -> list |
| |
| Return list of dependencies. |
| GLConfig: localdir.''' |
| localdir = self.config['localdir'] |
| result = list() |
| section = 'Depends-on:' |
| if 'dependencies' not in self.cache: |
| if section not in self.content: |
| depmodules = list() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| modules = ''.join(parts) |
| modules = [line for line in modules.split( |
| '\n') if line.strip()] |
| modules = [ |
| module for module in modules if not module.startswith('#')] |
| for line in modules: |
| split = [part for part in line.split(' ') if part.strip()] |
| if len(split) == 1: |
| module = line.strip() |
| condition = None |
| else: # if len(split) != 1 |
| module = split[0] |
| condition = split[1] |
| if type(condition) is bytes: |
| condition = condition.decode(ENCS['default']) |
| result += [tuple([self.modulesystem.find(module), condition])] |
| self.cache['dependencies'] = result |
| return(list(self.cache['dependencies'])) |
| |
| def getAutoconfSnippet_Early(self): |
| '''GLModule.getAutoconfSnippet_Early() -> string |
| |
| Return autoconf-early snippet.''' |
| section = 'configure.ac-early:' |
| if 'autoconf-early' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| result = ''.join(parts) |
| self.cache['autoconf-early'] = result |
| return(self.cache['autoconf-early']) |
| |
| def getAutoconfSnippet(self): |
| '''GLModule.getAutoconfSnippet() -> string |
| |
| Return autoconf snippet.''' |
| section = 'configure.ac:' |
| if 'autoconf' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| result = ''.join(parts) |
| self.cache['autoconf'] = result |
| return(self.cache['autoconf']) |
| |
| def getAutomakeSnippet(self): |
| '''getAutomakeSnippet() -> string |
| |
| Get automake snippet. |
| GLConfig: auxdir, ac_version.''' |
| result = string() # Define stack variable |
| conditional = self.getAutomakeSnippet_Conditional() |
| if conditional.strip(): |
| result += self.getAutomakeSnippet_Conditional() |
| else: # if not conditional.strip() |
| result += '\n' |
| result += self.getAutomakeSnippet_Unconditional() |
| return(result) |
| |
| def getAutomakeSnippet_Conditional(self): |
| '''GLModule.getAutomakeSnippet_Conditional() -> string |
| |
| Return conditional automake snippet.''' |
| section = 'Makefile.am:' |
| if 'makefile-conditional' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| result = ''.join(parts) |
| self.cache['makefile-conditional'] = result |
| return(self.cache['makefile-conditional']) |
| |
| def getAutomakeSnippet_Unconditional(self): |
| '''GLModule.getAutomakeSnippet_Unconditional() -> string |
| |
| Return unconditional automake snippet. |
| GLConfig: auxdir, ac_version.''' |
| auxdir = self.config['auxdir'] |
| ac_version = self.config['ac_version'] |
| result = string() |
| if 'makefile-unconditional' not in self.cache: |
| if self.isTests(): |
| files = self.getFiles() |
| extra_files = filter_filelist(constants.NL, files, |
| 'tests/', '', 'tests/', '').split(constants.NL) |
| extra_files = sorted(set(extra_files)) |
| if extra_files: |
| result += string('EXTRA_DIST += %s' % |
| ' '.join(extra_files)) |
| result += constants.NL * 2 |
| else: # if not tests module |
| # TODO: unconditional automake snippet for nontests modules |
| snippet = self.getAutomakeSnippet_Conditional() |
| snippet = constants.combine_lines(snippet) |
| pattern = compiler( |
| '^lib_SOURCES[\t ]*\\+=[\t ]*(.*?)$', re.S | re.M) |
| mentioned_files = pattern.findall(snippet) |
| if mentioned_files != list(): |
| mentioned_files = mentioned_files[-1].split(' ') |
| mentioned_files = [f.strip() for f in mentioned_files] |
| mentioned_files = [f for f in mentioned_files if f != ''] |
| mentioned_files = sorted(set(mentioned_files)) |
| all_files = self.getFiles() |
| lib_files = filter_filelist(constants.NL, all_files, |
| 'lib/', '', 'lib/', '').split(constants.NL) |
| extra_files = [ |
| f for f in lib_files if f not in mentioned_files] |
| extra_files = sorted(set(extra_files)) |
| if extra_files != [''] and extra_files: |
| result += string('EXTRA_DIST += %s' % |
| ' '.join(extra_files)) |
| result += '\n\n' |
| # Synthesize also an EXTRA_lib_SOURCES augmentation |
| if str(self) != 'relocatable-prog-wrapper' and str(self) != 'pt_chown': |
| extra_files = filter_filelist(constants.NL, extra_files, |
| '', '.c', '', '').split(constants.NL) |
| extra_files = sorted(set(extra_files)) |
| if extra_files != ['']: |
| result += string('EXTRA_lib_SOURCES += %s' % |
| ' '.join(extra_files)) |
| result += '\n\n' |
| # Synthesize an EXTRA_DIST augmentation also for the files in build-aux |
| buildaux_files = filter_filelist(constants.NL, all_files, |
| 'build-aux/', '', 'build-aux/', '').split(constants.NL) |
| buildaux_files = sorted(set(buildaux_files)) |
| if buildaux_files != ['']: |
| buildaux_files = ''.join(buildaux_files) |
| buildaux_files = joinpath( |
| '$(top_srcdir)', auxdir, buildaux_files) |
| result += string('EXTRA_DIST += %s' % buildaux_files) |
| result += '\n\n' |
| # Synthesize an EXTRA_DIST augmentation also for the files from top/. |
| top_files = filter_filelist(constants.NL, all_files, |
| 'top/', '', 'top/', '').split(constants.NL) |
| top_files = sorted(set(top_files)) |
| if top_files != ['']: |
| top_files = ''.join(top_files) |
| top_files = joinpath('$(top_srcdir)', top_files) |
| result += string('EXTRA_DIST += %s' % top_files) |
| result += '\n\n' |
| result = constants.nlconvert(result) |
| self.cache['makefile-unconditional'] = result |
| return(self.cache['makefile-unconditional']) |
| |
| def getInclude(self): |
| '''GLModule.getInclude() -> string |
| |
| Return include directive.''' |
| section = 'Include:' |
| if 'include' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| result = ''.join(parts) |
| result = result.strip() |
| pattern = compiler('^(["<].*?[>"])', re.S | re.M) |
| result = pattern.sub('#include \\1', result) |
| self.cache['include'] = result |
| return(self.cache['include']) |
| |
| def getLink(self): |
| '''GLModule.getLink() -> string |
| |
| Return link directive.''' |
| section = 'Link:' |
| if 'link' not in self.cache: |
| parts = list() |
| if section in self.content: |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| parts = [part.strip() for part in parts if part.strip()] |
| # result = ' '.join(parts) |
| self.cache['link'] = parts |
| return(self.cache['link']) |
| |
| def getLicense(self): |
| '''GLModule.getLicense(self) -> string |
| |
| Get license and warn user if module lacks a license.''' |
| license = self.getLicense_Raw() |
| if not self.isTests(): |
| if not license: |
| if self.config['errors']: |
| raise(GLError(18, string(self))) |
| else: # if not self.config['errors'] |
| sys.stderr.write('gnulib-tool: warning: ') |
| sys.stderr.write('module %s lacks a license\n' % str(self)) |
| if not license: |
| license = 'GPL' |
| return(license) |
| |
| def getLicense_Raw(self): |
| '''GLModule.getLicense_Raw() -> string |
| |
| Return module license.''' |
| section = 'License:' |
| if 'license' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| pattern = '^%s[\t ]*(.*?)%s' % (section, self.regex) |
| pattern = compiler(pattern, re.S | re.M) |
| result = pattern.findall(self.content) |
| if type(result) is list: |
| if not result: |
| result = string() |
| else: # if result |
| result = result[-1] |
| result = result.strip() |
| self.cache['license'] = result |
| return(self.cache['license']) |
| |
| def getMaintainer(self): |
| '''GLModule.getMaintainer() -> string |
| |
| Return maintainer directive.''' |
| section = 'Maintainer:' |
| if 'maintainer' not in self.cache: |
| if section not in self.content: |
| result = string() |
| else: # if section in self.content |
| snippet = self.content.split(section)[-1] |
| snippet = snippet.replace('\r\n', '\n') |
| lines = ['%s\n' % line for line in snippet.split('\n')] |
| parts = list() |
| for line in lines: |
| regex = '^(Description|Comment|Status|Notice|Applicability|' |
| regex += 'Files|Depends-on|configure\\.ac-early|configure\\.ac|' |
| regex += 'Makefile\\.am|Include|Link|License|Maintainer):$' |
| pattern = compiler(regex) |
| findflag = pattern.findall(line) |
| if findflag: |
| break |
| parts += [line] |
| result = ''.join(parts) |
| result = result.strip() |
| self.cache['maintainer'] = result |
| return(self.cache['maintainer']) |
| |
| |
| #=============================================================================== |
| # Define GLModuleTable class |
| #=============================================================================== |
| class GLModuleTable(object): |
| '''GLModuleTable is used to work with the list of the modules.''' |
| |
| def __init__(self, config, avoids=list()): |
| '''GLModuleTable.__init__(config, avoids) -> GLModuleTable |
| |
| Create new GLModuleTable instance. If modules are specified, then add |
| every module from iterable as unconditional module. If avoids is specified, |
| then in transitive_closure every dependency which is in avoids won't be |
| included in the final modules list. If testflags iterable is enabled, then |
| don't add module which status is in the testflags. If conddeps are enabled, |
| then store condition for each dependency if it has a condition. |
| The only necessary argument is localdir, which is needed just to create |
| modulesystem instance to look for dependencies.''' |
| self.avoids = list() # Avoids |
| self.dependers = dict() # Dependencies |
| self.conditionals = dict() # Conditional modules |
| self.unconditionals = dict() # Unconditional modules |
| self.base_modules = list() # Base modules |
| self.main_modules = list() # Main modules |
| self.tests_modules = list() # Tests modules |
| self.final_modules = list() # Final modules |
| if type(config) is not GLConfig: |
| raise(TypeError('config must be a GLConfig, not %s' % |
| type(config).__name__)) |
| for avoid in avoids: |
| if type(avoid) is not GLModule: |
| raise(TypeError('each avoid must be a GLModule instance')) |
| self.avoids += [avoids] |
| self.config = config |
| self.filesystem = GLFileSystem(self.config) |
| self.modulesystem = GLModuleSystem(self.config) |
| |
| def __repr__(self): |
| '''x.__repr__() <==> repr(x)''' |
| result = '<pygnulib.GLModuleTable %s>' % hex(id(self)) |
| 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()) |
| elif y == 'final': |
| return(self.getFinalModules()) |
| elif y == 'main': |
| return(self.getMainModules()) |
| elif y == 'tests': |
| return(self.getTestsModules()) |
| else: # if y == 'avoids' |
| return(self.getAvoids()) |
| else: # if y is not in list |
| raise(KeyError('GLModuleTable does not contain key: %s' % repr(y))) |
| |
| def addConditional(self, parent, module, condition): |
| '''GLModuleTable.addConditional(module, condition) |
| |
| Add new conditional dependency from parent to module with condition.''' |
| if type(parent) is not GLModule: |
| raise(TypeError('parent must be a GLModule, not %s' % |
| type(parent).__name__)) |
| if type(module) is not GLModule: |
| raise(TypeError('module must be a GLModule, not %s' % |
| type(module).__name__)) |
| if type(condition) is bytes or type(condition) is string \ |
| or condition == True: |
| if type(condition) is bytes: |
| condition = condition.decode(ENCS['default']) |
| else: # if condition has not bytes or string type or is not True |
| raise(TypeError('condition must be a string or True, not %s' % |
| type(condition).__name__)) |
| if not str(module) in self.unconditionals: |
| if str(module) not in self.dependers: |
| self.dependers[module] = list() |
| self.dependers[module] += [module] |
| key = '%s---%s' % (str(parent), str(module)) |
| self.conditionals[key] = condition |
| |
| def addUnconditional(self, module): |
| '''GLModuleTable.addUnconditional(module) |
| |
| Add module as unconditional dependency.''' |
| if type(module) is not GLModule: |
| raise(TypeError('module must be a GLModule, not %s' % |
| type(module).__name__)) |
| if str(module) in self.dependers: |
| self.dependers.pop(str(module)) |
| self.unconditionals[str(module)] = True |
| |
| def isConditional(self, module): |
| '''GLModuleTable.isConditional(module) -> bool |
| |
| Check whether module is unconditional.''' |
| if type(module) is not GLModule: |
| raise(TypeError('module must be a GLModule, not %s' % |
| type(module).__name__)) |
| result = str(module) in self.dependers |
| return(result) |
| |
| def getCondition(self, parent, module): |
| '''GLModuleTable.getCondition(module) -> string or True |
| |
| Return condition from parent to module. Condition can be string or True. |
| If module is not in the list of conddeps, method returns None.''' |
| if type(parent) is not GLModule: |
| raise(TypeError('parent must be a GLModule, not %s' % |
| type(parent).__name__)) |
| if type(module) is not GLModule: |
| raise(TypeError('module must be a GLModule, not %s' % |
| type(module).__name__)) |
| key = '%s---%s' % (str(parent), str(module)) |
| result = None |
| if key in self.conditionals: |
| result = self.conditionals[key] |
| return(result) |
| |
| def transitive_closure(self, modules): |
| '''GLModuleTable.transitive_closure(modules) -> list |
| |
| Use transitive closure to add module and its dependencies. Add every |
| module and its dependencies from modules list, but do not add dependencies |
| which contain in avoids list. If any testflag is enabled, then do not add |
| dependencies which have the status as this flag. If conddeps are enabled, |
| then store condition for each dependency if it has a condition. This method |
| is used to update final list of modules. Method returns list of modules. |
| GLConfig: testflags.''' |
| for module in modules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| handledmodules = list() |
| inmodules = modules |
| outmodules = list() |
| if self.config['conddeps']: |
| for module in modules: |
| self.addUnconditional(module) |
| while inmodules: |
| inmodules_this_round = inmodules |
| inmodules = list() |
| for module in inmodules_this_round: |
| outmodules += [module] |
| if self.config['conddeps']: |
| automake_snippet = \ |
| module.getAutomakeSnippet_Conditional() |
| pattern = compiler('^if') |
| if not pattern.findall(automake_snippet): |
| self.addUnconditional(module) |
| conditional = self.isConditional(module) |
| dependencies = module.getDependencies() |
| depmodules = [pair[0] for pair in dependencies] |
| conditions = [pair[1] for pair in dependencies] |
| if TESTS['tests'] in self.config['testflags']: |
| testsname = module.getTestsName() |
| if self.modulesystem.exists(testsname): |
| testsmodule = self.modulesystem.find(testsname) |
| depmodules += [testsmodule] |
| conditions += [None] |
| for depmodule in depmodules: |
| include = True |
| includes = list() |
| status = depmodule.getStatus() |
| for word in status: |
| if word == 'obsolete': |
| if TESTS['obsolete'] in self.config['testflags'] or \ |
| TESTS['all-test'] in self.config['testflags']: |
| includes += [False] |
| elif word == 'c++-test': |
| if TESTS['c++-test'] in self.config['testflags'] or \ |
| TESTS['all-test'] in self.config['testflags']: |
| includes += [False] |
| elif word == 'longrunning-test': |
| if TESTS['longrunning-test'] in self.config['testflags'] or \ |
| TESTS['all-test'] in self.config['testflags']: |
| includes += [False] |
| elif word == 'privileged-test': |
| if TESTS['privileged-test'] in self.config['testflags'] or \ |
| TESTS['all-test'] in self.config['testflags']: |
| includes += [False] |
| elif word == 'all-test': |
| if TESTS['all-test'] in self.config['testflags'] or \ |
| TESTS['all-test'] in self.config['testflags']: |
| includes += [False] |
| else: # if any other word |
| if word.endswith('-tests'): |
| if TESTS['all-test'] in self.config['testflags']: |
| includes += [False] |
| include = any(includes) |
| if include and depmodule not in self.avoids: |
| inmodules += [depmodule] |
| if self.config['conddeps']: |
| index = depmodules.index(depmodule) |
| condition = conditions[index] |
| if condition: |
| self.addConditional( |
| module, depmodule, condition) |
| else: # if condition |
| if conditional: |
| self.addConditional( |
| module, depmodule, True) |
| else: # if not conditional |
| self.addUnconditional(module) |
| listing = list() # Create empty list |
| inmodules = sorted(set(inmodules)) |
| handledmodules = sorted(set(handledmodules + inmodules_this_round)) |
| inmodules = \ |
| [ # Begin to filter inmodules |
| module for module in inmodules if module not in handledmodules |
| ] # Finish to filter inmodules |
| inmodules = sorted(set(inmodules)) |
| modules = sorted(set(outmodules)) |
| self.modules = modules |
| return(list(modules)) |
| |
| def transitive_closure_separately(self, basemodules, finalmodules): |
| '''GLModuleTable.transitive_closure_separately(*args, **kwargs) -> tuple |
| |
| Determine main module list and tests-related module list separately. |
| The main module list is the transitive closure of the specified modules, |
| ignoring tests modules. Its lib/* sources go into $sourcebase/. If lgpl is |
| specified, it will consist only of LGPLed source. |
| The tests-related module list is the transitive closure of the specified |
| modules, including tests modules, minus the main module list excluding |
| modules of applicability 'all'. Its lib/* sources (brought in through |
| dependencies of *-tests modules) go into $testsbase/. It may contain GPLed |
| source, even if lgpl is specified. |
| Arguments are basemodules and finalmodules, where basemodules argument |
| represents modules specified by user and finalmodules represents modules |
| list after previous transitive_closure. |
| Method returns tuple which contains two lists: the list of main modules and |
| the list of tests-related modules. Both lists contain dependencies. |
| GLConfig: testflags.''' |
| inctests = False |
| main_modules = list() |
| tests_modules = list() |
| if TESTS['tests'] in self.config['testflags']: |
| self.config['testflags'].pop(TESTS['tests']) |
| inctests = True |
| for module in basemodules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| for module in finalmodules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| main_modules = self.transitive_closure(basemodules) |
| tests_modules = \ |
| [m for m in finalmodules if m not in main_modules] + \ |
| [m for m in main_modules if m.getApplicability() != 'main'] |
| tests_modules = sorted(set(tests_modules)) |
| if inctests: |
| testflags = sorted( |
| set(self.config['testflags'] + [TESTS['tests']])) |
| self.config.setTestFlags(testflags) |
| result = tuple([main_modules, tests_modules]) |
| return(result) |
| |
| def add_dummy(self, modules): |
| '''GLModuleTable.add_dummy(modules) -> list |
| |
| Add dummy package to list of modules if dummy package is needed. If not, |
| return original list of modules. |
| GLConfig: auxdir, ac_version.''' |
| auxdir = self.config['auxdir'] |
| ac_version = self.config['ac_version'] |
| have_lib_sources = False |
| for module in modules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| snippet = module.getAutomakeSnippet() |
| snippet = constants.remove_backslash_newline(snippet) |
| pattern = compiler( |
| '^lib_SOURCES[\t ]*\\+=[\t ]*(.*?)$', re.S | re.M) |
| files = pattern.findall(snippet) |
| if files: # if source files were found |
| files = files[-1].split(' ') |
| for file in files: |
| if not file.endswith('.h'): |
| have_lib_sources = True |
| break |
| if not have_lib_sources: |
| dummy = self.modulesystem.find('dummy') |
| modules = sorted(set(modules + [dummy])) |
| return(list(modules)) |
| |
| def filelist(self, modules): |
| '''GLModuleTable.filelist(modules) -> list |
| |
| Determine the final file list for the given list of modules. The list of |
| modules must already include dependencies. |
| GLConfig: ac_version.''' |
| ac_version = self.config['ac_version'] |
| filelist = list() |
| for module in modules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| listings = [module.getFiles() for module in modules] |
| for listing in listings: |
| for file in listing: |
| if file not in filelist: |
| filelist += [file] |
| return(filelist) |
| |
| def filelist_separately(self, main_modules, tests_modules): |
| '''GLModuleTable.filelist_separately(**kwargs) -> list |
| |
| Determine the final file lists. They must be computed separately, because |
| files in lib/* go into $sourcebase/ if they are in the main file list but |
| into $testsbase/ if they are in the tests-related file list. Furthermore |
| lib/dummy.c can be in both.''' |
| ac_version = self.config['ac_version'] |
| main_filelist = self.filelist(main_modules) |
| tests_filelist = self.filelist(tests_modules) |
| tests_filelist = \ |
| [ # Begin to sort filelist |
| file.replace('lib/', 'tests=lib/', 1) \ |
| if file.startswith('lib/') else file |
| for file in tests_filelist |
| ] # Finish to sort filelist |
| result = tuple([main_filelist, tests_filelist]) |
| return(result) |
| |
| def getAvoids(self): |
| '''GLModuleTable.getAvoids() -> list |
| |
| Return list of avoids.''' |
| return(list(self.avoids)) |
| |
| def setAvoids(self, modules): |
| '''GLModuleTable.setAvoids(modules) |
| |
| Specify list of avoids.''' |
| for module in modules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| self.avoids = sorted(set(modules)) |
| |
| def getBaseModules(self): |
| '''GLModuleTable.getBaseModules() -> list |
| |
| Return list of base modules.''' |
| return(list(self.base_modules)) |
| |
| def setBaseModules(self, modules): |
| '''GLModuleTable.setBaseModules(modules) |
| |
| Specify list of base modules.''' |
| for module in modules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| self.base_modules = sorted(set(modules)) |
| |
| def getFinalModules(self): |
| '''GLModuleTable.getFinalModules() -> list |
| |
| Return list of final modules.''' |
| return(list(self.final_modules)) |
| |
| def setFinalModules(self, modules): |
| '''GLModuleTable.setFinalModules(modules) |
| |
| Specify list of final modules.''' |
| for module in modules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| self.final_modules = sorted(set(modules)) |
| |
| def getMainModules(self): |
| '''GLModuleTable.getMainModules() -> list |
| |
| Return list of main modules.''' |
| return(list(self.main_modules)) |
| |
| def setMainModules(self, modules): |
| '''GLModuleTable.setMainModules(modules) |
| |
| Specify list of main modules.''' |
| for module in modules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| self.main_modules = sorted(set(modules)) |
| |
| def getTestsModules(self): |
| '''GLModuleTable.getTestsModules() -> list |
| |
| Return list of tests modules.''' |
| return(list(self.tests_modules)) |
| |
| def setTestsModules(self, modules): |
| '''GLModuleTable.setTestsModules(modules) |
| |
| Specify list of tests modules.''' |
| for module in modules: |
| if type(module) is not GLModule: |
| raise(TypeError('each module must be a GLModule instance')) |
| self.tests_modules = sorted(set(modules)) |
