summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/python/SConscript1
-rw-r--r--src/python/m5/util/__init__.py1
-rw-r--r--src/python/m5/util/code_formatter.py311
3 files changed, 313 insertions, 0 deletions
diff --git a/src/python/SConscript b/src/python/SConscript
index c36f03695..bb892f376 100644
--- a/src/python/SConscript
+++ b/src/python/SConscript
@@ -53,6 +53,7 @@ PySource('m5', 'm5/ticks.py')
PySource('m5', 'm5/trace.py')
PySource('m5.util', 'm5/util/__init__.py')
PySource('m5.util', 'm5/util/attrdict.py')
+PySource('m5.util', 'm5/util/code_formatter.py')
PySource('m5.util', 'm5/util/grammar.py')
PySource('m5.util', 'm5/util/jobfile.py')
PySource('m5.util', 'm5/util/misc.py')
diff --git a/src/python/m5/util/__init__.py b/src/python/m5/util/__init__.py
index 48e8111bd..3930c8b6f 100644
--- a/src/python/m5/util/__init__.py
+++ b/src/python/m5/util/__init__.py
@@ -27,6 +27,7 @@
# Authors: Nathan Binkert
from attrdict import attrdict, optiondict
+from code_formatter import code_formatter
from misc import *
from multidict import multidict
from orderdict import orderdict
diff --git a/src/python/m5/util/code_formatter.py b/src/python/m5/util/code_formatter.py
new file mode 100644
index 000000000..919a6423b
--- /dev/null
+++ b/src/python/m5/util/code_formatter.py
@@ -0,0 +1,311 @@
+# Copyright (c) 2006-2009 Nathan Binkert <nate@binkert.org>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met: redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer;
+# redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution;
+# neither the name of the copyright holders nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import inspect
+import os
+import re
+import string
+
+class lookup(object):
+ def __init__(self, formatter, frame, *args, **kwargs):
+ self.frame = frame
+ self.formatter = formatter
+ self.dict = self.formatter._dict
+ self.args = args
+ self.kwargs = kwargs
+ self.locals = {}
+
+ def __setitem__(self, item, val):
+ self.locals[item] = val
+
+ def __getitem__(self, item):
+ if item in self.locals:
+ return self.locals[item]
+
+ if item in self.kwargs:
+ return self.kwargs[item]
+
+ if item == '__file__':
+ return self.frame.f_code.co_filename
+
+ if item == '__line__':
+ return self.frame.f_lineno
+
+ if item in self.dict:
+ return self.dict[item]
+
+ if self.formatter.locals or self.formatter.globals:
+ if self.formatter.locals and item in self.frame.f_locals:
+ return self.frame.f_locals[item]
+
+ if self.formatter.globals and item in self.frame.f_globals:
+ return self.frame.f_globals[item]
+
+ if item in __builtins__:
+ return __builtins__[item]
+
+ try:
+ item = int(item)
+ return self.args[item]
+ except ValueError:
+ pass
+ raise IndexError, "Could not find '%s'" % item
+
+class code_formatter_meta(type):
+ pattern = r"""
+ (?:
+ %(delim)s(?P<escaped>%(delim)s) | # escaped delimiter
+ ^(?P<indent>[ ]*)%(delim)s(?P<lone>%(ident)s)$ | # lone identifier
+ %(delim)s(?P<ident>%(ident)s) | # identifier
+ %(delim)s%(lb)s(?P<b_ident>%(ident)s)%(rb)s | # braced identifier
+ %(delim)s(?P<pos>%(pos)s) | # positional parameter
+ %(delim)s%(lb)s(?P<b_pos>%(pos)s)%(rb)s | # braced positional
+ %(delim)s%(ldb)s(?P<eval>.*?)%(rdb)s | # double braced expression
+ %(delim)s(?P<invalid>) # ill-formed delimiter exprs
+ )
+ """
+ def __init__(cls, name, bases, dct):
+ super(code_formatter_meta, cls).__init__(name, bases, dct)
+ if 'pattern' in dct:
+ pat = cls.pattern
+ else:
+ # tuple expansion to ensure strings are proper length
+ lb,rb = cls.braced
+ lb1,lb2,rb2,rb1 = cls.double_braced
+ pat = code_formatter_meta.pattern % {
+ 'delim' : re.escape(cls.delim),
+ 'ident' : cls.ident,
+ 'pos' : cls.pos,
+ 'lb' : re.escape(lb),
+ 'rb' : re.escape(rb),
+ 'ldb' : re.escape(lb1+lb2),
+ 'rdb' : re.escape(rb2+rb1),
+ }
+ cls.pattern = re.compile(pat, re.VERBOSE | re.DOTALL | re.MULTILINE)
+
+class code_formatter(object):
+ __metaclass__ = code_formatter_meta
+
+ delim = r'$'
+ ident = r'[_A-z]\w*'
+ pos = r'[0-9]+'
+ braced = r'{}'
+ double_braced = r'{{}}'
+
+ globals = True
+ locals = True
+ fix_newlines = True
+ def __init__(self, *args, **kwargs):
+ self._data = []
+ self._dict = {}
+ self._indent_level = 0
+ self._indent_spaces = 4
+ self.globals = kwargs.pop('globals',type(self).globals)
+ self.locals = kwargs.pop('locals', type(self).locals)
+ self._fix_newlines = \
+ kwargs.pop('fix_newlines', type(self).fix_newlines)
+
+ if args:
+ self.__call__(args)
+
+ def indent(self):
+ self._indent_level += self._indent_spaces
+
+ def dedent(self):
+ assert self._indent_level >= self._indent_spaces
+ self._indent_level -= self._indent_spaces
+
+ def fix(self, status):
+ previous = self._fix_newlines
+ self._fix_newlines = status
+ return previous
+
+ def nofix(self):
+ previous = self._fix_newlines
+ self._fix_newlines = False
+ return previous
+
+ def clear():
+ self._data = []
+
+ def write(self, *args):
+ f = file(os.path.join(*args), "w")
+ for data in self._data:
+ f.write(data)
+ f.close()
+
+ def __str__(self):
+ data = string.join(self._data, '')
+ self._data = [ data ]
+ return data
+
+ def __getitem__(self, item):
+ return self._dict[item]
+
+ def __setitem__(self, item, value):
+ self._dict[item] = value
+
+ def __delitem__(self, item):
+ del self._dict[item]
+
+ def __contains__(self, item):
+ return item in self._dict
+
+ def __iadd__(self, data):
+ self.append(data)
+
+ def append(self, data):
+ if isinstance(data, code_formatter):
+ self._data.extend(data._data)
+ else:
+ self._append(str(data))
+
+ def _append(self, data):
+ if not self._fix_newlines:
+ self._data.append(data)
+ return
+
+ initial_newline = not self._data or self._data[-1] == '\n'
+ for line in data.splitlines():
+ if line:
+ if self._indent_level:
+ self._data.append(' ' * self._indent_level)
+ self._data.append(line)
+
+ if line or not initial_newline:
+ self._data.append('\n')
+
+ initial_newline = False
+
+ def insert_newline(self):
+ self._data.append('\n')
+
+ def __call__(self, format, *args, **kwargs):
+ frame = inspect.currentframe().f_back
+
+ l = lookup(self, frame, *args, **kwargs)
+ def convert(match):
+ ident = match.group('lone')
+ # check for a lone identifier
+ if ident:
+ indent = match.group('indent') # must be spaces
+ lone = '%s' % (l[ident], )
+
+ def indent_lines(gen):
+ for line in gen:
+ yield indent
+ yield line
+ return ''.join(indent_lines(lone.splitlines(True)))
+
+ # check for an identifier, braced or not
+ ident = match.group('ident') or match.group('b_ident')
+ if ident is not None:
+ return '%s' % (l[ident], )
+
+ # check for a positional parameter, braced or not
+ pos = match.group('pos') or match.group('b_pos')
+ if pos is not None:
+ pos = int(pos)
+ if pos > len(args):
+ raise ValueError \
+ ('Positional parameter #%d not found in pattern' % pos,
+ code_formatter.pattern)
+ return '%s' % (args[int(pos)], )
+
+ # check for a double braced expression
+ eval_expr = match.group('eval')
+ if eval_expr is not None:
+ result = eval(eval_expr, {}, l)
+ return '%s' % (result, )
+
+ # check for an escaped delimiter
+ if match.group('escaped') is not None:
+ return '$'
+
+ # At this point, we have to match invalid
+ if match.group('invalid') is None:
+ # didn't match invalid!
+ raise ValueError('Unrecognized named group in pattern',
+ code_formatter.pattern)
+
+ i = match.start('invalid')
+ if i == 0:
+ colno = 1
+ lineno = 1
+ else:
+ lines = format[:i].splitlines(True)
+ colno = i - reduce(lambda x,y: x+y, (len(z) for z in lines))
+ lineno = len(lines)
+
+ raise ValueError('Invalid format string: line %d, col %d' %
+ (lineno, colno))
+
+ d = code_formatter.pattern.sub(convert, format)
+ self._append(d)
+
+__all__ = [ "code_formatter" ]
+
+if __name__ == '__main__':
+ from code_formatter import code_formatter
+ f = code_formatter()
+
+ class Foo(dict):
+ def __init__(self, **kwargs):
+ self.update(kwargs)
+ def __getattr__(self, attr):
+ return self[attr]
+
+ x = "this is a test"
+ l = [ [Foo(x=[Foo(y=9)])] ]
+
+ y = code_formatter()
+ y('''
+{
+ this_is_a_test();
+}
+''')
+ f(' $y')
+ f('''$__file__:$__line__
+{''')
+ f("${{', '.join(str(x) for x in xrange(4))}}")
+ f('${x}')
+ f('$x')
+ f.indent()
+ for i in xrange(5):
+ f('$x')
+ f('$i')
+ f('$0', "zero")
+ f('$1 $0', "zero", "one")
+ f('${0}', "he went")
+ f('${0}asdf', "he went")
+ f.dedent()
+
+ f('''
+ ${{l[0][0]["x"][0].y}}
+}
+''', 1, 9)
+
+ print f,