| #!/usr/bin/env python3 | |
| # | |
| # Copyright (C) 2013-2023 Free Software Foundation, Inc. | |
| # | |
| # This script is free software; you can redistribute it and/or modify | |
| # it under the terms of the GNU General Public License as published by | |
| # the Free Software Foundation; either version 3, or (at your option) | |
| # any later version. | |
| # This script adjusts the copyright notices at the top of source files | |
| # so that they have the form: | |
| # | |
| # Copyright XXXX-YYYY Free Software Foundation, Inc. | |
| # | |
| # It doesn't change code that is known to be maintained elsewhere or | |
| # that carries a non-FSF copyright. | |
| # | |
| # Pass --this-year to the script if you want it to add the current year | |
| # to all applicable notices. Pass --quilt if you are using quilt and | |
| # want files to be added to the quilt before being changed. | |
| # | |
| # By default the script will update all directories for which the | |
| # output has been vetted. You can instead pass the names of individual | |
| # directories, including those that haven't been approved. So: | |
| # | |
| # update-copyright.py --this-year | |
| # | |
| # is the command that would be used at the beginning of a year to update | |
| # all copyright notices (and possibly at other times to check whether | |
| # new files have been added with old years). On the other hand: | |
| # | |
| # update-copyright.py --this-year libiberty | |
| # | |
| # would run the script on just libiberty/. | |
| # | |
| # This script was copied from gcc's contrib/ and modified to suit | |
| # binutils. In contrast to the gcc script, this one will update | |
| # the testsuite and --version output strings too. | |
| import os | |
| import re | |
| import sys | |
| import time | |
| import subprocess | |
| class Errors: | |
| def __init__ (self): | |
| self.num_errors = 0 | |
| def report (self, filename, string): | |
| if filename: | |
| string = filename + ': ' + string | |
| sys.stderr.write (string + '\n') | |
| self.num_errors += 1 | |
| def ok (self): | |
| return self.num_errors == 0 | |
| class GenericFilter: | |
| def __init__ (self): | |
| self.skip_files = set() | |
| self.skip_dirs = set() | |
| self.skip_extensions = set([ | |
| '.png', | |
| '.pyc', | |
| ]) | |
| self.fossilised_files = set() | |
| self.own_files = set() | |
| self.skip_files |= set ([ | |
| # Skip licence files. | |
| 'COPYING', | |
| 'COPYING.LIB', | |
| 'COPYING3', | |
| 'COPYING3.LIB', | |
| 'COPYING.LIBGLOSS', | |
| 'COPYING.NEWLIB', | |
| 'LICENSE', | |
| 'fdl.texi', | |
| 'gpl_v3.texi', | |
| 'fdl-1.3.xml', | |
| 'gpl-3.0.xml', | |
| # Skip auto- and libtool-related files | |
| 'aclocal.m4', | |
| 'compile', | |
| 'config.guess', | |
| 'config.sub', | |
| 'depcomp', | |
| 'install-sh', | |
| 'libtool.m4', | |
| 'ltmain.sh', | |
| 'ltoptions.m4', | |
| 'ltsugar.m4', | |
| 'ltversion.m4', | |
| 'lt~obsolete.m4', | |
| 'missing', | |
| 'mkdep', | |
| 'mkinstalldirs', | |
| 'move-if-change', | |
| 'shlibpath.m4', | |
| 'symlink-tree', | |
| 'ylwrap', | |
| # Skip FSF mission statement, etc. | |
| 'gnu.texi', | |
| 'funding.texi', | |
| 'appendix_free.xml', | |
| # Skip imported texinfo files. | |
| 'texinfo.tex', | |
| ]) | |
| self.skip_extensions |= set ([ | |
| # Maintained by the translation project. | |
| '.po', | |
| # Automatically-generated. | |
| '.pot', | |
| ]) | |
| self.skip_dirs |= set ([ | |
| 'autom4te.cache', | |
| ]) | |
| def get_line_filter (self, dir, filename): | |
| if filename.startswith ('ChangeLog'): | |
| # Ignore references to copyright in changelog entries. | |
| return re.compile ('\t') | |
| return None | |
| def skip_file (self, dir, filename): | |
| if filename in self.skip_files: | |
| return True | |
| (base, extension) = os.path.splitext (os.path.join (dir, filename)) | |
| if extension in self.skip_extensions: | |
| return True | |
| if extension == '.in': | |
| # Skip .in files produced by automake. | |
| if os.path.exists (base + '.am'): | |
| return True | |
| # Skip files produced by autogen | |
| if (os.path.exists (base + '.def') | |
| and os.path.exists (base + '.tpl')): | |
| return True | |
| # Skip configure files produced by autoconf | |
| if filename == 'configure': | |
| if os.path.exists (base + '.ac'): | |
| return True | |
| if os.path.exists (base + '.in'): | |
| return True | |
| return False | |
| def skip_dir (self, dir, subdir): | |
| return subdir in self.skip_dirs | |
| def is_fossilised_file (self, dir, filename): | |
| if filename in self.fossilised_files: | |
| return True | |
| # Only touch current current ChangeLogs. | |
| if filename != 'ChangeLog' and filename.find ('ChangeLog') >= 0: | |
| return True | |
| return False | |
| def by_package_author (self, dir, filename): | |
| return filename in self.own_files | |
| class Copyright: | |
| def __init__ (self, errors): | |
| self.errors = errors | |
| # Characters in a range of years. Include '.' for typos. | |
| ranges = '[0-9](?:[-0-9.,\s]|\s+and\s+)*[0-9]' | |
| # Non-whitespace characters in a copyright holder's name. | |
| name = '[\w.,-]' | |
| # Matches one year. | |
| self.year_re = re.compile ('[0-9]+') | |
| # Matches part of a year or copyright holder. | |
| self.continuation_re = re.compile (ranges + '|' + name) | |
| # Matches a full copyright notice: | |
| self.copyright_re = re.compile ( | |
| # 1: 'Copyright (C)', etc. | |
| '([Cc]opyright' | |
| '|[Cc]opyright\s+\([Cc]\)' | |
| '|[Cc]opyright\s+%s' | |
| '|[Cc]opyright\s+©' | |
| '|[Cc]opyright\s+@copyright{}' | |
| '|@set\s+copyright[\w-]+)' | |
| # 2: the years. Include the whitespace in the year, so that | |
| # we can remove any excess. | |
| '(\s*(?:' + ranges + ',?' | |
| '|@value\{[^{}]*\})\s*)' | |
| # 3: 'by ', if used | |
| '(by\s+)?' | |
| # 4: the copyright holder. Don't allow multiple consecutive | |
| # spaces, so that right-margin gloss doesn't get caught | |
| # (e.g. gnat_ugn.texi). | |
| '(' + name + '(?:\s?' + name + ')*)?') | |
| # A regexp for notices that might have slipped by. Just matching | |
| # 'copyright' is too noisy, and 'copyright.*[0-9]' falls foul of | |
| # HTML header markers, so check for 'copyright' and two digits. | |
| self.other_copyright_re = re.compile ('(^|[^\._])copyright[^=]*[0-9][0-9]', | |
| re.IGNORECASE) | |
| self.comment_re = re.compile('#+|[*]+|;+|%+|//+|@c |dnl ') | |
| self.holders = { '@copying': '@copying' } | |
| self.holder_prefixes = set() | |
| # True to 'quilt add' files before changing them. | |
| self.use_quilt = False | |
| # If set, force all notices to include this year. | |
| self.max_year = None | |
| # Goes after the year(s). Could be ', '. | |
| self.separator = ' ' | |
| def add_package_author (self, holder, canon_form = None): | |
| if not canon_form: | |
| canon_form = holder | |
| self.holders[holder] = canon_form | |
| index = holder.find (' ') | |
| while index >= 0: | |
| self.holder_prefixes.add (holder[:index]) | |
| index = holder.find (' ', index + 1) | |
| def add_external_author (self, holder): | |
| self.holders[holder] = None | |
| class BadYear (Exception): | |
| def __init__ (self, year): | |
| self.year = year | |
| def __str__ (self): | |
| return 'unrecognised year: ' + self.year | |
| def parse_year (self, string): | |
| year = int (string) | |
| if len (string) == 2: | |
| if year > 70: | |
| return year + 1900 | |
| elif len (string) == 4: | |
| return year | |
| raise self.BadYear (string) | |
| def year_range (self, years): | |
| year_list = [self.parse_year (year) | |
| for year in self.year_re.findall (years)] | |
| assert len (year_list) > 0 | |
| return (min (year_list), max (year_list)) | |
| def set_use_quilt (self, use_quilt): | |
| self.use_quilt = use_quilt | |
| def include_year (self, year): | |
| assert not self.max_year | |
| self.max_year = year | |
| def canonicalise_years (self, dir, filename, filter, years): | |
| # Leave texinfo variables alone. | |
| if years.startswith ('@value'): | |
| return years | |
| (min_year, max_year) = self.year_range (years) | |
| # Update the upper bound, if enabled. | |
| if self.max_year and not filter.is_fossilised_file (dir, filename): | |
| max_year = max (max_year, self.max_year) | |
| # Use a range. | |
| if min_year == max_year: | |
| return '%d' % min_year | |
| else: | |
| return '%d-%d' % (min_year, max_year) | |
| def strip_continuation (self, line): | |
| line = line.lstrip() | |
| match = self.comment_re.match (line) | |
| if match: | |
| line = line[match.end():].lstrip() | |
| return line | |
| def is_complete (self, match): | |
| holder = match.group (4) | |
| return (holder | |
| and (holder not in self.holder_prefixes | |
| or holder in self.holders)) | |
| def update_copyright (self, dir, filename, filter, file, line, match): | |
| orig_line = line | |
| next_line = None | |
| pathname = os.path.join (dir, filename) | |
| intro = match.group (1) | |
| if intro.startswith ('@set'): | |
| # Texinfo year variables should always be on one line | |
| after_years = line[match.end (2):].strip() | |
| if after_years != '': | |
| self.errors.report (pathname, | |
| 'trailing characters in @set: ' | |
| + after_years) | |
| return (False, orig_line, next_line) | |
| else: | |
| # If it looks like the copyright is incomplete, add the next line. | |
| while not self.is_complete (match): | |
| try: | |
| next_line = file.readline() | |
| except StopIteration: | |
| break | |
| # If the next line doesn't look like a proper continuation, | |
| # assume that what we've got is complete. | |
| continuation = self.strip_continuation (next_line) | |
| if not self.continuation_re.match (continuation): | |
| break | |
| # Merge the lines for matching purposes. | |
| orig_line += next_line | |
| line = line.rstrip() + ' ' + continuation | |
| next_line = None | |
| # Rematch with the longer line, at the original position. | |
| match = self.copyright_re.match (line, match.start()) | |
| assert match | |
| holder = match.group (4) | |
| # Use the filter to test cases where markup is getting in the way. | |
| if filter.by_package_author (dir, filename): | |
| assert holder not in self.holders | |
| elif not holder: | |
| self.errors.report (pathname, 'missing copyright holder') | |
| return (False, orig_line, next_line) | |
| elif holder not in self.holders: | |
| self.errors.report (pathname, | |
| 'unrecognised copyright holder: ' + holder) | |
| return (False, orig_line, next_line) | |
| else: | |
| # See whether the copyright is associated with the package | |
| # author. | |
| canon_form = self.holders[holder] | |
| if not canon_form: | |
| return (False, orig_line, next_line) | |
| # Make sure the author is given in a consistent way. | |
| line = (line[:match.start (4)] | |
| + canon_form | |
| + line[match.end (4):]) | |
| # Remove any 'by' | |
| line = line[:match.start (3)] + line[match.end (3):] | |
| # Update the copyright years. | |
| years = match.group (2).strip() | |
| if (self.max_year | |
| and match.start(0) > 0 and line[match.start(0)-1] == '"' | |
| and not filter.is_fossilised_file (dir, filename)): | |
| # A printed copyright date consists of the current year | |
| canon_form = '%d' % self.max_year | |
| else: | |
| try: | |
| canon_form = self.canonicalise_years (dir, filename, filter, years) | |
| except self.BadYear as e: | |
| self.errors.report (pathname, str (e)) | |
| return (False, orig_line, next_line) | |
| line = (line[:match.start (2)] | |
| + ' ' + canon_form + self.separator | |
| + line[match.end (2):]) | |
| # Use the standard (C) form. | |
| if intro.endswith ('right'): | |
| intro += ' (C)' | |
| elif intro.endswith ('(c)'): | |
| intro = intro[:-3] + '(C)' | |
| line = line[:match.start (1)] + intro + line[match.end (1):] | |
| # Strip trailing whitespace | |
| line = line.rstrip() + '\n' | |
| return (line != orig_line, line, next_line) | |
| def guess_encoding (self, pathname): | |
| for encoding in ('utf8', 'iso8859'): | |
| try: | |
| open(pathname, 'r', encoding=encoding).read() | |
| return encoding | |
| except UnicodeDecodeError: | |
| pass | |
| return None | |
| def process_file (self, dir, filename, filter): | |
| pathname = os.path.join (dir, filename) | |
| if filename.endswith ('.tmp'): | |
| # Looks like something we tried to create before. | |
| try: | |
| os.remove (pathname) | |
| except OSError: | |
| pass | |
| return | |
| lines = [] | |
| changed = False | |
| line_filter = filter.get_line_filter (dir, filename) | |
| mode = None | |
| encoding = self.guess_encoding(pathname) | |
| with open (pathname, 'r', encoding=encoding) as file: | |
| prev = None | |
| mode = os.fstat (file.fileno()).st_mode | |
| for line in file: | |
| while line: | |
| next_line = None | |
| # Leave filtered-out lines alone. | |
| if not (line_filter and line_filter.match (line)): | |
| match = self.copyright_re.search (line) | |
| if match: | |
| res = self.update_copyright (dir, filename, filter, | |
| file, line, match) | |
| (this_changed, line, next_line) = res | |
| changed = changed or this_changed | |
| # Check for copyright lines that might have slipped by. | |
| elif self.other_copyright_re.search (line): | |
| self.errors.report (pathname, | |
| 'unrecognised copyright: %s' | |
| % line.strip()) | |
| lines.append (line) | |
| line = next_line | |
| # If something changed, write the new file out. | |
| if changed and self.errors.ok(): | |
| tmp_pathname = pathname + '.tmp' | |
| with open (tmp_pathname, 'w', encoding=encoding) as file: | |
| for line in lines: | |
| file.write (line) | |
| os.fchmod (file.fileno(), mode) | |
| if self.use_quilt: | |
| subprocess.call (['quilt', 'add', pathname]) | |
| os.rename (tmp_pathname, pathname) | |
| def process_tree (self, tree, filter): | |
| for (dir, subdirs, filenames) in os.walk (tree): | |
| # Don't recurse through directories that should be skipped. | |
| for i in range (len (subdirs) - 1, -1, -1): | |
| if filter.skip_dir (dir, subdirs[i]): | |
| del subdirs[i] | |
| # Handle the files in this directory. | |
| for filename in filenames: | |
| if filter.skip_file (dir, filename): | |
| sys.stdout.write ('Skipping %s\n' | |
| % os.path.join (dir, filename)) | |
| else: | |
| self.process_file (dir, filename, filter) | |
| class CmdLine: | |
| def __init__ (self, copyright = Copyright): | |
| self.errors = Errors() | |
| self.copyright = copyright (self.errors) | |
| self.dirs = [] | |
| self.default_dirs = [] | |
| self.chosen_dirs = [] | |
| self.option_handlers = dict() | |
| self.option_help = [] | |
| self.add_option ('--help', 'Print this help', self.o_help) | |
| self.add_option ('--quilt', '"quilt add" files before changing them', | |
| self.o_quilt) | |
| self.add_option ('--this-year', 'Add the current year to every notice', | |
| self.o_this_year) | |
| def add_option (self, name, help, handler): | |
| self.option_help.append ((name, help)) | |
| self.option_handlers[name] = handler | |
| def add_dir (self, dir, filter = GenericFilter()): | |
| self.dirs.append ((dir, filter)) | |
| def o_help (self, option = None): | |
| sys.stdout.write ('Usage: %s [options] dir1 dir2...\n\n' | |
| 'Options:\n' % sys.argv[0]) | |
| format = '%-15s %s\n' | |
| for (what, help) in self.option_help: | |
| sys.stdout.write (format % (what, help)) | |
| sys.stdout.write ('\nDirectories:\n') | |
| format = '%-25s' | |
| i = 0 | |
| for (dir, filter) in self.dirs: | |
| i += 1 | |
| if i % 3 == 0 or i == len (self.dirs): | |
| sys.stdout.write (dir + '\n') | |
| else: | |
| sys.stdout.write (format % dir) | |
| sys.exit (0) | |
| def o_quilt (self, option): | |
| self.copyright.set_use_quilt (True) | |
| def o_this_year (self, option): | |
| self.copyright.include_year (time.localtime().tm_year) | |
| def main (self): | |
| for arg in sys.argv[1:]: | |
| if arg[:1] != '-': | |
| self.chosen_dirs.append (arg) | |
| elif arg in self.option_handlers: | |
| self.option_handlers[arg] (arg) | |
| else: | |
| self.errors.report (None, 'unrecognised option: ' + arg) | |
| if self.errors.ok(): | |
| if len (self.chosen_dirs) == 0: | |
| self.chosen_dirs = self.default_dirs | |
| if len (self.chosen_dirs) == 0: | |
| self.o_help() | |
| else: | |
| for chosen_dir in self.chosen_dirs: | |
| canon_dir = os.path.join (chosen_dir, '') | |
| count = 0 | |
| for (dir, filter) in self.dirs: | |
| if (dir + os.sep).startswith (canon_dir): | |
| count += 1 | |
| self.copyright.process_tree (dir, filter) | |
| if count == 0: | |
| self.errors.report (None, 'unrecognised directory: ' | |
| + chosen_dir) | |
| sys.exit (0 if self.errors.ok() else 1) | |
| #---------------------------------------------------------------------------- | |
| class TopLevelFilter (GenericFilter): | |
| def skip_dir (self, dir, subdir): | |
| return True | |
| class ConfigFilter (GenericFilter): | |
| def __init__ (self): | |
| GenericFilter.__init__ (self) | |
| def skip_file (self, dir, filename): | |
| if filename.endswith ('.m4'): | |
| pathname = os.path.join (dir, filename) | |
| with open (pathname) as file: | |
| # Skip files imported from gettext. | |
| if file.readline().find ('gettext-') >= 0: | |
| return True | |
| return GenericFilter.skip_file (self, dir, filename) | |
| class LdFilter (GenericFilter): | |
| def __init__ (self): | |
| GenericFilter.__init__ (self) | |
| self.skip_extensions |= set ([ | |
| # ld testsuite output match files. | |
| '.ro', | |
| ]) | |
| class BinutilsCopyright (Copyright): | |
| def __init__ (self, errors): | |
| Copyright.__init__ (self, errors) | |
| canon_fsf = 'Free Software Foundation, Inc.' | |
| self.add_package_author ('Free Software Foundation', canon_fsf) | |
| self.add_package_author ('Free Software Foundation.', canon_fsf) | |
| self.add_package_author ('Free Software Foundation Inc.', canon_fsf) | |
| self.add_package_author ('Free Software Foundation, Inc', canon_fsf) | |
| self.add_package_author ('Free Software Foundation, Inc.', canon_fsf) | |
| self.add_package_author ('The Free Software Foundation', canon_fsf) | |
| self.add_package_author ('The Free Software Foundation, Inc.', canon_fsf) | |
| self.add_package_author ('Software Foundation, Inc.', canon_fsf) | |
| self.add_external_author ('Carnegie Mellon University') | |
| self.add_external_author ('John D. Polstra.') | |
| self.add_external_author ('Innovative Computing Labs') | |
| self.add_external_author ('Linaro Ltd.') | |
| self.add_external_author ('MIPS Computer Systems, Inc.') | |
| self.add_external_author ('Red Hat Inc.') | |
| self.add_external_author ('Regents of the University of California.') | |
| self.add_external_author ('The Regents of the University of California.') | |
| self.add_external_author ('Third Eye Software, Inc.') | |
| self.add_external_author ('Ulrich Drepper') | |
| self.add_external_author ('Synopsys Inc.') | |
| class BinutilsCmdLine (CmdLine): | |
| def __init__ (self): | |
| CmdLine.__init__ (self, BinutilsCopyright) | |
| self.add_dir ('.', TopLevelFilter()) | |
| self.add_dir ('bfd') | |
| self.add_dir ('binutils') | |
| self.add_dir ('config', ConfigFilter()) | |
| self.add_dir ('cpu') | |
| self.add_dir ('elfcpp') | |
| self.add_dir ('etc') | |
| self.add_dir ('gas') | |
| self.add_dir ('gdb') | |
| self.add_dir ('gdbserver') | |
| self.add_dir ('gdbsupport') | |
| self.add_dir ('gold') | |
| self.add_dir ('gprof') | |
| self.add_dir ('gprofng') | |
| self.add_dir ('include') | |
| self.add_dir ('ld', LdFilter()) | |
| self.add_dir ('libbacktrace') | |
| self.add_dir ('libctf') | |
| self.add_dir ('libdecnumber') | |
| self.add_dir ('libiberty') | |
| self.add_dir ('libsframe') | |
| self.add_dir ('opcodes') | |
| self.add_dir ('readline') | |
| self.add_dir ('sim') | |
| self.default_dirs = [ | |
| 'bfd', | |
| 'binutils', | |
| 'elfcpp', | |
| 'etc', | |
| 'gas', | |
| 'gold', | |
| 'gprof', | |
| 'include', | |
| 'ld', | |
| 'libctf', | |
| 'libiberty', | |
| 'libsframe', | |
| 'opcodes', | |
| ] | |
| BinutilsCmdLine().main() |