lean2/bin/lmake

254 lines
9.2 KiB
Python
Executable file

#!/usr/bin/env python
#
# Copyright (c) 2014 Microsoft Corporation. All rights reserved.
# Released under Apache 2.0 license as described in the file LICENSE.
#
# Author: Soonho Kong
import argparse
import fnmatch
import os
import os.path
import string
import subprocess
import sys
def lean_exe_name():
""" Return a lean executable name """
import platform
if platform.system() == 'Windows':
return "lean.exe"
else:
return "lean"
def find_makefile(path, makefile_names):
""" Find makefile in a given directory.
Args:
path: a string of path to look up
makefile_names: a list of strings to search
Return:
When found, return the full path of a makefile
Otherwise, return False.
"""
for makefile in makefile_names:
makefile_pathname = os.path.join(path, makefile)
if os.path.isfile(makefile_pathname):
return makefile_pathname
return False
def find_makefile_upward(path, makefile_names):
""" Strating from a given directory, search upward to find
a makefile
Args:
path: a string of path to start the search
Return:
When found, return the full path of a makefile
Otherwise, return False.
"""
makefile = find_makefile(path, makefile_names)
if makefile:
return makefile
up = os.path.dirname(path)
if up != path:
return find_makefile_upward(up, makefile_names)
return False
def which(program):
""" Lookup program in a path """
import os
def is_exe(fpath):
return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
fpath, fname = os.path.split(program)
if fpath:
if is_exe(program):
return program
else:
for path in os.environ["PATH"].split(os.pathsep):
path = path.strip('"')
exe_file = os.path.join(path, program)
if is_exe(exe_file):
return exe_file
return None
def find_lean_exe():
""" Find a fullpath of Lean executable """
# First Look up environment variable
lean=os.environ.get('LEAN')
if lean:
return lean
# Otherwise, Look up in PATH
import platform
lean = which(lean_exe_name())
# Otherwise, look up the directory where lmake is at
script_dir = os.path.dirname(os.path.realpath(__file__))
lean = os.path.join(script_dir, lean_exe_name())
if os.path.isfile(lean):
return lean
return False
def find_lean_opt():
""" Return a list of lean options from env_var LEAN_OPTIONS """
lean_opt = os.environ.get('LEAN_OPTIONS')
return string.split(lean_opt) if lean_opt is not None else []
def call_lean(leanfile, options):
""" Call lean with options """
from collections import OrderedDict
oleanfile = leanfile[:-5] + ".olean"
lean_exe = find_lean_exe()
lean_opt = list(OrderedDict.fromkeys(find_lean_opt() + options))
cmd = [lean_exe] + lean_opt + [leanfile] + ["-o", oleanfile]
subprocess.call(cmd, stderr=subprocess.STDOUT)
def get_lean(s):
""" Given a string s, return corresponding .lean file if exists """
# xyz.olean => realpath(xyz.lean)
if len(s) > 6 and s[-6:] == ".olean":
leanfile = os.path.realpath(s[:-6] + ".lean")
return leanfile if os.path.isfile(leanfile) else None
# xyz.lean => realpath(xyz.lean)
if os.path.isfile(s) and len(s) > 5 and s[-5:] == ".lean":
return os.path.realpath(s)
# xyz => realpath(xyz.lean)
if os.path.isfile(s + ".lean"):
return os.path.realpath(s + ".lean")
return None
def get_olean(s):
""" Given a string s, return corresponding .olean file if exists """
# xyz.olean => realpath(xyz.olean)
if len(s) > 6 and s[-6:] == ".olean":
leanfile = s[:-6] + ".lean"
return os.path.realpath(s) if os.path.isfile(leanfile) else None
# xyz.lean => realpath(xyz.olean)
if os.path.isfile(s) and len(s) > 5 and s[-5:] == ".lean":
leanfile = os.path.realpath(s)
return leanfile[:-5] + ".olean"
# xyz => realpath(xyz.olean)
if os.path.isfile(s + ".lean"):
return os.path.realpath(s + ".olean")
return None
def get_target(s):
""" Extract a target from an argument
if we have "xyz.lean", return "xyz.olean"
Otherwise, return s as it is. (it might be phony target such as 'clean')
"""
oleanfile = get_olean(s)
return oleanfile if oleanfile is not None else s
def need_to_make_always(directory, lean_options):
"""Return true if "-P" option was used previously, but not this time."""
lean_new_options = " ".join(lean_options)
lean_old_options = ""
lean_options_file_name = os.path.join(directory, ".lean_options")
need_to_write = True
if os.path.isfile(lean_options_file_name):
with open(lean_options_file_name, 'r') as f:
lean_old_options = f.readline()
need_to_write = not (lean_old_options == lean_new_options)
if need_to_write:
with open(lean_options_file_name, 'w') as f:
f.write(lean_new_options)
if ("--permissive" in lean_options) or ("-P" in lean_options):
return False
if ("--permissive" in lean_old_options) or ("-P" in lean_old_options):
return True
return False
def call_makefile(directory, makefile, makefile_options, args, lean_options):
""" Call makefile with a target generated from a given arg """
need_to_update = need_to_make_always(directory, lean_options)
if need_to_update:
makefile_options.append("--always-make")
env_copy = os.environ.copy()
env_copy['LEAN'] = find_lean_exe()
lean_options_str = ' '.join(lean_options)
if env_copy.get("LEAN_OPTIONS"):
env_copy['LEAN_OPTIONS'] = env_copy['LEAN_OPTIONS'] + lean_options_str
else:
env_copy['LEAN_OPTIONS'] = lean_options_str
cmd = ["make"]
if makefile:
cmd += ["--makefile", makefile]
if directory:
cmd += ["-C", directory]
cmd += makefile_options
for arg in args:
target = get_target(arg)
cmd.append(target)
subprocess.call(cmd, stderr=subprocess.STDOUT, env=env_copy)
def check_positive(value):
ivalue = int(value)
if ivalue <= 0:
raise argparse.ArgumentTypeError("%s is an invalid positive int value" % value)
return ivalue
def parse_arg(argv):
""" Parse arguments """
parser = argparse.ArgumentParser(description='Process arguments.')
parser.add_argument('--flycheck', '-F', action='store_true', default=False, help="Use --flycheck option for Lean.")
parser.add_argument('--permissive', '-P', action='store_true', default=False, help="Use --permissive option for Lean.")
parser.add_argument('--keep-going', '-k', action='store_true', default=False, help="Continue as much as possible after an error.")
parser.add_argument('--directory', '-C', action='store', help="Change to directory dir before reading the makefiles or doing anything else.")
parser.add_argument('--always-make','-B', action='store_true', default=False, help="Unconditionally make all targets.")
parser.add_argument('--makefile', '-f', '--file', action='store', help="Use file as a makefile.")
parser.add_argument('--jobs', '-j', nargs='?', default=-1, const=-2, type=check_positive, help="Specifies the number of jobs (commands) to run simultaneously.")
parser.add_argument('--just-print', '--dry-run', '--recon', '-n', action='store_true', default=False, help="Don't actually run any commands; just print them.")
parser.add_argument('targets', nargs='*')
args = parser.parse_args(argv)
lean_options = extract_lean_options(args)
makefile_options = extract_makefile_options(args)
return (args.directory, args.makefile, makefile_options, lean_options, args.targets)
def extract_lean_options(args):
lean_options = []
if args.flycheck:
lean_options.append("--flycheck")
if args.permissive:
lean_options.append("--permissive")
return lean_options
def extract_makefile_options(args):
makefile_options = []
if args.keep_going:
makefile_options.append("--keep-going")
if args.jobs == -1:
# -j is not used
pass
elif args.jobs == -2:
# -j is used but without providing number of processes
makefile_options.append("-j")
elif args.jobs:
makefile_options += ["-j", args.jobs]
if args.just_print:
makefile_options.append("--just-print")
if args.always_make:
makefile_options.append("--always-make")
return makefile_options
def main(argv=None):
if argv is None:
argv = sys.argv[1:]
(directory, makefile, makefile_options, lean_options, args) = parse_arg(argv)
working_dir = os.getcwd()
if makefile is None and directory is None:
makefile_names = ["GNUmakefile", "makefile", "Makefile"]
makefile = find_makefile_upward(working_dir, makefile_names)
if makefile:
directory = os.path.dirname(makefile)
if directory or makefile:
call_makefile(directory, makefile, makefile_options, args, lean_options)
else:
for arg in args:
leanfile = get_lean(arg)
if leanfile and os.path.isfile(leanfile):
call_lean(leanfile, lean_options)
if __name__ == "__main__":
sys.exit(main())