mirror of
https://github.com/python/cpython.git
synced 2024-12-01 03:01:36 +01:00
aaab30e00c
(with one small bugfix in bgen/bgen/scantools.py) This replaces string module functions with string methods for the stuff in the Tools directory. Several uses of string.letters etc. are still remaining.
318 lines
9.8 KiB
Python
Executable File
318 lines
9.8 KiB
Python
Executable File
#! /usr/bin/env python
|
|
|
|
# Perform massive identifier substitution on C source files.
|
|
# This actually tokenizes the files (to some extent) so it can
|
|
# avoid making substitutions inside strings or comments.
|
|
# Inside strings, substitutions are never made; inside comments,
|
|
# it is a user option (off by default).
|
|
#
|
|
# The substitutions are read from one or more files whose lines,
|
|
# when not empty, after stripping comments starting with #,
|
|
# must contain exactly two words separated by whitespace: the
|
|
# old identifier and its replacement.
|
|
#
|
|
# The option -r reverses the sense of the substitutions (this may be
|
|
# useful to undo a particular substitution).
|
|
#
|
|
# If the old identifier is prefixed with a '*' (with no intervening
|
|
# whitespace), then it will not be substituted inside comments.
|
|
#
|
|
# Command line arguments are files or directories to be processed.
|
|
# Directories are searched recursively for files whose name looks
|
|
# like a C file (ends in .h or .c). The special filename '-' means
|
|
# operate in filter mode: read stdin, write stdout.
|
|
#
|
|
# Symbolic links are always ignored (except as explicit directory
|
|
# arguments).
|
|
#
|
|
# The original files are kept as back-up with a "~" suffix.
|
|
#
|
|
# Changes made are reported to stdout in a diff-like format.
|
|
#
|
|
# NB: by changing only the function fixline() you can turn this
|
|
# into a program for different changes to C source files; by
|
|
# changing the function wanted() you can make a different selection of
|
|
# files.
|
|
|
|
import sys
|
|
import regex
|
|
import os
|
|
from stat import *
|
|
import getopt
|
|
|
|
err = sys.stderr.write
|
|
dbg = err
|
|
rep = sys.stdout.write
|
|
|
|
def usage():
|
|
progname = sys.argv[0]
|
|
err('Usage: ' + progname +
|
|
' [-c] [-r] [-s file] ... file-or-directory ...\n')
|
|
err('\n')
|
|
err('-c : substitute inside comments\n')
|
|
err('-r : reverse direction for following -s options\n')
|
|
err('-s substfile : add a file of substitutions\n')
|
|
err('\n')
|
|
err('Each non-empty non-comment line in a substitution file must\n')
|
|
err('contain exactly two words: an identifier and its replacement.\n')
|
|
err('Comments start with a # character and end at end of line.\n')
|
|
err('If an identifier is preceded with a *, it is not substituted\n')
|
|
err('inside a comment even when -c is specified.\n')
|
|
|
|
def main():
|
|
try:
|
|
opts, args = getopt.getopt(sys.argv[1:], 'crs:')
|
|
except getopt.error, msg:
|
|
err('Options error: ' + str(msg) + '\n')
|
|
usage()
|
|
sys.exit(2)
|
|
bad = 0
|
|
if not args: # No arguments
|
|
usage()
|
|
sys.exit(2)
|
|
for opt, arg in opts:
|
|
if opt == '-c':
|
|
setdocomments()
|
|
if opt == '-r':
|
|
setreverse()
|
|
if opt == '-s':
|
|
addsubst(arg)
|
|
for arg in args:
|
|
if os.path.isdir(arg):
|
|
if recursedown(arg): bad = 1
|
|
elif os.path.islink(arg):
|
|
err(arg + ': will not process symbolic links\n')
|
|
bad = 1
|
|
else:
|
|
if fix(arg): bad = 1
|
|
sys.exit(bad)
|
|
|
|
# Change this regular expression to select a different set of files
|
|
Wanted = '^[a-zA-Z0-9_]+\.[ch]$'
|
|
def wanted(name):
|
|
return regex.match(Wanted, name) >= 0
|
|
|
|
def recursedown(dirname):
|
|
dbg('recursedown(' + `dirname` + ')\n')
|
|
bad = 0
|
|
try:
|
|
names = os.listdir(dirname)
|
|
except os.error, msg:
|
|
err(dirname + ': cannot list directory: ' + str(msg) + '\n')
|
|
return 1
|
|
names.sort()
|
|
subdirs = []
|
|
for name in names:
|
|
if name in (os.curdir, os.pardir): continue
|
|
fullname = os.path.join(dirname, name)
|
|
if os.path.islink(fullname): pass
|
|
elif os.path.isdir(fullname):
|
|
subdirs.append(fullname)
|
|
elif wanted(name):
|
|
if fix(fullname): bad = 1
|
|
for fullname in subdirs:
|
|
if recursedown(fullname): bad = 1
|
|
return bad
|
|
|
|
def fix(filename):
|
|
## dbg('fix(' + `filename` + ')\n')
|
|
if filename == '-':
|
|
# Filter mode
|
|
f = sys.stdin
|
|
g = sys.stdout
|
|
else:
|
|
# File replacement mode
|
|
try:
|
|
f = open(filename, 'r')
|
|
except IOError, msg:
|
|
err(filename + ': cannot open: ' + str(msg) + '\n')
|
|
return 1
|
|
head, tail = os.path.split(filename)
|
|
tempname = os.path.join(head, '@' + tail)
|
|
g = None
|
|
# If we find a match, we rewind the file and start over but
|
|
# now copy everything to a temp file.
|
|
lineno = 0
|
|
initfixline()
|
|
while 1:
|
|
line = f.readline()
|
|
if not line: break
|
|
lineno = lineno + 1
|
|
while line[-2:] == '\\\n':
|
|
nextline = f.readline()
|
|
if not nextline: break
|
|
line = line + nextline
|
|
lineno = lineno + 1
|
|
newline = fixline(line)
|
|
if newline != line:
|
|
if g is None:
|
|
try:
|
|
g = open(tempname, 'w')
|
|
except IOError, msg:
|
|
f.close()
|
|
err(tempname+': cannot create: '+
|
|
str(msg)+'\n')
|
|
return 1
|
|
f.seek(0)
|
|
lineno = 0
|
|
initfixline()
|
|
rep(filename + ':\n')
|
|
continue # restart from the beginning
|
|
rep(`lineno` + '\n')
|
|
rep('< ' + line)
|
|
rep('> ' + newline)
|
|
if g is not None:
|
|
g.write(newline)
|
|
|
|
# End of file
|
|
if filename == '-': return 0 # Done in filter mode
|
|
f.close()
|
|
if not g: return 0 # No changes
|
|
|
|
# Finishing touch -- move files
|
|
|
|
# First copy the file's mode to the temp file
|
|
try:
|
|
statbuf = os.stat(filename)
|
|
os.chmod(tempname, statbuf[ST_MODE] & 07777)
|
|
except os.error, msg:
|
|
err(tempname + ': warning: chmod failed (' + str(msg) + ')\n')
|
|
# Then make a backup of the original file as filename~
|
|
try:
|
|
os.rename(filename, filename + '~')
|
|
except os.error, msg:
|
|
err(filename + ': warning: backup failed (' + str(msg) + ')\n')
|
|
# Now move the temp file to the original file
|
|
try:
|
|
os.rename(tempname, filename)
|
|
except os.error, msg:
|
|
err(filename + ': rename failed (' + str(msg) + ')\n')
|
|
return 1
|
|
# Return succes
|
|
return 0
|
|
|
|
# Tokenizing ANSI C (partly)
|
|
|
|
Identifier = '\(struct \)?[a-zA-Z_][a-zA-Z0-9_]+'
|
|
String = '"\([^\n\\"]\|\\\\.\)*"'
|
|
Char = '\'\([^\n\\\']\|\\\\.\)*\''
|
|
CommentStart = '/\*'
|
|
CommentEnd = '\*/'
|
|
|
|
Hexnumber = '0[xX][0-9a-fA-F]*[uUlL]*'
|
|
Octnumber = '0[0-7]*[uUlL]*'
|
|
Decnumber = '[1-9][0-9]*[uUlL]*'
|
|
Intnumber = Hexnumber + '\|' + Octnumber + '\|' + Decnumber
|
|
Exponent = '[eE][-+]?[0-9]+'
|
|
Pointfloat = '\([0-9]+\.[0-9]*\|\.[0-9]+\)\(' + Exponent + '\)?'
|
|
Expfloat = '[0-9]+' + Exponent
|
|
Floatnumber = Pointfloat + '\|' + Expfloat
|
|
Number = Floatnumber + '\|' + Intnumber
|
|
|
|
# Anything else is an operator -- don't list this explicitly because of '/*'
|
|
|
|
OutsideComment = (Identifier, Number, String, Char, CommentStart)
|
|
OutsideCommentPattern = '\(' + '\|'.join(OutsideComment) + '\)'
|
|
OutsideCommentProgram = regex.compile(OutsideCommentPattern)
|
|
|
|
InsideComment = (Identifier, Number, CommentEnd)
|
|
InsideCommentPattern = '\(' + '\|'.join(InsideComment) + '\)'
|
|
InsideCommentProgram = regex.compile(InsideCommentPattern)
|
|
|
|
def initfixline():
|
|
global Program
|
|
Program = OutsideCommentProgram
|
|
|
|
def fixline(line):
|
|
global Program
|
|
## print '-->', `line`
|
|
i = 0
|
|
while i < len(line):
|
|
i = Program.search(line, i)
|
|
if i < 0: break
|
|
found = Program.group(0)
|
|
## if Program is InsideCommentProgram: print '...',
|
|
## else: print ' ',
|
|
## print found
|
|
if len(found) == 2:
|
|
if found == '/*':
|
|
Program = InsideCommentProgram
|
|
elif found == '*/':
|
|
Program = OutsideCommentProgram
|
|
n = len(found)
|
|
if Dict.has_key(found):
|
|
subst = Dict[found]
|
|
if Program is InsideCommentProgram:
|
|
if not Docomments:
|
|
print 'Found in comment:', found
|
|
i = i + n
|
|
continue
|
|
if NotInComment.has_key(found):
|
|
## print 'Ignored in comment:',
|
|
## print found, '-->', subst
|
|
## print 'Line:', line,
|
|
subst = found
|
|
## else:
|
|
## print 'Substituting in comment:',
|
|
## print found, '-->', subst
|
|
## print 'Line:', line,
|
|
line = line[:i] + subst + line[i+n:]
|
|
n = len(subst)
|
|
i = i + n
|
|
return line
|
|
|
|
Docomments = 0
|
|
def setdocomments():
|
|
global Docomments
|
|
Docomments = 1
|
|
|
|
Reverse = 0
|
|
def setreverse():
|
|
global Reverse
|
|
Reverse = (not Reverse)
|
|
|
|
Dict = {}
|
|
NotInComment = {}
|
|
def addsubst(substfile):
|
|
try:
|
|
fp = open(substfile, 'r')
|
|
except IOError, msg:
|
|
err(substfile + ': cannot read substfile: ' + str(msg) + '\n')
|
|
sys.exit(1)
|
|
lineno = 0
|
|
while 1:
|
|
line = fp.readline()
|
|
if not line: break
|
|
lineno = lineno + 1
|
|
try:
|
|
i = line.index('#')
|
|
except ValueError:
|
|
i = -1 # Happens to delete trailing \n
|
|
words = line[:i].split()
|
|
if not words: continue
|
|
if len(words) == 3 and words[0] == 'struct':
|
|
words[:2] = [words[0] + ' ' + words[1]]
|
|
elif len(words) <> 2:
|
|
err(substfile + ':' + `lineno` +
|
|
': warning: bad line: ' + line)
|
|
continue
|
|
if Reverse:
|
|
[value, key] = words
|
|
else:
|
|
[key, value] = words
|
|
if value[0] == '*':
|
|
value = value[1:]
|
|
if key[0] == '*':
|
|
key = key[1:]
|
|
NotInComment[key] = value
|
|
if Dict.has_key(key):
|
|
err(substfile + ':' + `lineno` +
|
|
': warning: overriding: ' +
|
|
key + ' ' + value + '\n')
|
|
err(substfile + ':' + `lineno` +
|
|
': warning: previous: ' + Dict[key] + '\n')
|
|
Dict[key] = value
|
|
fp.close()
|
|
|
|
main()
|