--- /dev/null
+-------------------------------------------------------------------------------
+-- Copyright (c) 2006-2013 Fabien Fleutot and others.
+--
+-- All rights reserved.
+--
+-- This program and the accompanying materials are made available
+-- under the terms of the Eclipse Public License v1.0 which
+-- accompanies this distribution, and is available at
+-- http://www.eclipse.org/legal/epl-v10.html
+--
+-- This program and the accompanying materials are also made available
+-- under the terms of the MIT public license which accompanies this
+-- distribution, and is available at http://www.lua.org/license.html
+--
+-- Contributors:
+-- Fabien Fleutot - API and implementation
+--
+-------------------------------------------------------------------------------
+
+-- Survive lack of checks
+if not pcall(require, 'checks') then function package.preload.checks() function checks() end end end
+
+-- Main file for the metalua executable
+require 'metalua.loader' -- load *.mlue files
+require 'metalua.compiler.globals' -- metalua-aware loadstring, dofile etc.
+
+local alt_getopt = require 'alt_getopt'
+local pp = require 'metalua.pprint'
+local mlc = require 'metalua.compiler'
+
+local M = { }
+
+local AST_COMPILE_ERROR_NUMBER = -1
+local RUNTIME_ERROR_NUMBER = -3
+
+local alt_getopt_options = "f:l:e:o:xivaASbs"
+
+local long_opts = {
+ file='f',
+ library='l',
+ literal='e',
+ output='o',
+ run='x',
+ interactive='i',
+ verbose='v',
+ ['print-ast']='a',
+ ['print-ast-lineinfo']='A',
+ ['print-src']='S',
+ ['meta-bugs']='b',
+ ['sharp-bang']='s',
+}
+
+local chunk_options = {
+ library=1,
+ file=1,
+ literal=1
+}
+
+local usage=[[
+
+Compile and/or execute metalua programs. Parameters passed to the
+compiler should be prefixed with an option flag, hinting what must be
+done with them: take tham as file names to compile, as library names
+to load, as parameters passed to the running program... When option
+flags are absent, metalua tries to adopt a "Do What I Mean" approach:
+
+- if no code (no library, no literal expression and no file) is
+ specified, the first flag-less parameter is taken as a file name to
+ load.
+
+- if no code and no parameter is passed, an interactive loop is
+ started.
+
+- if a target file is specified with --output, the program is not
+ executed by default, unless a --run flag forces it to. Conversely,
+ if no --output target is specified, the code is run unless ++run
+ forbids it.
+]]
+
+function M.cmdline_parser(...)
+ local argv = {...}
+ local opts, optind, optarg =
+ alt_getopt.get_ordered_opts({...}, alt_getopt_options, long_opts)
+ --pp.printf("argv=%s; opts=%s, ending at %i, with optarg=%s",
+ -- argv, opts, optind, optarg)
+ local s2l = { } -- short to long option names conversion table
+ for long, short in pairs(long_opts) do s2l[short]=long end
+ local cfg = { chunks = { } }
+ for i, short in pairs(opts) do
+ local long = s2l[short]
+ if chunk_options[long] then table.insert(cfg.chunks, { tag=long, optarg[i] })
+ else cfg[long] = optarg[i] or true end
+ end
+ cfg.params = { select(optind, ...) }
+ return cfg
+end
+
+function M.main (...)
+
+ local cfg = M.cmdline_parser(...)
+
+ -------------------------------------------------------------------
+ -- Print messages if in verbose mode
+ -------------------------------------------------------------------
+ local function verb_print (fmt, ...)
+ if cfg.verbose then
+ return pp.printf ("[ "..fmt.." ]", ...)
+ end
+ end
+
+ if cfg.verbose then
+ verb_print("raw options: %s", cfg)
+ end
+
+ -------------------------------------------------------------------
+ -- If there's no chunk but there are params, interpret the first
+ -- param as a file name.
+ if not next(cfg.chunks) and next(cfg.params) then
+ local the_file = table.remove(cfg.params, 1)
+ verb_print("Param %q considered as a source file", the_file)
+ cfg.file={ the_file }
+ end
+
+ -------------------------------------------------------------------
+ -- If nothing to do, run REPL loop
+ if not next(cfg.chunks) and not cfg.interactive then
+ verb_print "Nothing to compile nor run, force interactive loop"
+ cfg.interactive=true
+ end
+
+
+ -------------------------------------------------------------------
+ -- Run if asked to, or if no --output has been given
+ -- if cfg.run==false it's been *forced* to false, don't override.
+ if not cfg.run and not cfg.output then
+ verb_print("No output file specified; I'll run the program")
+ cfg.run = true
+ end
+
+ local code = { }
+
+ -------------------------------------------------------------------
+ -- Get ASTs from sources
+
+ local last_file_idx
+ for i, x in ipairs(cfg.chunks) do
+ local compiler = mlc.new()
+ local tag, val = x.tag, x[1]
+ verb_print("Compiling %s", x)
+ local st, ast
+ if tag=='library' then
+ ast = { tag='Call',
+ {tag='Id', "require" },
+ {tag='String', val } }
+ elseif tag=='literal' then ast = compiler :src_to_ast(val)
+ elseif tag=='file' then
+ ast = compiler :srcfile_to_ast(val)
+ -- Isolate each file in a separate fenv
+ ast = { tag='Call',
+ { tag='Function', { { tag='Dots'} }, ast },
+ { tag='Dots' } }
+ ast.source = '@'..val
+ code.source = '@'..val
+ last_file_idx = i
+ else
+ error ("Bad option "..tag)
+ end
+ local valid = true -- TODO: check AST's correctness
+ if not valid then
+ pp.printf ("Cannot compile %s:\n%s", x, ast or "no msg")
+ os.exit (AST_COMPILE_ERROR_NUMBER)
+ end
+ ast.origin = x
+ table.insert(code, ast)
+ end
+ -- The last file returns the whole chunk's result
+ if last_file_idx then
+ -- transform +{ (function(...) -{ast} end)(...) }
+ -- into +{ return (function(...) -{ast} end)(...) }
+ local prv_ast = code[last_file_idx]
+ local new_ast = { tag='Return', prv_ast }
+ code[last_file_idx] = new_ast
+ end
+
+ -- Further uses of compiler won't involve AST transformations:
+ -- they can share the same instance.
+ -- TODO: reuse last instance if possible.
+ local compiler = mlc.new()
+
+ -------------------------------------------------------------------
+ -- AST printing
+ if cfg['print-ast'] or cfg['print-ast-lineinfo'] then
+ verb_print "Resulting AST:"
+ for _, x in ipairs(code) do
+ pp.printf("--- AST From %s: ---", x.source)
+ if x.origin and x.origin.tag=='File' then x=x[1][1][2][1] end
+ local pp_cfg = cfg['print-ast-lineinfo']
+ and { line_max=1, fix_indent=1, metalua_tag=1 }
+ or { line_max=1, metalua_tag=1, hide_hash=1 }
+ pp.print(x, 80, pp_cfg)
+ end
+ end
+
+ -------------------------------------------------------------------
+ -- Source printing
+ if cfg['print-src'] then
+ verb_print "Resulting sources:"
+ for _, x in ipairs(code) do
+ printf("--- Source From %s: ---", table.tostring(x.source, 'nohash'))
+ if x.origin and x.origin.tag=='File' then x=x[1][1][2] end
+ print (compiler :ast2string (x))
+ end
+ end
+
+ -- TODO: canonize/check AST
+
+ local bytecode = compiler :ast_to_bytecode (code)
+ code = nil
+
+ -------------------------------------------------------------------
+ -- Insert #!... command
+ if cfg.sharpbang then
+ local shbang = cfg.sharpbang
+ verb_print ("Adding sharp-bang directive %q", shbang)
+ if not shbang :match'^#!' then shbang = '#!' .. shbang end
+ if not shbang :match'\n$' then shbang = shbang .. '\n' end
+ bytecode = shbang .. bytecode
+ end
+
+ -------------------------------------------------------------------
+ -- Save to file
+ if cfg.output then
+ -- FIXME: handle '-'
+ verb_print ("Saving to file %q", cfg.output)
+ local file, err_msg = io.open(cfg.output, 'wb')
+ if not file then error("can't open output file: "..err_msg) end
+ file:write(bytecode)
+ file:close()
+ if cfg.sharpbang and os.getenv "OS" ~= "Windows_NT" then
+ pcall(os.execute, 'chmod a+x "'..cfg.output..'"')
+ end
+ end
+
+ -------------------------------------------------------------------
+ -- Run compiled code
+ if cfg.run then
+ verb_print "Running"
+ local f = compiler :bytecode_to_function (bytecode)
+ bytecode = nil
+ -- FIXME: isolate execution in a ring
+ -- FIXME: check for failures
+ local function print_traceback (errmsg)
+ return errmsg .. '\n' .. debug.traceback ('',2) .. '\n'
+ end
+ local function g() return f(unpack (cfg.params)) end
+ local st, msg = xpcall(g, print_traceback)
+ if not st then
+ io.stderr:write(msg)
+ os.exit(RUNTIME_ERROR_NUMBER)
+ end
+ end
+
+ -------------------------------------------------------------------
+ -- Run REPL loop
+ if cfg.interactive then
+ verb_print "Starting REPL loop"
+ require 'metalua.repl' .run()
+ end
+
+ verb_print "Done"
+
+end
+
+return M.main(...)
projects / metalua.git / blobdiff