Initial revision
This commit is contained in:
Guido van Rossum
parent
bc9231a3f6
commit
1d28e1707a
|
|
@ -0,0 +1,314 @@
|
|||
#! /ufs/guido/bin/sgi/python
|
||||
#! /usr/local/bin/python
|
||||
|
||||
# This file contains a class and a main program that perform two
|
||||
# related (though complimentary) formatting operations on Python
|
||||
# programs. When called as "pindend -c", it takes a valid Python
|
||||
# program as input and outputs a version augmented with block-closing
|
||||
# comments. When called as "pindent -r" it assumes its input is a
|
||||
# Python program with block-closing comments but with its indentation
|
||||
# messed up, and outputs a properly indented version.
|
||||
|
||||
# A "block-closing comment" is a comment of the form '# end <keyword>'
|
||||
# where <keyword> is the keyword that opened the block. If the
|
||||
# opening keyword is 'def' or 'class', the function or class name may
|
||||
# be repeated in the block-closing comment as well. Here is an
|
||||
# example of a program fully augmented with block-closing comments:
|
||||
|
||||
# def foobar(a, b):
|
||||
# if a == b:
|
||||
# a = a+1
|
||||
# elif a < b:
|
||||
# b = b-1
|
||||
# if b > a: a = a-1
|
||||
# # end if
|
||||
# else:
|
||||
# print 'oops!'
|
||||
# # end if
|
||||
# # end def foobar
|
||||
|
||||
# Note that only the last part of an if...elif...else... block needs a
|
||||
# block-closing comment; the same is true for other compound
|
||||
# statements (e.g. try...except). Also note that "short-form" blocks
|
||||
# like the second 'if' in the example must be closed as well;
|
||||
# otherwise the 'else' in the example would be ambiguous (remember
|
||||
# that indentation is not significant when interpreting block-closing
|
||||
# comments).
|
||||
|
||||
# Both operations are idempotent (i.e. applied to their own output
|
||||
# they yield an identical result). Running first "pindent -c" and
|
||||
# then "pindent -r" on a valid Python program produces a program that
|
||||
# is semantically identical to the input (though its indentation may
|
||||
# be different).
|
||||
|
||||
# Other options:
|
||||
# -s stepsize: set the indentation step size (default 8)
|
||||
# -t tabsize : set the number of spaces a tab character is worth (default 8)
|
||||
# file ... : input file(s) (default standard input)
|
||||
# The results always go to standard output
|
||||
|
||||
# Caveats:
|
||||
# - comments ending in a backslash will be mistaken for continued lines
|
||||
# - continuations using backslash are always left unchanged
|
||||
# - continuations inside parentheses are not extra indented by -r
|
||||
# but must be indented for -c to work correctly (this breaks
|
||||
# idempotency!)
|
||||
# - continued lines inside triple-quoted strings are totally garbled
|
||||
|
||||
# Secret feature:
|
||||
# - On input, a block may also be closed with an "end statement" --
|
||||
# this is a block-closing comment without the '#' sign.
|
||||
|
||||
# Possible improvements:
|
||||
# - check syntax based on transitions in 'next' table
|
||||
# - better error reporting
|
||||
# - better error recovery
|
||||
# - check identifier after class/def
|
||||
|
||||
# The following wishes need a more complete tokenization of the source:
|
||||
# - Don't get fooled by comments ending in backslash
|
||||
# - reindent continuation lines indicated by backslash
|
||||
# - handle continuation lines inside parentheses/braces/brackets
|
||||
# - handle triple quoted strings spanning lines
|
||||
# - realign comments
|
||||
# - optionally do much more thorough reformatting, a la C indent
|
||||
|
||||
import os
|
||||
import regex
|
||||
import string
|
||||
import sys
|
||||
|
||||
next = {}
|
||||
next['if'] = next['elif'] = 'elif', 'else', 'end'
|
||||
next['while'] = next['for'] = 'else', 'end'
|
||||
next['try'] = 'except', 'finally'
|
||||
next['except'] = 'except', 'else', 'end'
|
||||
next['else'] = next['finally'] = next['def'] = next['class'] = 'end'
|
||||
next['end'] = ()
|
||||
start = 'if', 'while', 'for', 'try', 'def', 'class'
|
||||
|
||||
class PythonIndenter:
|
||||
|
||||
def __init__(self, fpi = sys.stdin, fpo = sys.stdout,
|
||||
indentsize = 8, tabsize = 8):
|
||||
self.fpi = fpi
|
||||
self.fpo = fpo
|
||||
self.indentsize = indentsize
|
||||
self.tabsize = tabsize
|
||||
self.lineno = 0
|
||||
self.write = fpo.write
|
||||
self.kwprog = regex.symcomp(
|
||||
'^[ \t]*\(<kw>[a-z]+\)'
|
||||
'\([ \t]+\(<id>[a-zA-Z_][a-zA-Z0-9_]*\)\)?'
|
||||
'[^a-zA-Z0-9_]')
|
||||
self.endprog = regex.symcomp(
|
||||
'^[ \t]*#?[ \t]*end[ \t]+\(<kw>[a-z]+\)'
|
||||
'\([ \t]+\(<id>[a-zA-Z_][a-zA-Z0-9_]*\)\)?'
|
||||
'[^a-zA-Z0-9_]')
|
||||
self.wsprog = regex.compile('^[ \t]*')
|
||||
# end def __init__
|
||||
|
||||
def readline(self):
|
||||
line = self.fpi.readline()
|
||||
if line: self.lineno = self.lineno + 1
|
||||
# end if
|
||||
return line
|
||||
# end def readline
|
||||
|
||||
def error(self, fmt, *args):
|
||||
if args: fmt = fmt % args
|
||||
# end if
|
||||
sys.stderr.write('Error at line %d: %s\n' % (self.lineno, fmt))
|
||||
self.write('### %s ###\n' % fmt)
|
||||
# end def error
|
||||
|
||||
def getline(self):
|
||||
line = self.readline()
|
||||
while line[-2:] == '\\\n':
|
||||
line2 = self.readline()
|
||||
if not line2: break
|
||||
# end if
|
||||
line = line + line2
|
||||
# end while
|
||||
return line
|
||||
# end def getline
|
||||
|
||||
def putline(self, line, indent = None):
|
||||
if indent is None:
|
||||
self.write(line)
|
||||
return
|
||||
# end if
|
||||
tabs, spaces = divmod(indent*self.indentsize, self.tabsize)
|
||||
i = max(0, self.wsprog.match(line))
|
||||
self.write('\t'*tabs + ' '*spaces + line[i:])
|
||||
# end def putline
|
||||
|
||||
def reformat(self):
|
||||
stack = []
|
||||
while 1:
|
||||
line = self.getline()
|
||||
if not line: break # EOF
|
||||
# end if
|
||||
if self.endprog.match(line) >= 0:
|
||||
kw = 'end'
|
||||
kw2 = self.endprog.group('kw')
|
||||
if not stack:
|
||||
self.error('unexpected end')
|
||||
elif stack[-1][0] != kw2:
|
||||
self.error('unmatched end')
|
||||
# end if
|
||||
del stack[-1:]
|
||||
self.putline(line, len(stack))
|
||||
continue
|
||||
# end if
|
||||
if self.kwprog.match(line) >= 0:
|
||||
kw = self.kwprog.group('kw')
|
||||
if kw in start:
|
||||
self.putline(line, len(stack))
|
||||
stack.append((kw, kw))
|
||||
continue
|
||||
# end if
|
||||
if next.has_key(kw) and stack:
|
||||
self.putline(line, len(stack)-1)
|
||||
kwa, kwb = stack[-1]
|
||||
stack[-1] = kwa, kw
|
||||
continue
|
||||
# end if
|
||||
# end if
|
||||
self.putline(line, len(stack))
|
||||
# end while
|
||||
if stack:
|
||||
self.error('unterminated keywords')
|
||||
for kwa, kwb in stack:
|
||||
self.write('\t%s\n' % kwa)
|
||||
# end for
|
||||
# end if
|
||||
# end def reformat
|
||||
|
||||
def complete(self):
|
||||
self.indentsize = 1
|
||||
stack = []
|
||||
todo = []
|
||||
current, firstkw, lastkw, topid = 0, '', '', ''
|
||||
while 1:
|
||||
line = self.getline()
|
||||
i = max(0, self.wsprog.match(line))
|
||||
if self.endprog.match(line) >= 0:
|
||||
thiskw = 'end'
|
||||
endkw = self.endprog.group('kw')
|
||||
thisid = self.endprog.group('id')
|
||||
elif self.kwprog.match(line) >= 0:
|
||||
thiskw = self.kwprog.group('kw')
|
||||
if not next.has_key(thiskw):
|
||||
thiskw = ''
|
||||
# end if
|
||||
if thiskw in ('def', 'class'):
|
||||
thisid = self.kwprog.group('id')
|
||||
else:
|
||||
thisid = ''
|
||||
# end if
|
||||
elif line[i:i+1] in ('\n', '#'):
|
||||
todo.append(line)
|
||||
continue
|
||||
else:
|
||||
thiskw = ''
|
||||
# end if
|
||||
indent = len(string.expandtabs(line[:i], self.tabsize))
|
||||
while indent < current:
|
||||
if firstkw:
|
||||
if topid:
|
||||
s = '# end %s %s\n' % (
|
||||
firstkw, topid)
|
||||
else:
|
||||
s = '# end %s\n' % firstkw
|
||||
# end if
|
||||
self.putline(s, current)
|
||||
firstkw = lastkw = ''
|
||||
# end if
|
||||
current, firstkw, lastkw, topid = stack[-1]
|
||||
del stack[-1]
|
||||
# end while
|
||||
if indent == current and firstkw:
|
||||
if thiskw == 'end':
|
||||
if endkw != firstkw:
|
||||
self.error('mismatched end')
|
||||
# end if
|
||||
firstkw = lastkw = ''
|
||||
elif not thiskw or thiskw in start:
|
||||
if topid:
|
||||
s = '# end %s %s\n' % (
|
||||
firstkw, topid)
|
||||
else:
|
||||
s = '# end %s\n' % firstkw
|
||||
# end if
|
||||
self.putline(s, current)
|
||||
firstkw = lastkw = topid = ''
|
||||
# end if
|
||||
# end if
|
||||
if indent > current:
|
||||
stack.append(current, firstkw, lastkw, topid)
|
||||
if thiskw and thiskw not in start:
|
||||
# error
|
||||
thiskw = ''
|
||||
# end if
|
||||
current, firstkw, lastkw, topid = \
|
||||
indent, thiskw, thiskw, thisid
|
||||
# end if
|
||||
if thiskw:
|
||||
if thiskw in start:
|
||||
firstkw = lastkw = thiskw
|
||||
topid = thisid
|
||||
else:
|
||||
lastkw = thiskw
|
||||
# end if
|
||||
# end if
|
||||
for l in todo: self.write(l)
|
||||
# end for
|
||||
todo = []
|
||||
if not line: break
|
||||
# end if
|
||||
self.write(line)
|
||||
# end while
|
||||
# end def complete
|
||||
|
||||
# end class PythonIndenter
|
||||
|
||||
def test():
|
||||
import getopt
|
||||
opts, args = getopt.getopt(sys.argv[1:], 'crs:t:')
|
||||
action = None
|
||||
stepsize = 8
|
||||
tabsize = 8
|
||||
for o, a in opts:
|
||||
if o == '-c':
|
||||
action = PythonIndenter.complete
|
||||
elif o == '-r':
|
||||
action = PythonIndenter.reformat
|
||||
elif p == '-s':
|
||||
stepsize = string.atoi(a)
|
||||
elif p == '-t':
|
||||
tabsize = string.atoi(a)
|
||||
# end if
|
||||
# end for
|
||||
if not action:
|
||||
print 'You must specify -c(omplete) or -r(eformat)'
|
||||
sys.exit(2)
|
||||
# end if
|
||||
if not args: args = ['-']
|
||||
# end if
|
||||
for file in args:
|
||||
if file == '-':
|
||||
fp = sys.stdin
|
||||
else:
|
||||
fp = open(file, 'r')
|
||||
# end if
|
||||
pi = PythonIndenter(fp, sys.stdout, stepsize, tabsize)
|
||||
action(pi)
|
||||
if fp != sys.stdin: fp.close()
|
||||
# end if
|
||||
# end for
|
||||
# end def test
|
||||
|
||||
if __name__ == '__main__':
|
||||
test()
|
||||
# end if
|
||||
Loading…
Reference in New Issue