| # Copyright 2019 Google LLC |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # https://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """Formatter for Emboss source files. |
| |
| This module exports a single function, format_emboss_parse_tree(), which |
| pretty-prints an Emboss parse tree. |
| """ |
| |
| from __future__ import print_function |
| |
| import collections |
| import itertools |
| |
| from compiler.front_end import module_ir |
| from compiler.front_end import tokenizer |
| from compiler.util import parser_types |
| |
| |
| class Config(collections.namedtuple("Config", ["indent_width", "show_line_types"])): |
| """Configuration for formatting.""" |
| |
| def __new__(cls, indent_width=2, show_line_types=False): |
| return super(cls, Config).__new__(cls, indent_width, show_line_types) |
| |
| |
| class _Row(collections.namedtuple("Row", ["name", "columns", "indent"])): |
| """Structured contents of a single line.""" |
| |
| def __new__(cls, name, columns=None, indent=0): |
| return super(cls, _Row).__new__(cls, name, tuple(columns or []), indent) |
| |
| |
| class _Block(collections.namedtuple("Block", ["prefix", "header", "body"])): |
| """Structured block of multiple lines.""" |
| |
| def __new__(cls, prefix, header, body): |
| assert header |
| return super(cls, _Block).__new__(cls, prefix, header, body) |
| |
| |
| # Map of productions to their formatters. |
| _formatters = {} |
| |
| |
| def format_emboss_parse_tree(parse_tree, config, used_productions=None): |
| """Formats Emboss source code. |
| |
| Arguments: |
| parse_tree: A parse tree of an Emboss source file. |
| config: A Config tuple with formatting options. |
| used_productions: An optional set to which all used productions will be |
| added. Intended for use by test code to ensure full production |
| coverage. |
| |
| Returns: |
| A string of the reformatted source text. |
| """ |
| if hasattr(parse_tree, "children"): |
| parsed_children = [ |
| format_emboss_parse_tree(child, config, used_productions) |
| for child in parse_tree.children |
| ] |
| args = parsed_children + [config] |
| if used_productions is not None: |
| used_productions.add(parse_tree.production) |
| return _formatters[parse_tree.production](*args) |
| else: |
| assert isinstance(parse_tree, parser_types.Token), str(parse_tree) |
| return parse_tree.text |
| |
| |
| def sanity_check_format_result(formatted_text, original_text): |
| """Checks that the given texts are equivalent.""" |
| # The texts are considered equivalent if they tokenize to the same token |
| # stream, except that: |
| # |
| # Multiple consecutive newline tokens are equivalent to a single newline |
| # token. |
| # |
| # Extra newline tokens at the start of the stream should be ignored. |
| # |
| # Whitespace at the start or end of a token should be ignored. This matters |
| # for documentation and comment tokens, which may have had trailing whitespace |
| # in the original text, and for indent tokens, which may contain a different |
| # number of space and/or tab characters. |
| original_tokens, errors = tokenizer.tokenize(original_text, "") |
| if errors: |
| return ["BUG: original text is not tokenizable: {!r}".format(errors)] |
| |
| formatted_tokens, errors = tokenizer.tokenize(formatted_text, "") |
| if errors: |
| return ["BUG: formatted text is not tokenizable: {!r}".format(errors)] |
| |
| o_tokens = _collapse_newline_tokens(original_tokens) |
| f_tokens = _collapse_newline_tokens(formatted_tokens) |
| for i in range(len(o_tokens)): |
| if ( |
| o_tokens[i].symbol != f_tokens[i].symbol |
| or o_tokens[i].text.strip() != f_tokens[i].text.strip() |
| ): |
| return [ |
| "BUG: Symbol {} differs: {!r} vs {!r}".format( |
| i, o_tokens[i], f_tokens[i] |
| ) |
| ] |
| return [] |
| |
| |
| def _collapse_newline_tokens(token_list): |
| r"""Collapses multiple consecutive "\\n" tokens into a single newline.""" |
| result = [] |
| for symbol, group in itertools.groupby(token_list, lambda x: x.symbol): |
| if symbol == '"\\n"': |
| # Skip all newlines if they are at the start, otherwise add a single |
| # newline for each consecutive run of newlines. |
| if result: |
| result.append(list(group)[0]) |
| else: |
| result.extend(group) |
| return result |
| |
| |
| def _indent_row(row): |
| """Adds one level of indent to the given row, returning a new row.""" |
| assert isinstance(row, _Row), repr(row) |
| return _Row(name=row.name, columns=row.columns, indent=row.indent + 1) |
| |
| |
| def _indent_rows(rows): |
| """Adds one level of indent to the given rows, returning a new list.""" |
| return list(map(_indent_row, rows)) |
| |
| |
| def _indent_blocks(blocks): |
| """Adds one level of indent to the given blocks, returning a new list.""" |
| return [ |
| _Block( |
| prefix=_indent_rows(block.prefix), |
| header=_indent_row(block.header), |
| body=_indent_rows(block.body), |
| ) |
| for block in blocks |
| ] |
| |
| |
| def _intersperse(interspersed, sections): |
| """Intersperses `interspersed` between non-empty `sections`.""" |
| result = [] |
| for section in sections: |
| if section: |
| if result: |
| result.extend(interspersed) |
| result.extend(section) |
| return result |
| |
| |
| def _should_add_blank_lines(blocks): |
| """Returns true if blank lines should be added between blocks.""" |
| other_non_empty_lines = 0 |
| last_non_empty_lines = 0 |
| for block in blocks: |
| last_non_empty_lines = len( |
| [line for line in block.body + block.prefix if line.columns] |
| ) |
| other_non_empty_lines += last_non_empty_lines |
| # Vertical spaces should be added if there are more interior |
| # non-empty-non-header lines than header lines. |
| return len(blocks) <= other_non_empty_lines - last_non_empty_lines |
| |
| |
| def _columnize(blocks, indent_width, indent_columns=1): |
| """Aligns columns in the header rows of the given blocks. |
| |
| The `indent_columns` argument is used to determine how many columns should be |
| indented. With `indent_columns == 1`, the result would be: |
| |
| AA BB CC |
| AAA BBB CCC |
| A B C |
| |
| With `indent_columns == 2`: |
| |
| AA BB CC |
| AAA BBB CCC |
| A B C |
| |
| With `indent_columns == 1`, only the first column is indented compared to |
| surrounding rows; with `indent_columns == 2`, both the first and second |
| columns are indented. |
| |
| Arguments: |
| blocks: A list of _Blocks to columnize. |
| indent_width: The number of spaces per level of indent. |
| indent_columns: The number of columns to indent. |
| |
| Returns: |
| A list of _Rows of the prefix, header, and body _Rows of each block, where |
| the header _Rows of each type have had their columns aligned. |
| """ |
| single_width_separators = {"enum-value": {0, 1}, "field": {0}} |
| # For each type of row, figure out how many characters each column needs. |
| row_types = collections.defaultdict(lambda: collections.defaultdict(lambda: 0)) |
| for block in blocks: |
| max_lengths = row_types[block.header.name] |
| for i in range(len(block.header.columns)): |
| if i == indent_columns - 1: |
| adjustment = block.header.indent * indent_width |
| else: |
| adjustment = 0 |
| max_lengths[i] = max( |
| max_lengths[i], len(block.header.columns[i]) + adjustment |
| ) |
| |
| assert len(row_types) < 3 |
| |
| # Then, for each row, actually columnize it. |
| result = [] |
| for block in blocks: |
| columns = [] |
| for i in range(len(block.header.columns)): |
| column_width = row_types[block.header.name][i] |
| if column_width == 0: |
| # Zero-width columns are entirely omitted, including their column |
| # separators. |
| pass |
| else: |
| if i == indent_columns - 1: |
| # This function only performs the right padding for each column. |
| # Since the left padding for indent will be added later, the |
| # corresponding space needs to be removed from the right padding of |
| # the first column. |
| column_width -= block.header.indent * indent_width |
| if i in single_width_separators.get(block.header.name, []): |
| # Only one space around the "=" in enum values and between the start |
| # and size in field locations. |
| column_width += 1 |
| else: |
| column_width += 2 |
| columns.append(block.header.columns[i].ljust(column_width)) |
| result.append( |
| block.prefix |
| + [ |
| _Row( |
| block.header.name, ["".join(columns).rstrip()], block.header.indent |
| ) |
| ] |
| + block.body |
| ) |
| return result |
| |
| |
| def _indent_blanks_and_comments(rows): |
| """Indents blank and comment lines to match the next non-blank line.""" |
| result = [] |
| previous_indent = 0 |
| for row in reversed(rows): |
| if not "".join(row.columns) or row.name == "comment": |
| result.append(_Row(row.name, row.columns, previous_indent)) |
| else: |
| result.append(row) |
| previous_indent = row.indent |
| return reversed(result) |
| |
| |
| def _add_blank_rows_on_dedent(rows): |
| """Adds blank rows before dedented lines, where needed.""" |
| result = [] |
| previous_indent = 0 |
| previous_row_was_blank = True |
| for row in rows: |
| row_is_blank = not "".join(row.columns) |
| found_dedent = previous_indent > row.indent |
| if found_dedent and not previous_row_was_blank and not row_is_blank: |
| result.append(_Row("dedent-space", [], row.indent)) |
| result.append(row) |
| previous_indent = row.indent |
| previous_row_was_blank = row_is_blank |
| return result |
| |
| |
| def _render_row_to_text(row, indent_width): |
| assert len(row.columns) < 2, "{!r}".format(row) |
| text = " " * indent_width * row.indent |
| text += "".join(row.columns) |
| return text.rstrip() |
| |
| |
| def _render_rows_to_text(rows, indent_width, show_line_types): |
| max_row_name_len = max([0] + [len(row.name) for row in rows]) |
| flattened_rows = [] |
| for row in rows: |
| row_text = _render_row_to_text(row, indent_width) |
| if show_line_types: |
| row_text = row.name.ljust(max_row_name_len) + "|" + row_text |
| flattened_rows.append(row_text) |
| return "\n".join(flattened_rows + [""]) |
| |
| |
| def _check_productions(): |
| """Asserts that the productions in this module match those in module_ir.""" |
| productions_ok = True |
| for production in module_ir.PRODUCTIONS: |
| if production not in _formatters: |
| productions_ok = False |
| print("@_formats({!r})".format(str(production))) |
| |
| for production in _formatters: |
| if production not in module_ir.PRODUCTIONS: |
| productions_ok = False |
| print("not @_formats({!r})".format(str(production))) |
| |
| assert productions_ok, "Grammar mismatch." |
| |
| |
| def _formats_with_config(production_text): |
| """Marks a function as a formatter requiring a config argument.""" |
| production = parser_types.Production.parse(production_text) |
| |
| def formats(f): |
| assert production not in _formatters, production |
| _formatters[production] = f |
| return f |
| |
| return formats |
| |
| |
| def _formats(production_text): |
| """Marks a function as the formatter for a particular production.""" |
| |
| def strip_config_argument(f): |
| _formats_with_config(production_text)(lambda *a, **kw: f(*a[:-1], **kw)) |
| return f |
| |
| return strip_config_argument |
| |
| |
| ################################################################################ |
| # From here to the end of the file are functions which recursively format an |
| # Emboss parse tree. |
| # |
| # The format_parse_tree() function will call formatters, bottom-up, for the |
| # entire parse tree. Each formatter will be called with the results of the |
| # formatters for each child node. (The "formatter" for leaf nodes is the |
| # original text of the token.) |
| # |
| # Formatters can be roughly divided into three types: |
| # |
| # The _module formatter is the top-level formatter. It handles final rendering |
| # into text, and returns a string. |
| # |
| # Formatters for productions that are at least one full line return lists of |
| # _Rows. The production 'attribute-line' falls into this category, but |
| # 'attribute' does not. This form allows parallel constructs in separate lines |
| # to be lined up column-wise, even when there are intervening lines that should |
| # not be lined up -- for example, the types and names of struct fields will be |
| # aligned, even if there are documentation, comment, or attribute lines mixed |
| # in. |
| # |
| # Formatters for productions that are smaller than one full line just return |
| # strings. |
| |
| |
| @_formats_with_config( |
| "module -> comment-line* doc-line* import-line*" |
| " attribute-line* type-definition*" |
| ) |
| def _module(comments, docs, imports, attributes, types, config): |
| """Performs top-level formatting for an Emboss source file.""" |
| |
| # The top-level sections other than types should be separated by single lines. |
| header_rows = _intersperse( |
| [_Row("section-break")], |
| [ |
| _strip_empty_leading_trailing_comment_lines(comments), |
| docs, |
| imports, |
| attributes, |
| ], |
| ) |
| |
| # Top-level types should be separated by double lines from themselves and from |
| # the header rows. |
| rows = _intersperse( |
| [_Row("top-type-separator"), _Row("top-type-separator")], [header_rows] + types |
| ) |
| |
| # Final fixups. |
| rows = _indent_blanks_and_comments(rows) |
| rows = _add_blank_rows_on_dedent(rows) |
| return _render_rows_to_text(rows, config.indent_width, config.show_line_types) |
| |
| |
| @_formats("doc-line -> doc Comment? eol") |
| def _doc_line(doc, comment, eol): |
| assert not comment, "Comment should not be possible on the same line as doc." |
| return [_Row("doc", [doc])] + eol |
| |
| |
| @_formats( |
| 'import-line -> "import" string-constant "as" snake-word Comment?' |
| " eol" |
| ) |
| def _import_line(import_, filename, as_, name, comment, eol): |
| return [ |
| _Row( |
| "import", ["{} {} {} {} {}".format(import_, filename, as_, name, comment)] |
| ) |
| ] + eol |
| |
| |
| @_formats("attribute-line -> attribute Comment? eol") |
| def _attribute_line(attribute, comment, eol): |
| return [_Row("attribute", ["{} {}".format(attribute, comment)])] + eol |
| |
| |
| @_formats( |
| 'attribute -> "[" attribute-context? "$default"? snake-word ":"' |
| ' attribute-value "]"' |
| ) |
| def _attribute(open_, context, default, name, colon, value, close): |
| return "".join( |
| [open_, _concatenate_with_spaces(context, default, name + colon, value), close] |
| ) |
| |
| |
| @_formats('parameter-definition -> snake-name ":" type') |
| def _parameter_definition(name, colon, type_specifier): |
| return "{}{} {}".format(name, colon, type_specifier) |
| |
| |
| @_formats("type-definition* -> type-definition type-definition*") |
| def _type_defitinions(definition, definitions): |
| return [definition] + definitions |
| |
| |
| @_formats( |
| 'bits -> "bits" type-name delimited-parameter-definition-list? ":"' |
| " Comment? eol bits-body" |
| ) |
| @_formats( |
| 'struct -> "struct" type-name delimited-parameter-definition-list?' |
| ' ":" Comment? eol struct-body' |
| ) |
| def _structure_type(struct, name, parameters, colon, comment, eol, body): |
| return ( |
| [ |
| _Row( |
| "type-header", |
| ["{} {}{}{} {}".format(struct, name, parameters, colon, comment)], |
| ) |
| ] |
| + eol |
| + body |
| ) |
| |
| |
| @_formats('enum -> "enum" type-name ":" Comment? eol enum-body') |
| @_formats('external -> "external" type-name ":" Comment? eol external-body') |
| def _type(struct, name, colon, comment, eol, body): |
| return ( |
| [_Row("type-header", ["{} {}{} {}".format(struct, name, colon, comment)])] |
| + eol |
| + body |
| ) |
| |
| |
| @_formats_with_config( |
| "bits-body -> Indent doc-line* attribute-line*" |
| " type-definition* bits-field-block Dedent" |
| ) |
| @_formats_with_config( |
| "struct-body -> Indent doc-line* attribute-line*" |
| " type-definition* struct-field-block Dedent" |
| ) |
| def _structure_body(indent, docs, attributes, type_definitions, fields, dedent, config): |
| del indent, dedent # Unused. |
| spacing = [_Row("field-separator")] if _should_add_blank_lines(fields) else [] |
| columnized_fields = _columnize(fields, config.indent_width, indent_columns=2) |
| return _indent_rows( |
| _intersperse(spacing, [docs, attributes] + type_definitions + columnized_fields) |
| ) |
| |
| |
| @_formats('field-location -> expression "[" "+" expression "]"') |
| def _field_location(start, open_bracket, plus, size, close_bracket): |
| return [start, open_bracket + plus + size + close_bracket] |
| |
| |
| @_formats( |
| "anonymous-bits-field-block -> conditional-anonymous-bits-field-block" |
| " anonymous-bits-field-block" |
| ) |
| @_formats( |
| "anonymous-bits-field-block -> unconditional-anonymous-bits-field" |
| " anonymous-bits-field-block" |
| ) |
| @_formats("bits-field-block -> conditional-bits-field-block bits-field-block") |
| @_formats("bits-field-block -> unconditional-bits-field bits-field-block") |
| @_formats( |
| "struct-field-block -> conditional-struct-field-block" |
| " struct-field-block" |
| ) |
| @_formats("struct-field-block -> unconditional-struct-field struct-field-block") |
| @_formats( |
| "unconditional-anonymous-bits-field* ->" |
| " unconditional-anonymous-bits-field" |
| " unconditional-anonymous-bits-field*" |
| ) |
| @_formats( |
| "unconditional-anonymous-bits-field+ ->" |
| " unconditional-anonymous-bits-field" |
| " unconditional-anonymous-bits-field*" |
| ) |
| @_formats( |
| "unconditional-bits-field* -> unconditional-bits-field" |
| " unconditional-bits-field*" |
| ) |
| @_formats( |
| "unconditional-bits-field+ -> unconditional-bits-field" |
| " unconditional-bits-field*" |
| ) |
| @_formats( |
| "unconditional-struct-field* -> unconditional-struct-field" |
| " unconditional-struct-field*" |
| ) |
| @_formats( |
| "unconditional-struct-field+ -> unconditional-struct-field" |
| " unconditional-struct-field*" |
| ) |
| def _structure_block(field, block): |
| """Prepends field to block.""" |
| return field + block |
| |
| |
| @_formats( |
| 'virtual-field -> "let" snake-name "=" expression Comment? eol' |
| " field-body?" |
| ) |
| def _virtual_field(let_keyword, name, equals, value, comment, eol, body): |
| # This formatting doesn't look the best when there are blocks of several |
| # virtual fields next to each other, but works pretty well when they're |
| # intermixed with physical fields. It's probably good enough for now, since |
| # there aren't (yet) any virtual fields in real .embs, and will probably only |
| # be a few in the near future. |
| return [ |
| _Block( |
| [], |
| _Row( |
| "virtual-field", |
| [ |
| _concatenate_with( |
| " ", |
| _concatenate_with_spaces(let_keyword, name, equals, value), |
| comment, |
| ) |
| ], |
| ), |
| eol + body, |
| ) |
| ] |
| |
| |
| @_formats( |
| "field -> field-location type snake-name abbreviation?" |
| " attribute* doc? Comment? eol field-body?" |
| ) |
| def _unconditional_field( |
| location, type_, name, abbreviation, attributes, doc, comment, eol, body |
| ): |
| return [ |
| _Block( |
| [], |
| _Row( |
| "field", |
| location |
| + [ |
| type_, |
| _concatenate_with_spaces(name, abbreviation), |
| attributes, |
| doc, |
| comment, |
| ], |
| ), |
| eol + body, |
| ) |
| ] |
| |
| |
| @_formats("field-body -> Indent doc-line* attribute-line* Dedent") |
| def _field_body(indent, docs, attributes, dedent): |
| del indent, dedent # Unused |
| return _indent_rows(docs + attributes) |
| |
| |
| @_formats( |
| "anonymous-bits-field-definition ->" |
| ' field-location "bits" ":" Comment? eol anonymous-bits-body' |
| ) |
| def _inline_bits(location, bits, colon, comment, eol, body): |
| # Even though an anonymous bits field technically defines a new, anonymous |
| # type, conceptually it's more like defining a bunch of fields on the |
| # surrounding type, so it is treated as an inline list of blocks, instead of |
| # being separately formatted. |
| header_row = _Row( |
| "field", |
| [location[0], location[1] + " " + bits + colon, "", "", "", "", comment], |
| ) |
| return [_Block([], header_row, eol + body.header_lines)] + body.field_blocks |
| |
| |
| @_formats( |
| "inline-enum-field-definition ->" |
| ' field-location "enum" snake-name abbreviation? ":" Comment? eol' |
| " enum-body" |
| ) |
| @_formats( |
| "inline-struct-field-definition ->" |
| ' field-location "struct" snake-name abbreviation? ":" Comment? eol' |
| " struct-body" |
| ) |
| @_formats( |
| "inline-bits-field-definition ->" |
| ' field-location "bits" snake-name abbreviation? ":" Comment? eol' |
| " bits-body" |
| ) |
| def _inline_type(location, keyword, name, abbreviation, colon, comment, eol, body): |
| """Formats an inline type in a struct or bits.""" |
| header_row = _Row( |
| "field", |
| location |
| + [ |
| keyword, |
| _concatenate_with_spaces(name, abbreviation) + colon, |
| "", |
| "", |
| comment, |
| ], |
| ) |
| return [_Block([], header_row, eol + body)] |
| |
| |
| @_formats( |
| 'conditional-struct-field-block -> "if" expression ":" Comment? eol' |
| " Indent unconditional-struct-field+" |
| " Dedent" |
| ) |
| @_formats( |
| 'conditional-bits-field-block -> "if" expression ":" Comment? eol' |
| " Indent unconditional-bits-field+" |
| " Dedent" |
| ) |
| @_formats( |
| "conditional-anonymous-bits-field-block ->" |
| ' "if" expression ":" Comment? eol' |
| " Indent unconditional-anonymous-bits-field+ Dedent" |
| ) |
| def _conditional_field(if_, condition, colon, comment, eol, indent, body, dedent): |
| """Formats an `if` construct.""" |
| del indent, dedent # Unused |
| # The body of an 'if' should be columnized with the surrounding blocks, so |
| # much like an inline 'bits', its body is treated as an inline list of blocks. |
| header_row = _Row("if", ["{} {}{} {}".format(if_, condition, colon, comment)]) |
| indented_body = _indent_blocks(body) |
| assert indented_body, "Expected body of if condition." |
| return [ |
| _Block( |
| [header_row] + eol + indented_body[0].prefix, |
| indented_body[0].header, |
| indented_body[0].body, |
| ) |
| ] + indented_body[1:] |
| |
| |
| _InlineBitsBodyType = collections.namedtuple( |
| "InlineBitsBodyType", ["header_lines", "field_blocks"] |
| ) |
| |
| |
| @_formats( |
| "anonymous-bits-body ->" |
| " Indent attribute-line* anonymous-bits-field-block Dedent" |
| ) |
| def _inline_bits_body(indent, attributes, fields, dedent): |
| del indent, dedent # Unused |
| return _InlineBitsBodyType( |
| header_lines=_indent_rows(attributes), field_blocks=_indent_blocks(fields) |
| ) |
| |
| |
| @_formats_with_config( |
| "enum-body -> Indent doc-line* attribute-line* enum-value+" " Dedent" |
| ) |
| def _enum_body(indent, docs, attributes, values, dedent, config): |
| del indent, dedent # Unused |
| spacing = [_Row("value-separator")] if _should_add_blank_lines(values) else [] |
| columnized_values = _columnize(values, config.indent_width) |
| return _indent_rows(_intersperse(spacing, [docs, attributes] + columnized_values)) |
| |
| |
| @_formats("enum-value* -> enum-value enum-value*") |
| @_formats("enum-value+ -> enum-value enum-value*") |
| def _enum_values(value, block): |
| return value + block |
| |
| |
| @_formats( |
| 'enum-value -> constant-name "=" expression attribute* doc? Comment? eol' |
| " enum-value-body?" |
| ) |
| def _enum_value(name, equals, value, attributes, docs, comment, eol, body): |
| return [ |
| _Block( |
| [], |
| _Row("enum-value", [name, equals, value, attributes, docs, comment]), |
| eol + body, |
| ) |
| ] |
| |
| |
| @_formats("enum-value-body -> Indent doc-line* attribute-line* Dedent") |
| def _enum_value_body(indent, docs, attributes, dedent): |
| del indent, dedent # Unused |
| return _indent_rows(docs + attributes) |
| |
| |
| @_formats("external-body -> Indent doc-line* attribute-line* Dedent") |
| def _external_body(indent, docs, attributes, dedent): |
| del indent, dedent # Unused |
| return _indent_rows(_intersperse([_Row("section-break")], [docs, attributes])) |
| |
| |
| @_formats('comment-line -> Comment? "\\n"') |
| def _comment_line(comment, eol): |
| del eol # Unused |
| if comment: |
| return [_Row("comment", [comment])] |
| else: |
| return [_Row("comment")] |
| |
| |
| @_formats('eol -> "\\n" comment-line*') |
| def _eol(eol, comments): |
| del eol # Unused |
| return _strip_empty_leading_trailing_comment_lines(comments) |
| |
| |
| def _strip_empty_leading_trailing_comment_lines(comments): |
| first_non_empty_line = None |
| last_non_empty_line = None |
| for i in range(len(comments)): |
| if comments[i].columns: |
| if first_non_empty_line is None: |
| first_non_empty_line = i |
| last_non_empty_line = i |
| if first_non_empty_line is None: |
| return [] |
| else: |
| return comments[first_non_empty_line : last_non_empty_line + 1] |
| |
| |
| @_formats("attribute-line* -> ") |
| @_formats("anonymous-bits-field-block -> ") |
| @_formats("bits-field-block -> ") |
| @_formats("comment-line* -> ") |
| @_formats("doc-line* -> ") |
| @_formats("enum-value* -> ") |
| @_formats("enum-value-body? -> ") |
| @_formats("field-body? -> ") |
| @_formats("import-line* -> ") |
| @_formats("struct-field-block -> ") |
| @_formats("type-definition* -> ") |
| @_formats("unconditional-anonymous-bits-field* -> ") |
| @_formats("unconditional-bits-field* -> ") |
| @_formats("unconditional-struct-field* -> ") |
| def _empty_list(): |
| return [] |
| |
| |
| @_formats("abbreviation? -> ") |
| @_formats("additive-expression-right* -> ") |
| @_formats("and-expression-right* -> ") |
| @_formats("argument-list -> ") |
| @_formats("array-length-specifier* -> ") |
| @_formats("attribute* -> ") |
| @_formats("attribute-context? -> ") |
| @_formats("comma-then-expression* -> ") |
| @_formats("Comment? -> ") |
| @_formats('"$default"? -> ') |
| @_formats("delimited-argument-list? -> ") |
| @_formats("delimited-parameter-definition-list? -> ") |
| @_formats("doc? -> ") |
| @_formats("equality-expression-right* -> ") |
| @_formats("equality-or-greater-expression-right* -> ") |
| @_formats("equality-or-less-expression-right* -> ") |
| @_formats("field-reference-tail* -> ") |
| @_formats("or-expression-right* -> ") |
| @_formats("parameter-definition-list -> ") |
| @_formats("parameter-definition-list-tail* -> ") |
| @_formats("times-expression-right* -> ") |
| @_formats("type-size-specifier? -> ") |
| def _empty_string(): |
| return "" |
| |
| |
| @_formats("abbreviation? -> abbreviation") |
| @_formats('additive-operator -> "-"') |
| @_formats('additive-operator -> "+"') |
| @_formats('and-operator -> "&&"') |
| @_formats("attribute-context? -> attribute-context") |
| @_formats("attribute-value -> expression") |
| @_formats("attribute-value -> string-constant") |
| @_formats("boolean-constant -> BooleanConstant") |
| @_formats("bottom-expression -> boolean-constant") |
| @_formats("bottom-expression -> builtin-reference") |
| @_formats("bottom-expression -> constant-reference") |
| @_formats("bottom-expression -> field-reference") |
| @_formats("bottom-expression -> numeric-constant") |
| @_formats('builtin-field-word -> "$max_size_in_bits"') |
| @_formats('builtin-field-word -> "$max_size_in_bytes"') |
| @_formats('builtin-field-word -> "$min_size_in_bits"') |
| @_formats('builtin-field-word -> "$min_size_in_bytes"') |
| @_formats('builtin-field-word -> "$size_in_bits"') |
| @_formats('builtin-field-word -> "$size_in_bytes"') |
| @_formats("builtin-reference -> builtin-word") |
| @_formats('builtin-word -> "$is_statically_sized"') |
| @_formats('builtin-word -> "$next"') |
| @_formats('builtin-word -> "$static_size_in_bits"') |
| @_formats("choice-expression -> logical-expression") |
| @_formats("Comment? -> Comment") |
| @_formats("comparison-expression -> additive-expression") |
| @_formats("constant-name -> constant-word") |
| @_formats("constant-reference -> constant-reference-tail") |
| @_formats("constant-reference-tail -> constant-word") |
| @_formats("constant-word -> ShoutyWord") |
| @_formats('"$default"? -> "$default"') |
| @_formats("delimited-argument-list? -> delimited-argument-list") |
| @_formats("doc? -> doc") |
| @_formats("doc -> Documentation") |
| @_formats("enum-value-body? -> enum-value-body") |
| @_formats('equality-operator -> "=="') |
| @_formats("equality-or-greater-expression-right -> equality-expression-right") |
| @_formats("equality-or-greater-expression-right -> greater-expression-right") |
| @_formats("equality-or-less-expression-right -> equality-expression-right") |
| @_formats("equality-or-less-expression-right -> less-expression-right") |
| @_formats("expression -> choice-expression") |
| @_formats("field-body? -> field-body") |
| @_formats('function-name -> "$lower_bound"') |
| @_formats('function-name -> "$present"') |
| @_formats('function-name -> "$max"') |
| @_formats('function-name -> "$upper_bound"') |
| @_formats('greater-operator -> ">="') |
| @_formats('greater-operator -> ">"') |
| @_formats('inequality-operator -> "!="') |
| @_formats('less-operator -> "<="') |
| @_formats('less-operator -> "<"') |
| @_formats("logical-expression -> and-expression") |
| @_formats("logical-expression -> comparison-expression") |
| @_formats("logical-expression -> or-expression") |
| @_formats('multiplicative-operator -> "*"') |
| @_formats("negation-expression -> bottom-expression") |
| @_formats("numeric-constant -> Number") |
| @_formats('or-operator -> "||"') |
| @_formats("snake-name -> snake-word") |
| @_formats("snake-reference -> builtin-field-word") |
| @_formats("snake-reference -> snake-word") |
| @_formats("snake-word -> SnakeWord") |
| @_formats("string-constant -> String") |
| @_formats("type-definition -> bits") |
| @_formats("type-definition -> enum") |
| @_formats("type-definition -> external") |
| @_formats("type-definition -> struct") |
| @_formats("type-name -> type-word") |
| @_formats("type-reference-tail -> type-word") |
| @_formats("type-reference -> type-reference-tail") |
| @_formats("type-size-specifier? -> type-size-specifier") |
| @_formats("type-word -> CamelWord") |
| @_formats("unconditional-anonymous-bits-field -> field") |
| @_formats("unconditional-anonymous-bits-field -> inline-bits-field-definition") |
| @_formats("unconditional-anonymous-bits-field -> inline-enum-field-definition") |
| @_formats("unconditional-bits-field -> unconditional-anonymous-bits-field") |
| @_formats("unconditional-bits-field -> virtual-field") |
| @_formats("unconditional-struct-field -> anonymous-bits-field-definition") |
| @_formats("unconditional-struct-field -> field") |
| @_formats("unconditional-struct-field -> inline-bits-field-definition") |
| @_formats("unconditional-struct-field -> inline-enum-field-definition") |
| @_formats("unconditional-struct-field -> inline-struct-field-definition") |
| @_formats("unconditional-struct-field -> virtual-field") |
| def _identity(x): |
| return x |
| |
| |
| @_formats("argument-list -> expression comma-then-expression*") |
| @_formats("times-expression -> negation-expression times-expression-right*") |
| @_formats( |
| "type -> type-reference delimited-argument-list? type-size-specifier?" |
| " array-length-specifier*" |
| ) |
| @_formats('array-length-specifier -> "[" expression "]"') |
| @_formats( |
| "array-length-specifier* -> array-length-specifier" |
| " array-length-specifier*" |
| ) |
| @_formats('type-size-specifier -> ":" numeric-constant') |
| @_formats('attribute-context -> "(" snake-word ")"') |
| @_formats('constant-reference -> snake-reference "." constant-reference-tail') |
| @_formats('constant-reference-tail -> type-word "." constant-reference-tail') |
| @_formats('constant-reference-tail -> type-word "." snake-reference') |
| @_formats('type-reference-tail -> type-word "." type-reference-tail') |
| @_formats("field-reference -> snake-reference field-reference-tail*") |
| @_formats('abbreviation -> "(" snake-word ")"') |
| @_formats("additive-expression-right -> additive-operator times-expression") |
| @_formats( |
| "additive-expression-right* -> additive-expression-right" |
| " additive-expression-right*" |
| ) |
| @_formats("additive-expression -> times-expression additive-expression-right*") |
| @_formats('array-length-specifier -> "[" "]"') |
| @_formats('delimited-argument-list -> "(" argument-list ")"') |
| @_formats( |
| "delimited-parameter-definition-list? ->" " delimited-parameter-definition-list" |
| ) |
| @_formats( |
| "delimited-parameter-definition-list ->" ' "(" parameter-definition-list ")"' |
| ) |
| @_formats( |
| "parameter-definition-list -> parameter-definition" |
| " parameter-definition-list-tail*" |
| ) |
| @_formats( |
| "parameter-definition-list-tail* -> parameter-definition-list-tail" |
| " parameter-definition-list-tail*" |
| ) |
| @_formats( |
| "times-expression-right -> multiplicative-operator" |
| " negation-expression" |
| ) |
| @_formats( |
| "times-expression-right* -> times-expression-right" |
| " times-expression-right*" |
| ) |
| @_formats('field-reference-tail -> "." snake-reference') |
| @_formats("field-reference-tail* -> field-reference-tail field-reference-tail*") |
| @_formats("negation-expression -> additive-operator bottom-expression") |
| @_formats('type-reference -> snake-word "." type-reference-tail') |
| @_formats('bottom-expression -> "(" expression ")"') |
| @_formats('bottom-expression -> function-name "(" argument-list ")"') |
| @_formats( |
| "comma-then-expression* -> comma-then-expression" |
| " comma-then-expression*" |
| ) |
| @_formats("or-expression-right* -> or-expression-right or-expression-right*") |
| @_formats( |
| "less-expression-right-list -> equality-expression-right*" |
| " less-expression-right" |
| " equality-or-less-expression-right*" |
| ) |
| @_formats("or-expression-right+ -> or-expression-right or-expression-right*") |
| @_formats("and-expression -> comparison-expression and-expression-right+") |
| @_formats( |
| "comparison-expression -> additive-expression" |
| " greater-expression-right-list" |
| ) |
| @_formats( |
| "comparison-expression -> additive-expression" |
| " equality-expression-right+" |
| ) |
| @_formats("or-expression -> comparison-expression or-expression-right+") |
| @_formats( |
| "equality-expression-right+ -> equality-expression-right" |
| " equality-expression-right*" |
| ) |
| @_formats("and-expression-right* -> and-expression-right and-expression-right*") |
| @_formats( |
| "equality-or-greater-expression-right* ->" |
| " equality-or-greater-expression-right" |
| " equality-or-greater-expression-right*" |
| ) |
| @_formats("and-expression-right+ -> and-expression-right and-expression-right*") |
| @_formats( |
| "equality-or-less-expression-right* ->" |
| " equality-or-less-expression-right" |
| " equality-or-less-expression-right*" |
| ) |
| @_formats( |
| "equality-expression-right* -> equality-expression-right" |
| " equality-expression-right*" |
| ) |
| @_formats( |
| "greater-expression-right-list ->" |
| " equality-expression-right* greater-expression-right" |
| " equality-or-greater-expression-right*" |
| ) |
| @_formats( |
| "comparison-expression -> additive-expression" |
| " less-expression-right-list" |
| ) |
| def _concatenate(*elements): |
| """Concatenates all arguments with no delimiters.""" |
| return "".join(elements) |
| |
| |
| @_formats("equality-expression-right -> equality-operator additive-expression") |
| @_formats("less-expression-right -> less-operator additive-expression") |
| @_formats("greater-expression-right -> greater-operator additive-expression") |
| @_formats("or-expression-right -> or-operator comparison-expression") |
| @_formats("and-expression-right -> and-operator comparison-expression") |
| def _concatenate_with_prefix_spaces(*elements): |
| return "".join(" " + element for element in elements if element) |
| |
| |
| @_formats("attribute* -> attribute attribute*") |
| @_formats('comma-then-expression -> "," expression') |
| @_formats( |
| "comparison-expression -> additive-expression inequality-operator" |
| " additive-expression" |
| ) |
| @_formats( |
| 'choice-expression -> logical-expression "?" logical-expression' |
| ' ":" logical-expression' |
| ) |
| @_formats('parameter-definition-list-tail -> "," parameter-definition') |
| def _concatenate_with_spaces(*elements): |
| return _concatenate_with(" ", *elements) |
| |
| |
| def _concatenate_with(joiner, *elements): |
| return joiner.join(element for element in elements if element) |
| |
| |
| @_formats("attribute-line* -> attribute-line attribute-line*") |
| @_formats("comment-line* -> comment-line comment-line*") |
| @_formats("doc-line* -> doc-line doc-line*") |
| @_formats("import-line* -> import-line import-line*") |
| def _concatenate_lists(head, tail): |
| return head + tail |
| |
| |
| _check_productions() |
