compiler/front_end/format.py

# 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 program formats an Emboss source file given on the command line.
"""

from __future__ import absolute_import
from __future__ import print_function

import argparse
import os
import sys

from compiler.front_end import format_emb
from compiler.front_end import parser
from compiler.front_end import tokenizer
from compiler.util import error


def _parse_command_line(argv):
  """Parses the given command-line arguments."""
  argparser = argparse.ArgumentParser(description='Emboss compiler front end.',
                                      prog=argv[0])
  argparser.add_argument('input_file',
                         type=str,
                         nargs='+',
                         help='.emb file to compile.')
  argparser.add_argument('--no-check-result',
                         default=True,
                         action='store_false',
                         dest='check_result',
                         help='Verify that the resulting formatted text '
                         'contains only whitespace changes.')
  argparser.add_argument('--debug-show-line-types',
                         default=False,
                         help='Show the computed type of each line.')
  argparser.add_argument('--no-edit-in-place',
                         default=True,
                         action='store_false',
                         dest='edit_in_place',
                         help='Write the formatted text back to the input '
                              'file.')
  argparser.add_argument('--indent',
                         type=int,
                         default=2,
                         help='Number of spaces to use for each level of '
                         'indentation.')
  argparser.add_argument('--color-output',
                         default='if-tty',
                         choices=['always', 'never', 'if-tty', 'auto'],
                         help="Print error messages using color.  'auto' is a "
                         "synonym for 'if-tty'.")
  return argparser.parse_args(argv[1:])


def _print_errors(errors, source_codes, flags):
  use_color = (flags.color_output == 'always' or
               (flags.color_output in ('auto', 'if-tty') and
                os.isatty(sys.stderr.fileno())))
  print(error.format_errors(errors, source_codes, use_color), file=sys.stderr)


def main(argv=()):
  flags = _parse_command_line(argv)

  if not flags.edit_in_place and len(flags.input_file) > 1:
    print('Multiple files may only be formatted without --no-edit-in-place.',
          file=sys.stderr)
    return 1

  if flags.edit_in_place and flags.debug_show_line_types:
    print('The flag --debug-show-line-types requires --no-edit-in-place.',
          file=sys.stderr)
    return 1

  for file_name in flags.input_file:
    with open(file_name) as f:
      source_code = f.read()

    tokens, errors = tokenizer.tokenize(source_code, file_name)
    if errors:
      _print_errors(errors, {file_name: source_code}, flags)
      continue

    parse_result = parser.parse_module(tokens)
    if parse_result.error:
      _print_errors(
          [error.make_error_from_parse_error(file_name, parse_result.error)],
          {file_name: source_code},
          flags)
      continue

    formatted_text = format_emb.format_emboss_parse_tree(
        parse_result.parse_tree,
        format_emb.Config(show_line_types=flags.debug_show_line_types,
                          indent_width=flags.indent))

    if flags.check_result and not flags.debug_show_line_types:
      errors = format_emb.sanity_check_format_result(formatted_text,
                                                     source_code)
      if errors:
        for e in errors:
          print(e, file=sys.stderr)
        continue

    if flags.edit_in_place:
      with open(file_name, 'w') as f:
        f.write(formatted_text)
    else:
      sys.stdout.write(formatted_text)

  return 0


if __name__ == '__main__':
  sys.exit(main(sys.argv))