src/python/m5/util/code_formatter.py

   1 # Copyright (c) 2006-2009 Nathan Binkert <nate@binkert.org>
   2 # All rights reserved.
   3 #
   4 # Redistribution and use in source and binary forms, with or without
   5 # modification, are permitted provided that the following conditions are
   6 # met: redistributions of source code must retain the above copyright
   7 # notice, this list of conditions and the following disclaimer;
   8 # redistributions in binary form must reproduce the above copyright
   9 # notice, this list of conditions and the following disclaimer in the
  10 # documentation and/or other materials provided with the distribution;
  11 # neither the name of the copyright holders nor the names of its
  12 # contributors may be used to endorse or promote products derived from
  13 # this software without specific prior written permission.
  14 #
  15 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  18 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  19 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  21 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27 import inspect
  28 import os
  29 import re
  30 import string
  31
  32 class lookup(object):
  33     def __init__(self, formatter, frame, *args, **kwargs):
  34         self.frame = frame
  35         self.formatter = formatter
  36         self.dict = self.formatter._dict
  37         self.args = args
  38         self.kwargs = kwargs
  39         self.locals = {}
  40
  41     def __setitem__(self, item, val):
  42         self.locals[item] = val
  43
  44     def __getitem__(self, item):
  45         if item in self.locals:
  46             return self.locals[item]
  47
  48         if item in self.kwargs:
  49             return self.kwargs[item]
  50
  51         if item == '__file__':
  52             return self.frame.f_code.co_filename
  53
  54         if item == '__line__':
  55             return self.frame.f_lineno
  56
  57         if item in self.dict:
  58             return self.dict[item]
  59
  60         if self.formatter.locals or self.formatter.globals:
  61             if self.formatter.locals and item in self.frame.f_locals:
  62                 return self.frame.f_locals[item]
  63
  64             if self.formatter.globals and item in self.frame.f_globals:
  65                 return self.frame.f_globals[item]
  66
  67         if item in __builtins__:
  68             return __builtins__[item]
  69
  70         try:
  71             item = int(item)
  72             return self.args[item]
  73         except ValueError:
  74             pass
  75         raise IndexError, "Could not find '%s'" % item
  76
  77 class code_formatter_meta(type):
  78     pattern = r"""
  79     (?:
  80       %(delim)s(?P<escaped>%(delim)s)              | # escaped delimiter
  81       ^(?P<indent>[ ]*)%(delim)s(?P<lone>%(ident)s)$ | # lone identifier
  82       %(delim)s(?P<ident>%(ident)s)                | # identifier
  83       %(delim)s%(lb)s(?P<b_ident>%(ident)s)%(rb)s  | # braced identifier
  84       %(delim)s(?P<pos>%(pos)s)                    | # positional parameter
  85       %(delim)s%(lb)s(?P<b_pos>%(pos)s)%(rb)s      | # braced positional
  86       %(delim)s%(ldb)s(?P<eval>.*?)%(rdb)s         | # double braced expression
  87       %(delim)s(?P<invalid>)                       # ill-formed delimiter exprs
  88     )
  89     """
  90     def __init__(cls, name, bases, dct):
  91         super(code_formatter_meta, cls).__init__(name, bases, dct)
  92         if 'pattern' in dct:
  93             pat = cls.pattern
  94         else:
  95             # tuple expansion to ensure strings are proper length
  96             lb,rb = cls.braced
  97             lb1,lb2,rb2,rb1 = cls.double_braced
  98             pat = code_formatter_meta.pattern % {
  99                 'delim' : re.escape(cls.delim),
 100                 'ident' : cls.ident,
 101                 'pos' : cls.pos,
 102                 'lb' : re.escape(lb),
 103                 'rb' : re.escape(rb),
 104                 'ldb' : re.escape(lb1+lb2),
 105                 'rdb' : re.escape(rb2+rb1),
 106                 }
 107         cls.pattern = re.compile(pat, re.VERBOSE | re.DOTALL | re.MULTILINE)
 108
 109 class code_formatter(object):
 110     __metaclass__ = code_formatter_meta
 111
 112     delim = r'$'
 113     ident = r'[_A-z]\w*'
 114     pos = r'[0-9]+'
 115     braced = r'{}'
 116     double_braced = r'{{}}'
 117
 118     globals = True
 119     locals = True
 120     fix_newlines = True
 121     def __init__(self, *args, **kwargs):
 122         self._data = []
 123         self._dict = {}
 124         self._indent_level = 0
 125         self._indent_spaces = 4
 126         self.globals = kwargs.pop('globals',type(self).globals)
 127         self.locals = kwargs.pop('locals', type(self).locals)
 128         self._fix_newlines = \
 129                 kwargs.pop('fix_newlines', type(self).fix_newlines)
 130
 131         if args:
 132             self.__call__(args)
 133
 134     def indent(self):
 135         self._indent_level += self._indent_spaces
 136
 137     def dedent(self):
 138         assert self._indent_level >= self._indent_spaces
 139         self._indent_level -= self._indent_spaces
 140
 141     def fix(self, status):
 142         previous = self._fix_newlines
 143         self._fix_newlines = status
 144         return previous
 145
 146     def nofix(self):
 147         previous = self._fix_newlines
 148         self._fix_newlines = False
 149         return previous
 150
 151     def clear():
 152         self._data = []
 153
 154     def write(self, *args):
 155         f = file(os.path.join(*args), "w")
 156         for data in self._data:
 157             f.write(data)
 158         f.close()
 159
 160     def __str__(self):
 161         data = string.join(self._data, '')
 162         self._data = [ data ]
 163         return data
 164
 165     def __getitem__(self, item):
 166         return self._dict[item]
 167
 168     def __setitem__(self, item, value):
 169         self._dict[item] = value
 170
 171     def __delitem__(self, item):
 172         del self._dict[item]
 173
 174     def __contains__(self, item):
 175         return item in self._dict
 176
 177     def __iadd__(self, data):
 178         self.append(data)
 179
 180     def append(self, data):
 181         if isinstance(data, code_formatter):
 182             self._data.extend(data._data)
 183         else:
 184             self._append(str(data))
 185
 186     def _append(self, data):
 187         if not self._fix_newlines:
 188             self._data.append(data)
 189             return
 190
 191         initial_newline = not self._data or self._data[-1] == '\n'
 192         for line in data.splitlines():
 193             if line:
 194                 if self._indent_level:
 195                     self._data.append(' ' * self._indent_level)
 196                 self._data.append(line)
 197
 198             if line or not initial_newline:
 199                 self._data.append('\n')
 200
 201             initial_newline = False
 202
 203     def insert_newline(self):
 204         self._data.append('\n')
 205
 206     def __call__(self, format, *args, **kwargs):
 207         frame = inspect.currentframe().f_back
 208
 209         l = lookup(self, frame, *args, **kwargs)
 210         def convert(match):
 211             ident = match.group('lone')
 212             # check for a lone identifier
 213             if ident:
 214                 indent = match.group('indent') # must be spaces
 215                 lone = '%s' % (l[ident], )
 216
 217                 def indent_lines(gen):
 218                     for line in gen:
 219                         yield indent
 220                         yield line
 221                 return ''.join(indent_lines(lone.splitlines(True)))
 222
 223             # check for an identifier, braced or not
 224             ident = match.group('ident') or match.group('b_ident')
 225             if ident is not None:
 226                 return '%s' % (l[ident], )
 227
 228             # check for a positional parameter, braced or not
 229             pos = match.group('pos') or match.group('b_pos')
 230             if pos is not None:
 231                 pos = int(pos)
 232                 if pos > len(args):
 233                     raise ValueError \
 234                         ('Positional parameter #%d not found in pattern' % pos,
 235                          code_formatter.pattern)
 236                 return '%s' % (args[int(pos)], )
 237
 238             # check for a double braced expression
 239             eval_expr = match.group('eval')
 240             if eval_expr is not None:
 241                 result = eval(eval_expr, {}, l)
 242                 return '%s' % (result, )
 243
 244             # check for an escaped delimiter
 245             if match.group('escaped') is not None:
 246                 return '$'
 247
 248             # At this point, we have to match invalid
 249             if match.group('invalid') is None:
 250                 # didn't match invalid!
 251                 raise ValueError('Unrecognized named group in pattern',
 252                                  code_formatter.pattern)
 253
 254             i = match.start('invalid')
 255             if i == 0:
 256                 colno = 1
 257                 lineno = 1
 258             else:
 259                 lines = format[:i].splitlines(True)
 260                 colno = i - reduce(lambda x,y: x+y, (len(z) for z in lines))
 261                 lineno = len(lines)
 262
 263                 raise ValueError('Invalid format string: line %d, col %d' %
 264                                  (lineno, colno))
 265
 266         d = code_formatter.pattern.sub(convert, format)
 267         self._append(d)
 268
 269 __all__ = [ "code_formatter" ]
 270
 271 if __name__ == '__main__':
 272     from code_formatter import code_formatter
 273     f = code_formatter()
 274
 275     class Foo(dict):
 276         def __init__(self, **kwargs):
 277             self.update(kwargs)
 278         def __getattr__(self, attr):
 279             return self[attr]
 280
 281     x = "this is a test"
 282     l = [ [Foo(x=[Foo(y=9)])] ]
 283
 284     y = code_formatter()
 285     y('''
 286 {
 287     this_is_a_test();
 288 }
 289 ''')
 290     f('    $y')
 291     f('''$__file__:$__line__
 292 {''')
 293     f("${{', '.join(str(x) for x in xrange(4))}}")
 294     f('${x}')
 295     f('$x')
 296     f.indent()
 297     for i in xrange(5):
 298         f('$x')
 299         f('$i')
 300         f('$0', "zero")
 301         f('$1 $0', "zero", "one")
 302         f('${0}', "he went")
 303         f('${0}asdf', "he went")
 304     f.dedent()
 305
 306     f('''
 307     ${{l[0][0]["x"][0].y}}
 308 }
 309 ''', 1, 9)
 310
 311     print f,