summaryrefslogtreecommitdiffstats
path: root/src/boost/tools/litre
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:45:59 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:45:59 +0000
commit19fcec84d8d7d21e796c7624e521b60d28ee21ed (patch)
tree42d26aa27d1e3f7c0b8bd3fd14e7d7082f5008dc /src/boost/tools/litre
parentInitial commit. (diff)
downloadceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.tar.xz
ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.zip
Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/boost/tools/litre')
-rw-r--r--src/boost/tools/litre/cplusplus.py810
-rw-r--r--src/boost/tools/litre/litre.py61
-rw-r--r--src/boost/tools/litre/tool.py67
3 files changed, 938 insertions, 0 deletions
diff --git a/src/boost/tools/litre/cplusplus.py b/src/boost/tools/litre/cplusplus.py
new file mode 100644
index 000000000..c48e0678e
--- /dev/null
+++ b/src/boost/tools/litre/cplusplus.py
@@ -0,0 +1,810 @@
+# Copyright David Abrahams 2004.
+# Copyright Daniel Wallin 2006.
+# Distributed under the Boost
+# Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+import os
+import tempfile
+import litre
+import re
+import sys
+import traceback
+
+# Thanks to Jean Brouwers for this snippet
+def _caller(up=0):
+ '''Get file name, line number, function name and
+ source text of the caller's caller as 4-tuple:
+ (file, line, func, text).
+
+ The optional argument 'up' allows retrieval of
+ a caller further back up into the call stack.
+
+ Note, the source text may be None and function
+ name may be '?' in the returned result. In
+ Python 2.3+ the file name may be an absolute
+ path.
+ '''
+ try: # just get a few frames'
+ f = traceback.extract_stack(limit=up+2)
+ if f:
+ return f[0]
+ except:
+ pass
+ # running with psyco?
+ return ('', 0, '', None)
+
+class Example:
+ closed = False
+ in_emph = None
+
+ def __init__(self, node, section, line_offset, line_hash = '#'):
+ # A list of text fragments comprising the Example. Start with a #line
+ # directive
+ self.section = section
+ self.line_hash = line_hash
+ self.node = node
+ self.body = []
+ self.line_offset = line_offset
+ self._number_of_prefixes = 0
+
+ self.emphasized = [] # indices of text strings that have been
+ # emphasized. These are generally expected to be
+ # invalid C++ and will need special treatment
+
+ def begin_emphasis(self):
+ self.in_emph = len(self.body)
+
+ def end_emphasis(self):
+ self.emphasized.append( (self.in_emph, len(self.body)) )
+
+ def append(self, s):
+ self.append_raw(self._make_line(s))
+
+ def prepend(self, s):
+ self.prepend_raw(self._make_line(s))
+
+ def append_raw(self, s):
+ self.body.append(s)
+
+ def prepend_raw(self, s):
+ self.body.insert(0,s)
+ self.emphasized = [ (x[0]+1,x[1]+1) for x in self.emphasized ]
+ self._number_of_prefixes += 1
+
+ def replace(self, s1, s2):
+ self.body = [x.replace(s1,s2) for x in self.body]
+
+ def sub(self, pattern, repl, count = 1, flags = re.MULTILINE):
+ pat = re.compile(pattern, flags)
+ for i,txt in enumerate(self.body):
+ if count > 0:
+ x, subs = pat.subn(repl, txt, count)
+ self.body[i] = x
+ count -= subs
+
+ def wrap(self, s1, s2):
+ self.append_raw(self._make_line(s2))
+ self.prepend_raw(self._make_line(s1, offset = -s1.count('\n')))
+
+ def replace_emphasis(self, s, index = 0):
+ """replace the index'th emphasized text with s"""
+ e = self.emphasized[index]
+ self.body[e[0]:e[1]] = [s]
+ del self.emphasized[index]
+
+ elipsis = re.compile('^([ \t]*)([.][.][.][ \t]*)$', re.MULTILINE)
+
+ def __str__(self):
+ # Comment out any remaining emphasized sections
+ b = [self.elipsis.sub(r'\1// \2', s) for s in self.body]
+ emph = self.emphasized
+ emph.reverse()
+ for e in emph:
+ b.insert(e[1], ' */')
+ b.insert(e[0], '/* ')
+ emph.reverse()
+
+ # Add initial #line
+ b.insert(
+ self._number_of_prefixes,
+ self._line_directive(self.node.line, self.node.source)
+ )
+
+ # Add trailing newline to avoid warnings
+ b.append('\n')
+ return ''.join(b)
+
+ def __repr__(self):
+ return "Example: " + repr(str(self))
+
+ def raw(self):
+ return ''.join(self.body)
+
+ def _make_line(self, s, offset = 0):
+ c = _caller(2)[1::-1]
+ offset -= s.count('\n')
+ return '\n%s%s\n' % (self._line_directive(offset = offset, *c), s.strip('\n'))
+
+ def _line_directive(self, line, source, offset = None):
+ if self.line_hash is None:
+ return '\n'
+
+ if offset is None:
+ offset = self.line_offset
+
+ if line is None or line <= -offset:
+ line = 1
+ else:
+ line += offset
+
+ if source is None:
+ return '%sline %d\n' % (self.line_hash, line)
+ else:
+ return '%sline %d "%s"\n' % (self.line_hash, line, source)
+
+
+def syscmd(
+ cmd
+ , expect_error = False
+ , input = None
+ , max_output_lines = None
+ ):
+
+ # On windows close() returns the exit code, on *nix it doesn't so
+ # we need to use popen2.Popen4 instead.
+ if sys.platform == 'win32':
+ stdin, stdout_stderr = os.popen4(cmd)
+ if input: stdin.write(input)
+ stdin.close()
+
+ out = stdout_stderr.read()
+ status = stdout_stderr.close()
+ else:
+ import popen2
+ process = popen2.Popen4(cmd)
+ if input: process.tochild.write(input)
+ out = process.fromchild.read()
+ status = process.wait()
+
+ if max_output_lines is not None:
+ out = '\n'.join(out.split('\n')[:max_output_lines])
+
+ if expect_error:
+ status = not status
+
+ if status:
+ print
+ print '========== offending command ==========='
+ print cmd
+ print '------------ stdout/stderr -------------'
+ print expect_error and 'Error expected, but none seen' or out
+ elif expect_error > 1:
+ print
+ print '------ Output of Expected Error --------'
+ print out
+ print '----------------------------------------'
+
+ sys.stdout.flush()
+
+ return (status,out)
+
+
+def expand_vars(path):
+ if os.name == 'nt':
+ re_env = re.compile(r'%\w+%')
+ return re_env.sub(
+ lambda m: os.environ.get( m.group(0)[1:-1] )
+ , path
+ )
+ else:
+ return os.path.expandvars(path)
+
+def remove_directory_and_contents(path):
+ for root, dirs, files in os.walk(path, topdown=False):
+ for name in files:
+ os.remove(os.path.join(root, name))
+ for name in dirs:
+ os.rmdir(os.path.join(root, name))
+ os.rmdir(path)
+
+class BuildResult:
+ def __init__(self, path):
+ self.path = path
+
+ def __repr__(self):
+ return self.path
+
+ def __del__(self):
+ remove_directory_and_contents(self.path)
+
+class CPlusPlusTranslator(litre.LitreTranslator):
+
+ _exposed_attrs = ['compile', 'test', 'ignore', 'match_stdout', 'stack', 'config'
+ , 'example', 'prefix', 'preprocessors', 'litre_directory',
+ 'litre_translator', 'includes', 'build', 'jam_prefix',
+ 'run_python']
+
+ last_run_output = ''
+
+ """Attributes that will be made available to litre code"""
+
+ def __init__(self, document, config):
+ litre.LitreTranslator.__init__(self, document, config)
+ self.in_literal = False
+ self.in_table = True
+ self.preprocessors = []
+ self.stack = []
+ self.example = None
+ self.prefix = []
+ self.includes = config.includes
+ self.litre_directory = os.path.split(__file__)[0]
+ self.config = config
+ self.litre_translator = self
+ self.line_offset = 0
+ self.last_source = None
+ self.jam_prefix = []
+
+ self.globals = { 'test_literals_in_tables' : False }
+ for m in self._exposed_attrs:
+ self.globals[m] = getattr(self, m)
+
+ self.examples = {}
+ self.current_section = None
+
+ #
+ # Stuff for use by docutils writer framework
+ #
+ def visit_emphasis(self, node):
+ if self.in_literal:
+ self.example.begin_emphasis()
+
+ def depart_emphasis(self, node):
+ if self.in_literal:
+ self.example.end_emphasis()
+
+ def visit_section(self, node):
+ self.current_section = node['ids'][0]
+
+ def visit_literal_block(self, node):
+ if node.source is None:
+ node.source = self.last_source
+ self.last_source = node.source
+
+ # create a new example
+ self.example = Example(node, self.current_section, line_offset = self.line_offset, line_hash = self.config.line_hash)
+
+ self.stack.append(self.example)
+
+ self.in_literal = True
+
+ def depart_literal_block(self, node):
+ self.in_literal = False
+
+ def visit_literal(self, node):
+ if self.in_table and self.globals['test_literals_in_tables']:
+ self.visit_literal_block(node)
+ else:
+ litre.LitreTranslator.visit_literal(self,node)
+
+ def depart_literal(self, node):
+ if self.in_table and self.globals['test_literals_in_tables']:
+ self.depart_literal_block(node)
+ else:
+ litre.LitreTranslator.depart_literal(self,node)
+
+ def visit_table(self,node):
+ self.in_table = True
+ litre.LitreTranslator.visit_table(self,node)
+
+ def depart_table(self,node):
+ self.in_table = False
+ litre.LitreTranslator.depart_table(self,node)
+
+ def visit_Text(self, node):
+ if self.in_literal:
+ self.example.append_raw(node.astext())
+
+ def depart_document(self, node):
+ self.write_examples()
+
+ #
+ # Private stuff
+ #
+
+ def handled(self, n = 1):
+ r = self.stack[-n:]
+ del self.stack[-n:]
+ return r
+
+ def _execute(self, code):
+ """Override of litre._execute; sets up variable context before
+ evaluating code
+ """
+ self.globals['example'] = self.example
+ eval(code, self.globals)
+
+ #
+ # Stuff for use by embedded python code
+ #
+
+ def match_stdout(self, expected = None):
+
+ if expected is None:
+ expected = self.example.raw()
+ self.handled()
+
+ if not re.search(expected, self.last_run_output, re.MULTILINE):
+ #if self.last_run_output.strip('\n') != expected.strip('\n'):
+ print 'output failed to match example'
+ print '-------- Actual Output -------------'
+ print repr(self.last_run_output)
+ print '-------- Expected Output -----------'
+ print repr(expected)
+ print '------------------------------------'
+ sys.stdout.flush()
+
+ def ignore(self, n = 1):
+ if n == 'all':
+ n = len(self.stack)
+ return self.handled(n)
+
+ def wrap(self, n, s1, s2):
+ self.stack[-1].append(s2)
+ self.stack[-n].prepend(s1)
+
+
+ def compile(
+ self
+ , howmany = 1
+ , pop = -1
+ , expect_error = False
+ , extension = '.o'
+ , options = ['-c']
+ , built_handler = lambda built_file: None
+ , source_file = None
+ , source_suffix = '.cpp'
+ # C-style comments by default; handles C++ and YACC
+ , make_comment = lambda text: '/*\n%s\n*/' % text
+ , built_file = None
+ , command = None
+ ):
+ """
+ Compile examples on the stack, whose topmost item is the last example
+ seen but not yet handled so far.
+
+ :howmany: How many of the topmost examples on the stack to compile.
+ You can pass a number, or 'all' to indicate that all examples should
+ be compiled.
+
+ :pop: How many of the topmost examples to discard. By default, all of
+ the examples that are compiled are discarded.
+
+ :expect_error: Whether a compilation error is to be expected. Any value
+ > 1 will cause the expected diagnostic's text to be dumped for
+ diagnostic purposes. It's common to expect an error but see a
+ completely unrelated one because of bugs in the example (you can get
+ this behavior for all examples by setting show_expected_error_output
+ in your config).
+
+ :extension: The extension of the file to build (set to .exe for
+ run)
+
+ :options: Compiler flags
+
+ :built_file: A path to use for the built file. By default, a temp
+ filename is conjured up
+
+ :built_handler: A function that's called with the name of the built file
+ upon success.
+
+ :source_file: The full name of the source file to write
+
+ :source_suffix: If source_file is None, the suffix to use for the source file
+
+ :make_comment: A function that transforms text into an appropriate comment.
+
+ :command: A function that is passed (includes, opts, target, source), where
+ opts is a string representing compiler options, target is the name of
+ the file to build, and source is the name of the file into which the
+ example code is written. By default, the function formats
+ litre.config.compiler with its argument tuple.
+ """
+
+ # Grab one example by default
+ if howmany == 'all':
+ howmany = len(self.stack)
+
+ source = '\n'.join(
+ self.prefix
+ + [str(x) for x in self.stack[-howmany:]]
+ )
+
+ source = reduce(lambda s, f: f(s), self.preprocessors, source)
+
+ if pop:
+ if pop < 0:
+ pop = howmany
+ del self.stack[-pop:]
+
+ if len(self.stack):
+ self.example = self.stack[-1]
+
+ cpp = self._source_file_path(source_file, source_suffix)
+
+ if built_file is None:
+ built_file = self._output_file_path(source_file, extension)
+
+ opts = ' '.join(options)
+
+ includes = ' '.join(['-I%s' % d for d in self.includes])
+ if not command:
+ command = self.config.compiler
+
+ if type(command) == str:
+ command = lambda i, o, t, s, c = command: c % (i, o, t, s)
+
+ cmd = command(includes, opts, expand_vars(built_file), expand_vars(cpp))
+
+ if expect_error and self.config.show_expected_error_output:
+ expect_error += 1
+
+
+ comment_cmd = command(includes, opts, built_file, os.path.basename(cpp))
+ comment = make_comment(config.comment_text(comment_cmd, expect_error))
+
+ self._write_source(cpp, '\n'.join([comment, source]))
+
+ #print 'wrote in', cpp
+ #print 'trying command', cmd
+
+ status, output = syscmd(cmd, expect_error)
+
+ if status or expect_error > 1:
+ print
+ if expect_error and expect_error < 2:
+ print 'Compilation failure expected, but none seen'
+ print '------------ begin offending source ------------'
+ print open(cpp).read()
+ print '------------ end offending source ------------'
+
+ if self.config.save_cpp:
+ print 'saved in', repr(cpp)
+ else:
+ self._remove_source(cpp)
+
+ sys.stdout.flush()
+ else:
+ print '.',
+ sys.stdout.flush()
+ built_handler(built_file)
+
+ self._remove_source(cpp)
+
+ try:
+ self._unlink(built_file)
+ except:
+ if not expect_error:
+ print 'failed to unlink', built_file
+
+ return status
+
+ def test(
+ self
+ , rule = 'run'
+ , howmany = 1
+ , pop = -1
+ , expect_error = False
+ , requirements = ''
+ , input = ''
+ ):
+
+ # Grab one example by default
+ if howmany == 'all':
+ howmany = len(self.stack)
+
+ source = '\n'.join(
+ self.prefix
+ + [str(x) for x in self.stack[-howmany:]]
+ )
+
+ source = reduce(lambda s, f: f(s), self.preprocessors, source)
+
+ id = self.example.section
+ if not id:
+ id = 'top-level'
+
+ if not self.examples.has_key(self.example.section):
+ self.examples[id] = [(rule, source)]
+ else:
+ self.examples[id].append((rule, source))
+
+ if pop:
+ if pop < 0:
+ pop = howmany
+ del self.stack[-pop:]
+
+ if len(self.stack):
+ self.example = self.stack[-1]
+
+ def write_examples(self):
+ jam = open(os.path.join(self.config.dump_dir, 'Jamfile.v2'), 'w')
+
+ jam.write('''
+import testing ;
+
+''')
+
+ for id,examples in self.examples.items():
+ for i in range(len(examples)):
+ cpp = '%s%d.cpp' % (id, i)
+
+ jam.write('%s %s ;\n' % (examples[i][0], cpp))
+
+ outfile = os.path.join(self.config.dump_dir, cpp)
+ print cpp,
+ try:
+ if open(outfile, 'r').read() == examples[i][1]:
+ print ' .. skip'
+ continue
+ except:
+ pass
+
+ open(outfile, 'w').write(examples[i][1])
+ print ' .. written'
+
+ jam.close()
+
+ def build(
+ self
+ , howmany = 1
+ , pop = -1
+ , source_file = 'example.cpp'
+ , expect_error = False
+ , target_rule = 'obj'
+ , requirements = ''
+ , input = ''
+ , output = 'example_output'
+ ):
+
+ # Grab one example by default
+ if howmany == 'all':
+ howmany = len(self.stack)
+
+ source = '\n'.join(
+ self.prefix
+ + [str(x) for x in self.stack[-howmany:]]
+ )
+
+ source = reduce(lambda s, f: f(s), self.preprocessors, source)
+
+ if pop:
+ if pop < 0:
+ pop = howmany
+ del self.stack[-pop:]
+
+ if len(self.stack):
+ self.example = self.stack[-1]
+
+ dir = tempfile.mkdtemp()
+ cpp = os.path.join(dir, source_file)
+ self._write_source(cpp, source)
+ self._write_jamfile(
+ dir
+ , target_rule = target_rule
+ , requirements = requirements
+ , input = input
+ , output = output
+ )
+
+ cmd = 'bjam'
+ if self.config.bjam_options:
+ cmd += ' %s' % self.config.bjam_options
+
+ os.chdir(dir)
+ status, output = syscmd(cmd, expect_error)
+
+ if status or expect_error > 1:
+ print
+ if expect_error and expect_error < 2:
+ print 'Compilation failure expected, but none seen'
+ print '------------ begin offending source ------------'
+ print open(cpp).read()
+ print '------------ begin offending Jamfile -----------'
+ print open(os.path.join(dir, 'Jamroot')).read()
+ print '------------ end offending Jamfile -------------'
+
+ sys.stdout.flush()
+ else:
+ print '.',
+ sys.stdout.flush()
+
+ if status: return None
+ else: return BuildResult(dir)
+
+ def _write_jamfile(self, path, target_rule, requirements, input, output):
+ jamfile = open(os.path.join(path, 'Jamroot'), 'w')
+ contents = r"""
+import modules ;
+
+BOOST_ROOT = [ modules.peek : BOOST_ROOT ] ;
+use-project /boost : $(BOOST_ROOT) ;
+
+%s
+
+%s %s
+ : example.cpp %s
+ : <include>.
+ %s
+ %s
+ ;
+ """ % (
+ '\n'.join(self.jam_prefix)
+ , target_rule
+ , output
+ , input
+ , ' '.join(['<include>%s' % d for d in self.includes])
+ , requirements
+ )
+
+ jamfile.write(contents)
+
+ def run_python(
+ self
+ , howmany = 1
+ , pop = -1
+ , module_path = []
+ , expect_error = False
+ ):
+ # Grab one example by default
+ if howmany == 'all':
+ howmany = len(self.stack)
+
+ if module_path == None: module_path = []
+
+ if isinstance(module_path, BuildResult) or type(module_path) == str:
+ module_path = [module_path]
+
+ module_path = map(lambda p: str(p), module_path)
+
+ source = '\n'.join(
+ self.prefix
+ + [str(x) for x in self.stack[-howmany:]]
+ )
+
+ if pop:
+ if pop < 0:
+ pop = howmany
+ del self.stack[-pop:]
+
+ if len(self.stack):
+ self.example = self.stack[-1]
+
+ r = re.compile(r'^(>>>|\.\.\.) (.*)$', re.MULTILINE)
+ source = r.sub(r'\2', source)
+ py = self._source_file_path(source_file = None, source_suffix = 'py')
+ open(py, 'w').write(source)
+
+ old_path = os.getenv('PYTHONPATH')
+ if old_path == None:
+ pythonpath = ':'.join(module_path)
+ old_path = ''
+ else:
+ pythonpath = old_path + ':%s' % ':'.join(module_path)
+
+ os.putenv('PYTHONPATH', pythonpath)
+ status, output = syscmd('python %s' % py)
+
+ if status or expect_error > 1:
+ print
+ if expect_error and expect_error < 2:
+ print 'Compilation failure expected, but none seen'
+ print '------------ begin offending source ------------'
+ print open(py).read()
+ print '------------ end offending Jamfile -------------'
+
+ sys.stdout.flush()
+ else:
+ print '.',
+ sys.stdout.flush()
+
+ self.last_run_output = output
+ os.putenv('PYTHONPATH', old_path)
+ self._unlink(py)
+
+ def _write_source(self, filename, contents):
+ open(filename,'w').write(contents)
+
+ def _remove_source(self, source_path):
+ os.unlink(source_path)
+
+ def _source_file_path(self, source_file, source_suffix):
+ if source_file is None:
+ cpp = tempfile.mktemp(suffix=source_suffix)
+ else:
+ cpp = os.path.join(tempfile.gettempdir(), source_file)
+ return cpp
+
+ def _output_file_path(self, source_file, extension):
+ return tempfile.mktemp(suffix=extension)
+
+ def _unlink(self, file):
+ file = expand_vars(file)
+ if os.path.exists(file):
+ os.unlink(file)
+
+ def _launch(self, exe, stdin = None):
+ status, output = syscmd(exe, input = stdin)
+ self.last_run_output = output
+
+ def run_(self, howmany = 1, stdin = None, **kw):
+ new_kw = { 'options':[], 'extension':'.exe' }
+ new_kw.update(kw)
+
+ self.compile(
+ howmany
+ , built_handler = lambda exe: self._launch(exe, stdin = stdin)
+ , **new_kw
+ )
+
+ def astext(self):
+ return ""
+ return '\n\n ---------------- Unhandled Fragment ------------ \n\n'.join(
+ [''] # generates a leading announcement
+ + [ unicode(s) for s in self.stack]
+ )
+
+class DumpTranslator(CPlusPlusTranslator):
+ example_index = 1
+
+ def _source_file_path(self, source_file, source_suffix):
+ if source_file is None:
+ source_file = 'example%s%s' % (self.example_index, source_suffix)
+ self.example_index += 1
+
+ cpp = os.path.join(config.dump_dir, source_file)
+ return cpp
+
+ def _output_file_path(self, source_file, extension):
+ chapter = os.path.basename(config.dump_dir)
+ return '%%TEMP%%\metaprogram-%s-example%s%s' \
+ % ( chapter, self.example_index - 1, extension)
+
+ def _remove_source(self, source_path):
+ pass
+
+
+class WorkaroundTranslator(DumpTranslator):
+ """Translator used to test/dump workaround examples for vc6 and vc7. Just
+ like a DumpTranslator except that we leave existing files alone.
+
+ Warning: not sensitive to changes in .rst source!! If you change the actual
+ examples in source files you will have to move the example files out of the
+ way and regenerate them, then re-incorporate the workarounds.
+ """
+ def _write_source(self, filename, contents):
+ if not os.path.exists(filename):
+ DumpTranslator._write_source(self, filename, contents)
+
+class Config:
+ save_cpp = False
+ line_hash = '#'
+ show_expected_error_output = False
+ max_output_lines = None
+
+class Writer(litre.Writer):
+ translator = CPlusPlusTranslator
+
+ def __init__(
+ self
+ , config
+ ):
+ litre.Writer.__init__(self)
+ self._config = Config()
+ defaults = Config.__dict__
+
+ # update config elements
+ self._config.__dict__.update(config.__dict__)
+# dict([i for i in config.__dict__.items()
+# if i[0] in config.__all__]))
+
diff --git a/src/boost/tools/litre/litre.py b/src/boost/tools/litre/litre.py
new file mode 100644
index 000000000..c0ac67e28
--- /dev/null
+++ b/src/boost/tools/litre/litre.py
@@ -0,0 +1,61 @@
+from docutils import writers
+from docutils import nodes
+
+class LitreTranslator(nodes.GenericNodeVisitor):
+
+ def __init__(self, document, config):
+ nodes.GenericNodeVisitor.__init__(self,document)
+ self._config = config
+
+ def default_visit(self, node):
+ pass
+ # print '**visiting:', repr(node)
+
+ def default_departure(self, node):
+ pass
+ # print '**departing:', repr(node)
+
+ def visit_raw(self, node):
+ if node.has_key('format'):
+ key = node['format'].lower()
+ if key == 'litre':
+ # This is probably very evil ;-)
+ #if node.has_key('source'):
+ # node.file = node.attributes['source']
+
+ self._handle_code(node, node.astext())
+
+ raise nodes.SkipNode
+
+ def visit_comment(self, node):
+ code = node.astext()
+ if code[0] == '@':
+ self._handle_code(node, code[1:].strip())
+
+ def _handle_code(self, node, code):
+ start_line = node.line or 0
+ start_line -= code.count('\n') + 2 # docutils bug workaround?
+ try:
+ self._execute(compile( start_line*'\n' + code, str(node.source), 'exec'))
+ except:
+ print '\n------- begin offending Python source -------'
+ print code
+ print '------- end offending Python source -------'
+ raise
+
+ def _execute(self, code):
+ """Override this to set up local variable context for code before
+ invoking it
+ """
+ eval(code)
+
+class Writer(writers.Writer):
+ translator = LitreTranslator
+ _config = None
+
+ def translate(self):
+ visitor = self.translator(self.document, self._config)
+ self.document.walkabout(visitor)
+ self.output = visitor.astext()
+
+
diff --git a/src/boost/tools/litre/tool.py b/src/boost/tools/litre/tool.py
new file mode 100644
index 000000000..1533fc33d
--- /dev/null
+++ b/src/boost/tools/litre/tool.py
@@ -0,0 +1,67 @@
+try:
+ import locale
+ locale.setlocale(locale.LC_ALL, '')
+except:
+ pass
+
+
+# try to import a litre_config.py file.
+try:
+ import litre_config as config
+except:
+ class config: pass
+
+import sys
+try: # if the user has set up docutils_root in his config, add it to the PYTHONPATH.
+ sys.path += ['%s/docutils' % config.docutils_root
+ , '%s/docutils/extras' % config.docutils_root]
+except: pass
+
+import docutils.writers
+import cplusplus
+import os
+
+from docutils.core import publish_cmdline, default_description
+
+description = ('Literate programming from ReStructuredText '
+ 'sources. ' + default_description)
+
+def _pop_option(prefix):
+ found = None
+ for opt in sys.argv:
+ if opt.startswith(prefix):
+ sys.argv = [ x for x in sys.argv if x != opt ]
+ found = opt
+ if prefix.endswith('='):
+ found = opt[len(prefix):]
+ return found
+
+
+dump_dir = _pop_option('--dump_dir=')
+max_output_lines = _pop_option('--max_output_lines=')
+
+if dump_dir:
+
+ cplusplus.Writer.translator = cplusplus.DumpTranslator
+ if _pop_option('--workaround'):
+ cplusplus.Writer.translator = cplusplus.WorkaroundTranslator
+ config.includes.insert(0, os.path.join(os.path.split(dump_dir)[0], 'patches'))
+
+ config.dump_dir = os.path.abspath(dump_dir)
+ if _pop_option('--cleanup_source'):
+ config.line_hash = None
+
+ if not os.path.exists(config.dump_dir):
+ os.makedirs(config.dump_dir)
+
+if max_output_lines:
+ config.max_output_lines = int(max_output_lines)
+
+config.bjam_options = _pop_option('--bjam=')
+
+config.includes = []
+
+publish_cmdline(
+ writer=cplusplus.Writer(config),
+ description=description
+ )