mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-21 01:12:32 +08:00
a2c5833233
The result of running etc/update-copyright.py --this-year, fixing all the files whose mode is changed by the script, plus a build with --enable-maintainer-mode --enable-cgen-maint=yes, then checking out */po/*.pot which we don't update frequently. The copy of cgen was with commit d1dd5fcc38ead reverted as that commit breaks building of bfp opcodes files.
623 lines
22 KiB
Python
Executable File
623 lines
22 KiB
Python
Executable File
#!/usr/bin/python
|
|
#
|
|
# Copyright (C) 2013-2022 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.pl --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.pl --this-year libjava
|
|
#
|
|
# would run the script on just libjava/.
|
|
#
|
|
# 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()
|
|
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():
|
|
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.next()
|
|
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 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)
|
|
with open (pathname, 'r') as file:
|
|
prev = None
|
|
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') as file:
|
|
for line in lines:
|
|
file.write (line)
|
|
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 xrange (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 ('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 ('gold')
|
|
self.add_dir ('gprof')
|
|
self.add_dir ('include')
|
|
self.add_dir ('ld', LdFilter())
|
|
self.add_dir ('libctf')
|
|
self.add_dir ('libdecnumber')
|
|
self.add_dir ('libiberty')
|
|
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',
|
|
'opcodes',
|
|
]
|
|
|
|
BinutilsCmdLine().main()
|