Rename the 'cretonne' crate to 'cretonne-codegen'.
This fixes the next part of #287.
This commit is contained in:
Dan Gohman
277
lib/codegen/meta/srcgen.py
Normal file
277
lib/codegen/meta/srcgen.py
Normal file
@@ -0,0 +1,277 @@
|
||||
"""
|
||||
Source code generator.
|
||||
|
||||
The `srcgen` module contains generic helper routines and classes for generating
|
||||
source code.
|
||||
|
||||
"""
|
||||
from __future__ import absolute_import
|
||||
import sys
|
||||
import os
|
||||
from collections import OrderedDict
|
||||
|
||||
try:
|
||||
from typing import Any, List, Set, Tuple # noqa
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
|
||||
class Formatter(object):
|
||||
"""
|
||||
Source code formatter class.
|
||||
|
||||
- Collect source code to be written to a file.
|
||||
- Keep track of indentation.
|
||||
|
||||
Indentation example:
|
||||
|
||||
>>> f = Formatter()
|
||||
>>> f.line('Hello line 1')
|
||||
>>> f.writelines()
|
||||
Hello line 1
|
||||
>>> f.indent_push()
|
||||
>>> f.comment('Nested comment')
|
||||
>>> f.indent_pop()
|
||||
>>> f.format('Back {} again', 'home')
|
||||
>>> f.writelines()
|
||||
Hello line 1
|
||||
// Nested comment
|
||||
Back home again
|
||||
|
||||
"""
|
||||
|
||||
shiftwidth = 4
|
||||
|
||||
def __init__(self):
|
||||
# type: () -> None
|
||||
self.indent = ''
|
||||
self.lines = [] # type: List[str]
|
||||
|
||||
def indent_push(self):
|
||||
# type: () -> None
|
||||
"""Increase current indentation level by one."""
|
||||
self.indent += ' ' * self.shiftwidth
|
||||
|
||||
def indent_pop(self):
|
||||
# type: () -> None
|
||||
"""Decrease indentation by one level."""
|
||||
assert self.indent != '', 'Already at top level indentation'
|
||||
self.indent = self.indent[0:-self.shiftwidth]
|
||||
|
||||
def line(self, s=None):
|
||||
# type: (str) -> None
|
||||
"""Add an indented line."""
|
||||
if s:
|
||||
self.lines.append('{}{}\n'.format(self.indent, s))
|
||||
else:
|
||||
self.lines.append('\n')
|
||||
|
||||
def outdented_line(self, s):
|
||||
# type: (str) -> None
|
||||
"""
|
||||
Emit a line outdented one level.
|
||||
|
||||
This is used for '} else {' and similar things inside a single indented
|
||||
block.
|
||||
"""
|
||||
self.lines.append('{}{}\n'.format(self.indent[0:-self.shiftwidth], s))
|
||||
|
||||
def writelines(self, f=None):
|
||||
# type: (Any) -> None
|
||||
"""Write all lines to `f`."""
|
||||
if not f:
|
||||
f = sys.stdout
|
||||
f.writelines(self.lines)
|
||||
|
||||
def update_file(self, filename, directory):
|
||||
# type: (str, str) -> None
|
||||
if directory is not None:
|
||||
filename = os.path.join(directory, filename)
|
||||
with open(filename, 'w') as f:
|
||||
self.writelines(f)
|
||||
|
||||
class _IndentedScope(object):
|
||||
def __init__(self, fmt, after):
|
||||
# type: (Formatter, str) -> None
|
||||
self.fmt = fmt
|
||||
self.after = after
|
||||
|
||||
def __enter__(self):
|
||||
# type: () -> None
|
||||
self.fmt.indent_push()
|
||||
|
||||
def __exit__(self, t, v, tb):
|
||||
# type: (object, object, object) -> None
|
||||
self.fmt.indent_pop()
|
||||
if self.after:
|
||||
self.fmt.line(self.after)
|
||||
|
||||
def indented(self, before=None, after=None):
|
||||
# type: (str, str) -> Formatter._IndentedScope
|
||||
"""
|
||||
Return a scope object for use with a `with` statement:
|
||||
|
||||
>>> f = Formatter()
|
||||
>>> with f.indented('prefix {', '} suffix'):
|
||||
... f.line('hello')
|
||||
>>> f.writelines()
|
||||
prefix {
|
||||
hello
|
||||
} suffix
|
||||
|
||||
The optional `before` and `after` parameters are surrounding lines
|
||||
which are *not* indented.
|
||||
"""
|
||||
if before:
|
||||
self.line(before)
|
||||
return Formatter._IndentedScope(self, after)
|
||||
|
||||
def format(self, fmt, *args):
|
||||
# type: (str, *Any) -> None
|
||||
self.line(fmt.format(*args))
|
||||
|
||||
def multi_line(self, s):
|
||||
# type: (str) -> None
|
||||
"""Add one or more lines after stripping common indentation."""
|
||||
for l in parse_multiline(s):
|
||||
self.line(l)
|
||||
|
||||
def comment(self, s):
|
||||
# type: (str) -> None
|
||||
"""Add a comment line."""
|
||||
self.line('// ' + s)
|
||||
|
||||
def doc_comment(self, s):
|
||||
# type: (str) -> None
|
||||
"""Add a (multi-line) documentation comment."""
|
||||
for l in parse_multiline(s):
|
||||
self.line('/// ' + l if l else '///')
|
||||
|
||||
def match(self, m):
|
||||
# type: (Match) -> None
|
||||
"""
|
||||
Add a match expression.
|
||||
|
||||
Example:
|
||||
|
||||
>>> f = Formatter()
|
||||
>>> m = Match('x')
|
||||
>>> m.arm('Orange', ['a', 'b'], 'some body')
|
||||
>>> m.arm('Yellow', ['a', 'b'], 'some body')
|
||||
>>> m.arm('Green', ['a', 'b'], 'different body')
|
||||
>>> m.arm('Blue', ['x', 'y'], 'some body')
|
||||
>>> f.match(m)
|
||||
>>> f.writelines()
|
||||
match x {
|
||||
Orange { a, b } |
|
||||
Yellow { a, b } => {
|
||||
some body
|
||||
}
|
||||
Green { a, b } => {
|
||||
different body
|
||||
}
|
||||
Blue { x, y } => {
|
||||
some body
|
||||
}
|
||||
}
|
||||
|
||||
"""
|
||||
with self.indented('match {} {{'.format(m.expr), '}'):
|
||||
for (fields, body), names in m.arms.items():
|
||||
with self.indented('', '}'):
|
||||
names_left = len(names)
|
||||
for name in names.keys():
|
||||
fields_str = ', '.join(fields)
|
||||
if len(fields) != 0:
|
||||
fields_str = '{{ {} }} '.format(fields_str)
|
||||
names_left -= 1
|
||||
if names_left > 0:
|
||||
suffix = '|'
|
||||
else:
|
||||
suffix = '=> {'
|
||||
self.outdented_line(name + ' ' + fields_str + suffix)
|
||||
if names_left == 0:
|
||||
self.multi_line(body)
|
||||
|
||||
|
||||
def _indent(s):
|
||||
# type: (str) -> int
|
||||
"""
|
||||
Compute the indentation of s, or None of an empty line.
|
||||
|
||||
Example:
|
||||
>>> _indent("foo")
|
||||
0
|
||||
>>> _indent(" bar")
|
||||
4
|
||||
>>> _indent(" ")
|
||||
>>> _indent("")
|
||||
"""
|
||||
t = s.lstrip()
|
||||
return len(s) - len(t) if t else None
|
||||
|
||||
|
||||
def parse_multiline(s):
|
||||
# type: (str) -> List[str]
|
||||
"""
|
||||
Given a multi-line string, split it into a sequence of lines after
|
||||
stripping a common indentation, as described in the "trim" function
|
||||
from PEP 257. This is useful for strings defined with doc strings:
|
||||
>>> parse_multiline('\\n hello\\n world\\n')
|
||||
['hello', 'world']
|
||||
"""
|
||||
if not s:
|
||||
return []
|
||||
# Convert tabs to spaces (following the normal Python rules)
|
||||
# and split into a list of lines:
|
||||
lines = s.expandtabs().splitlines()
|
||||
# Determine minimum indentation (first line doesn't count):
|
||||
indent = sys.maxsize
|
||||
for line in lines[1:]:
|
||||
stripped = line.lstrip()
|
||||
if stripped:
|
||||
indent = min(indent, len(line) - len(stripped))
|
||||
# Remove indentation (first line is special):
|
||||
trimmed = [lines[0].strip()]
|
||||
if indent < sys.maxsize:
|
||||
for line in lines[1:]:
|
||||
trimmed.append(line[indent:].rstrip())
|
||||
# Strip off trailing and leading blank lines:
|
||||
while trimmed and not trimmed[-1]:
|
||||
trimmed.pop()
|
||||
while trimmed and not trimmed[0]:
|
||||
trimmed.pop(0)
|
||||
return trimmed
|
||||
|
||||
|
||||
class Match(object):
|
||||
"""
|
||||
Match formatting class.
|
||||
|
||||
Match objects collect all the information needed to emit a Rust `match`
|
||||
expression, automatically deduplicating overlapping identical arms.
|
||||
|
||||
Example:
|
||||
|
||||
>>> m = Match('x')
|
||||
>>> m.arm('Orange', ['a', 'b'], 'some body')
|
||||
>>> m.arm('Yellow', ['a', 'b'], 'some body')
|
||||
>>> m.arm('Green', ['a', 'b'], 'different body')
|
||||
>>> m.arm('Blue', ['x', 'y'], 'some body')
|
||||
>>> assert(len(m.arms) == 3)
|
||||
|
||||
Note that this class is ignorant of Rust types, and considers two fields
|
||||
with the same name to be equivalent.
|
||||
"""
|
||||
|
||||
def __init__(self, expr):
|
||||
# type: (str) -> None
|
||||
self.expr = expr
|
||||
self.arms = OrderedDict() # type: OrderedDict[Tuple[Tuple[str, ...], str], OrderedDict[str, None]] # noqa
|
||||
|
||||
def arm(self, name, fields, body):
|
||||
# type: (str, List[str], str) -> None
|
||||
key = (tuple(fields), body)
|
||||
if key not in self.arms:
|
||||
self.arms[key] = OrderedDict()
|
||||
self.arms[key][name] = None
|
||||
Reference in New Issue
Block a user