#!/usr/bin/env python  """ Lichen Python-like compiler tool.  Copyright (C) 2016, 2017 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>. """  VERSION = "0.1"  from errors import * from os import environ, listdir, remove, rename from os.path import abspath, exists, extsep, isdir, isfile, join, split from pyparser import error from subprocess import Popen, PIPE from time import time import importer, deducer, optimiser, generator, translator import sys  libdirs = [     join(split(__file__)[0], "lib"),     split(__file__)[0],     "/usr/share/lichen/lib"     ]  def load_module(filename, module_name):     for libdir in libdirs:         path = join(libdir, filename)         if exists(path):             return i.load_from_file(path, module_name)     return None  def show_missing(missing):     missing = list(missing)     missing.sort()     for module_name, name in missing:         print >>sys.stderr, "Module %s references an unknown object: %s" % (module_name, name)  def show_syntax_error(exc):     print >>sys.stderr, "Syntax error at column %d on line %d in file %s:" % (exc.offset, exc.lineno, exc.filename)     print >>sys.stderr     print >>sys.stderr, exc.text.rstrip()     print >>sys.stderr, " " * exc.offset + "^"  def stopwatch(activity, now):     print >>sys.stderr, "%s took %.2f seconds" % (activity, time() - now)     return time()  def call(tokens, verbose=False):     out = not verbose and PIPE or None     cmd = Popen(tokens, stdout=out, stderr=out)     stdout, stderr = cmd.communicate()     return cmd.wait()  def start_arg_list(l, arg, prefix, needed):      """     Add to 'l' any value given as part of 'arg' having the given option     'prefix'. The 'needed' number of values is provided in case no value is     found.      Return 'l' and 'needed' decremented by 1 together in a tuple.     """      s = arg[len(prefix):].strip()     if s:         l.append(s)         return l, needed - 1     else:         return l, needed  def getvalue(l, i):     if l and len(l) > i:         return l[i]     else:         return None  def remove_all(dirname):      "Remove 'dirname' and its contents."      for filename in listdir(dirname):         pathname = join(dirname, filename)         if isdir(pathname):             remove_all(pathname)         else:             remove(pathname)  # Main program.  if __name__ == "__main__":     basename = split(sys.argv[0])[-1]     args = sys.argv[1:]     path = libdirs      # Show help text if requested or if no arguments are given.      if "--help" in args or "-h" in args or "-?" in args or not args:         print >>sys.stderr, """\ Usage: %s [ <options> ] <filename>  Compile the program whose principal file is given in place of <filename>. The following options may be specified:  -c          Only partially compile the program; do not build or link it --compile   Equivalent to -c -E          Ignore environment variables affecting the module search path --no-env    Equivalent to -E -g          Generate debugging information for the built executable --debug     Equivalent to -g -G          Remove superfluous sections of the built executable --gc-sections Equivalent to -G -P          Show the module search path --show-path Equivalent to -P -q          Silence messages produced when building an executable --quiet     Equivalent to -q -r          Reset (discard) cached information; inspect the whole program again --reset     Equivalent to -r -R          Reset (discard) all program details including translated code --reset-all Equivalent to -R -t          Silence timing messages --no-timing Equivalent to -t -tb         Provide a traceback for any internal errors (development only) --traceback Equivalent to -tb -v          Report compiler activities in a verbose fashion (development only) --verbose   Equivalent to -v  Some options may be followed by values, either immediately after the option (without any space between) or in the arguments that follow them:  -o          Indicate the output executable name -W          Show warnings on the topics indicated  Currently, the following warnings are supported:  all         Show all possible warnings  args        Show invocations where a callable may be involved that cannot accept             the arguments provided  Control over program organisation can be exercised using the following options with each requiring an input filename providing a particular form of information:  --attr-codes        Attribute codes identifying named object attributes --attr-locations    Attribute locations in objects --param-codes       Parameter codes identifying named parameters --param-locations   Parameter locations in signatures  The following informational options can be specified to produce output instead of compiling a program:  --help      Show a summary of the command syntax and options -h          Equivalent to --help -?          Equivalent to --help --version   Show version information for this tool -V          Equivalent to --version """ % basename         sys.exit(1)      # Show the version information if requested.      elif "--version" in args or "-V" in args:         print >>sys.stderr, """\ lplc %s Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,               2014, 2015, 2016, 2017 Paul Boddie <paul@boddie.org.uk> This program is free software; you may redistribute it under the terms of the GNU General Public License version 3 or (at your option) a later version. This program has absolutely no warranty. """ % VERSION         sys.exit(1)      # Determine the options and arguments.      attrnames = []     attrlocations = []     debug = False     gc_sections = False     ignore_env = False     make = True     make_verbose = True     outputs = []     paramnames = []     paramlocations = []     reset = False     reset_all = False     timings = True     traceback = False     verbose = False     warnings = []      unrecognised = []     filenames = []      # Obtain program filenames by default.      l = filenames     needed = None      for arg in args:         if arg == "--attr-codes": l = attrnames; needed = 1         elif arg == "--attr-locations": l = attrlocations; needed = 1         elif arg in ("-c", "--compile"): make = False         elif arg in ("-E", "--no-env"): ignore_env = True         elif arg in ("-g", "--debug"): debug = True         elif arg in ("-G", "--gc-sections"): gc_sections = True         # "P" handled below.         elif arg == "--param-codes": l = paramnames; needed = 1         elif arg == "--param-locations": l = paramlocations; needed = 1         elif arg in ("-q", "--quiet"): make_verbose = False         elif arg in ("-r", "--reset"): reset = True         elif arg in ("-R", "--reset-all"): reset_all = True         elif arg in ("-t", "--no-timing"): timings = False         elif arg in ("-tb", "--traceback"): traceback = True         elif arg.startswith("-o"): l, needed = start_arg_list(outputs, arg, "-o", 1)         elif arg in ("-v", "--verbose"): verbose = True         elif arg.startswith("-W"): l, needed = start_arg_list(warnings, arg, "-W", 1)         elif arg.startswith("-"): unrecognised.append(arg)         else:             l.append(arg)             if needed:                 needed -= 1          if needed == 0:             l = filenames      # Report unrecognised options.      if unrecognised:         print >>sys.stderr, "The following options were not recognised: %s" % ", ".join(unrecognised)         sys.exit(1)      # Add extra components to the module search path from the environment.      if not ignore_env:         extra = environ.get("LICHENPATH")         if extra:             libdirs = extra.split(":") + libdirs      # Show the module search path if requested.      if "-P" in args or "--show-path" in args:         for libdir in libdirs:             print libdir         sys.exit(0)      # Obtain the program filename.      if len(filenames) != 1:         print >>sys.stderr, "One main program file must be specified."         sys.exit(1)      filename = abspath(filenames[0])      if not isfile(filename):         print >>sys.stderr, "Filename %s is not a valid input." % filenames[0]         sys.exit(1)      path.append(split(filename)[0])      # Obtain the output filename.      if outputs and not make:         print >>sys.stderr, "Output specified but building disabled."      output = outputs and outputs[0] or "_main"      # Define the output data directories.      datadir = "%s%s%s" % (output, extsep, "lplc") # _main.lplc by default     cache_dir = join(datadir, "_cache")     deduced_dir = join(datadir, "_deduced")     output_dir = join(datadir, "_output")     generated_dir = join(datadir, "_generated")      # Perform any full reset of the working data.      if reset_all:         remove_all(datadir)              # Load the program.      try:         if timings: now = time()          i = importer.Importer(path, cache_dir, verbose, warnings)         m = i.initialise(filename, reset)         success = i.finalise()          if timings: now = stopwatch("Inspection", now)          # Check for success, indicating missing references otherwise.          if not success:             show_missing(i.missing)             sys.exit(1)          d = deducer.Deducer(i, deduced_dir)         d.to_output()          if timings: now = stopwatch("Deduction", now)          o = optimiser.Optimiser(i, d, output_dir,                                 getvalue(attrnames, 0), getvalue(attrlocations, 0),                                 getvalue(paramnames, 0), getvalue(paramlocations, 0))         o.to_output()          if timings: now = stopwatch("Optimisation", now)          # Detect structure or signature changes demanding a reset of the         # generated sources.          reset = reset or o.need_reset()          g = generator.Generator(i, o, generated_dir)         g.to_output(reset, debug, gc_sections)          if timings: now = stopwatch("Generation", now)          t = translator.Translator(i, d, o, generated_dir)         t.to_output(reset, debug, gc_sections)          if timings: now = stopwatch("Translation", now)          # Compile the program unless otherwise indicated.          if make:             make_clean_cmd = ["make", "-C", generated_dir, "clean"]             make_cmd = make_clean_cmd[:-1]              retval = call(make_cmd, make_verbose)              if not retval:                 if timings: stopwatch("Compilation", now)             else:                 sys.exit(retval)              # Move the executable into the current directory.              rename(join(generated_dir, "main"), output)      # Report any errors.      except error.SyntaxError, exc:         show_syntax_error(exc)         if traceback:             raise         sys.exit(1)      except ProcessingError, exc:         print exc         if traceback:             raise         sys.exit(1)      else:         sys.exit(0)  # vim: tabstop=4 expandtab shiftwidth=4