util/sort_includes.py

   1 #!/usr/bin/env python
   2
   3 import os
   4 import re
   5 import sys
   6
   7 from file_types import *
   8
   9 cpp_c_headers = {
  10     'assert.h' : 'cassert',
  11     'ctype.h'  : 'cctype',
  12     'errno.h'  : 'cerrno',
  13     'float.h'  : 'cfloat',
  14     'limits.h' : 'climits',
  15     'locale.h' : 'clocale',
  16     'math.h'   : 'cmath',
  17     'setjmp.h' : 'csetjmp',
  18     'signal.h' : 'csignal',
  19     'stdarg.h' : 'cstdarg',
  20     'stddef.h' : 'cstddef',
  21     'stdio.h'  : 'cstdio',
  22     'stdlib.h' : 'cstdlib',
  23     'string.h' : 'cstring',
  24     'time.h'   : 'ctime',
  25     'wchar.h'  : 'cwchar',
  26     'wctype.h' : 'cwctype',
  27 }
  28
  29 include_re = re.compile(r'([#%])(include|import).*[<"](.*)[">]')
  30 def include_key(line):
  31     '''Mark directories with a leading space so directories
  32     are sorted before files'''
  33
  34     match = include_re.match(line)
  35     assert match, line
  36     keyword = match.group(2)
  37     include = match.group(3)
  38
  39     # Everything but the file part needs to have a space prepended
  40     parts = include.split('/')
  41     if len(parts) == 2 and parts[0] == 'dnet':
  42         # Don't sort the dnet includes with respect to each other, but
  43         # make them sorted with respect to non dnet includes.  Python
  44         # guarantees that sorting is stable, so just clear the
  45         # basename part of the filename.
  46         parts[1] = ' '
  47     parts[0:-1] = [ ' ' + s for s in parts[0:-1] ]
  48     key = '/'.join(parts)
  49
  50     return key
  51
  52 class SortIncludes(object):
  53     # different types of includes for different sorting of headers
  54     # <Python.h>         - Python header needs to be first if it exists
  55     # <*.h>              - system headers (directories before files)
  56     # <*>                - STL headers
  57     # <*.(hh|hxx|hpp|H)> - C++ Headers (directories before files)
  58     # "*"                - M5 headers (directories before files)
  59     includes_re = (
  60         ('python', '<>', r'^(#include)[ \t]+<(Python.*\.h)>(.*)'),
  61         ('c', '<>', r'^(#include)[ \t]<(.+\.h)>(.*)'),
  62         ('stl', '<>', r'^(#include)[ \t]+<([0-9A-z_]+)>(.*)'),
  63         ('cc', '<>', r'^(#include)[ \t]+<([0-9A-z_]+\.(hh|hxx|hpp|H))>(.*)'),
  64         ('m5cc', '""', r'^(#include)[ \t]"(.+\.h{1,2})"(.*)'),
  65         ('swig0', '<>', r'^(%import)[ \t]<(.+)>(.*)'),
  66         ('swig1', '<>', r'^(%include)[ \t]<(.+)>(.*)'),
  67         ('swig2', '""', r'^(%import)[ \t]"(.+)"(.*)'),
  68         ('swig3', '""', r'^(%include)[ \t]"(.+)"(.*)'),
  69         )
  70
  71     # compile the regexes
  72     includes_re = tuple((a, b, re.compile(c)) for a,b,c in includes_re)
  73
  74     def __init__(self):
  75         pass
  76
  77     def reset(self):
  78         # clear all stored headers
  79         self.includes = {}
  80         for include_type,_,_ in self.includes_re:
  81             self.includes[include_type] = []
  82
  83     def dump_block(self):
  84         '''dump the includes'''
  85         first = True
  86         for include,_,_ in self.includes_re:
  87             if not self.includes[include]:
  88                 continue
  89
  90             if not first:
  91                 # print a newline between groups of
  92                 # include types
  93                 yield ''
  94             first = False
  95
  96             # print out the includes in the current group
  97             # and sort them according to include_key()
  98             prev = None
  99             for l in sorted(self.includes[include],
 100                             key=include_key):
 101                 if l != prev:
 102                     yield l
 103                 prev = l
 104
 105     def __call__(self, lines, filename, language):
 106         self.reset()
 107         leading_blank = False
 108         blanks = 0
 109         block = False
 110
 111         for line in lines:
 112             if not line:
 113                 blanks += 1
 114                 if not block:
 115                     # if we're not in an include block, spit out the
 116                     # newline otherwise, skip it since we're going to
 117                     # control newlines withinin include block
 118                     yield ''
 119                 continue
 120
 121             # Try to match each of the include types
 122             for include_type,(ldelim,rdelim),include_re in self.includes_re:
 123                 match = include_re.match(line)
 124                 if not match:
 125                     continue
 126
 127                 # if we've got a match, clean up the #include line,
 128                 # fix up stl headers and store it in the proper category
 129                 groups = match.groups()
 130                 keyword = groups[0]
 131                 include = groups[1]
 132                 extra = groups[-1]
 133                 if include_type == 'c' and language == 'C++':
 134                     stl_inc = cpp_c_headers.get(include, None)
 135                     if stl_inc:
 136                         include = stl_inc
 137                         include_type = 'stl'
 138
 139                 line = keyword + ' ' + ldelim + include + rdelim + extra
 140
 141                 self.includes[include_type].append(line)
 142
 143                 # We've entered a block, don't keep track of blank
 144                 # lines while in a block
 145                 block = True
 146                 blanks = 0
 147                 break
 148             else:
 149                 # this line did not match a #include
 150                 assert not include_re.match(line)
 151
 152                 # if we're not in a block and we didn't match an include
 153                 # to enter a block, just emit the line and continue
 154                 if not block:
 155                     yield line
 156                     continue
 157
 158                 # We've exited an include block.
 159                 for block_line in self.dump_block():
 160                     yield block_line
 161
 162                 # if there are any newlines after the include block,
 163                 # emit a single newline (removing extras)
 164                 if blanks and block:
 165                     yield ''
 166
 167                 blanks = 0
 168                 block = False
 169                 self.reset()
 170
 171                 # emit the line that ended the block
 172                 yield line
 173
 174         if block:
 175             # We've exited an include block.
 176             for block_line in self.dump_block():
 177                 yield block_line
 178
 179
 180
 181 # default language types to try to apply our sorting rules to
 182 default_languages = frozenset(('C', 'C++', 'isa', 'python', 'scons', 'swig'))
 183
 184 def options():
 185     import optparse
 186     options = optparse.OptionParser()
 187     add_option = options.add_option
 188     add_option('-d', '--dir_ignore', metavar="DIR[,DIR]", type='string',
 189                default=','.join(default_dir_ignore),
 190                help="ignore directories")
 191     add_option('-f', '--file_ignore', metavar="FILE[,FILE]", type='string',
 192                default=','.join(default_file_ignore),
 193                help="ignore files")
 194     add_option('-l', '--languages', metavar="LANG[,LANG]", type='string',
 195                default=','.join(default_languages),
 196                help="languages")
 197     add_option('-n', '--dry-run', action='store_true',
 198                help="don't overwrite files")
 199
 200     return options
 201
 202 def parse_args(parser):
 203     opts,args = parser.parse_args()
 204
 205     opts.dir_ignore = frozenset(opts.dir_ignore.split(','))
 206     opts.file_ignore = frozenset(opts.file_ignore.split(','))
 207     opts.languages = frozenset(opts.languages.split(','))
 208
 209     return opts,args
 210
 211 if __name__ == '__main__':
 212     parser = options()
 213     opts, args = parse_args(parser)
 214
 215     for base in args:
 216         for filename,language in find_files(base, languages=opts.languages,
 217                 file_ignore=opts.file_ignore, dir_ignore=opts.dir_ignore):
 218             if opts.dry_run:
 219                 print "%s: %s" % (filename, language)
 220             else:
 221                 update_file(filename, filename, language, SortIncludes())