#!/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 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

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.

    debug = False

    gc_sections = False

    ignore_env = False

    make = True

    make_verbose = True

    reset = False

    reset_all = False

    timings = True

    traceback = False

    verbose = False

    warnings = []

    filenames = []

    outputs = []

    # Obtain program filenames by default.

    l = filenames

    needed = None

    for arg in args:

        if 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

        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 == ("-v", "--verbose"): verbose = True

        elif arg.startswith("-W"): l, needed = start_arg_list(warnings, arg, "-W", 1)

        else:

            l.append(arg)

            if needed:

                needed -= 1

        if needed == 0:

            l = filenames

    # 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)

        o.to_output()

        if timings: now = stopwatch("Optimisation", now)

        g = generator.Generator(i, o, generated_dir)

        g.to_output(debug, gc_sections)

        if timings: now = stopwatch("Generation", now)

        t = translator.Translator(i, d, o, generated_dir)

        t.to_output(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