------------------------------------------------------------------------------
-- DynASM. A dynamic assembler for code generation engines.
-- Originally designed and implemented for LuaJIT.
--
-- Copyright (C) 2005-2017 Mike Pall. All rights reserved.
-- See below for full copyright notice.
------------------------------------------------------------------------------

-- Application information.
local _info = {
    name = "DynASM",
    description = "A dynamic assembler for code generation engines",
    version = "1.4.0",
    vernum = 10400,
    release = "2015-10-18",
    author = "Mike Pall",
    url = "http://luajit.org/dynasm.html",
    license = "MIT",
    copyright = [[
Copyright (C) 2005-2017 Mike Pall. All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

[ MIT license: http://www.opensource.org/licenses/mit-license.php ]
]],
}

-- Cache library functions.
local type, pairs, ipairs = type, pairs, ipairs
local pcall, error, assert = pcall, error, assert
local _s = string
local sub, match, gmatch, gsub = _s.sub, _s.match, _s.gmatch, _s.gsub
local format, rep, upper = _s.format, _s.rep, _s.upper
local _t = table
local insert, remove, concat, sort = _t.insert, _t.remove, _t.concat, _t.sort
local exit = os.exit
local io = io
local stdin, stdout, stderr = io.stdin, io.stdout, io.stderr

------------------------------------------------------------------------------

-- Program options.
local g_opt = {}

-- Global state for current file.
local g_fname, g_curline, g_indent, g_lineno, g_synclineno, g_arch
local g_errcount = 0

-- Write buffer for output file.
local g_wbuffer, g_capbuffer

------------------------------------------------------------------------------

-- Write an output line (or callback function) to the buffer.
local function wline(line, needindent)
    local buf = g_capbuffer or g_wbuffer
    buf[#buf + 1] = needindent and g_indent .. line or line
    g_synclineno = g_synclineno + 1
end

-- Write assembler line as a comment, if requestd.
local function wcomment(aline)
    if g_opt.comment then
        wline(g_opt.comment .. aline .. g_opt.endcomment, true)
    end
end

-- Resync CPP line numbers.
local function wsync()
    if g_synclineno ~= g_lineno and g_opt.cpp then
        wline("#line " .. g_lineno .. ' "' .. g_fname .. '"')
        g_synclineno = g_lineno
    end
end

-- Dummy action flush function. Replaced with arch-specific function later.
local function wflush(term)
end

-- Dump all buffered output lines.
local function wdumplines(out, buf)
    for _, line in ipairs(buf) do
        if type(line) == "string" then
            assert(out:write(line, "\n"))
        else
            -- Special callback to dynamically insert lines after end of processing.
            line(out)
        end
    end
end

------------------------------------------------------------------------------

-- Emit an error. Processing continues with next statement.
local function werror(msg)
    error(format("%s:%s: error: %s:\n%s", g_fname, g_lineno, msg, g_curline), 0)
end

-- Emit a fatal error. Processing stops.
local function wfatal(msg)
    g_errcount = "fatal"
    werror(msg)
end

-- Print a warning. Processing continues.
local function wwarn(msg)
    stderr:write(format("%s:%s: warning: %s:\n%s\n",
            g_fname, g_lineno, msg, g_curline))
end

-- Print caught error message. But suppress excessive errors.
local function wprinterr(...)
    if type(g_errcount) == "number" then
        -- Regular error.
        g_errcount = g_errcount + 1
        if g_errcount < 21 then
            -- Seems to be a reasonable limit.
            stderr:write(...)
        elseif g_errcount == 21 then
            stderr:write(g_fname,
                    ":*: warning: too many errors (suppressed further messages).\n")
        end
    else
        -- Fatal error.
        stderr:write(...)
        return true -- Stop processing.
    end
end

------------------------------------------------------------------------------

-- Map holding all option handlers.
local opt_map = {}
local opt_current

-- Print error and exit with error status.
local function opterror(...)
    stderr:write("dynasm.lua: ERROR: ", ...)
    stderr:write("\n")
    exit(1)
end

-- Get option parameter.
local function optparam(args)
    local argn = args.argn
    local p = args[argn]
    if not p then
        opterror("missing parameter for option `", opt_current, "'.")
    end
    args.argn = argn + 1
    return p
end

------------------------------------------------------------------------------

-- Core pseudo-opcodes.
local map_coreop = {}
-- Dummy opcode map. Replaced by arch-specific map.
local map_op = {}

-- Forward declarations.
local dostmt
local readfile

------------------------------------------------------------------------------

-- Map for defines (initially empty, chains to arch-specific map).
local map_def = {}

-- Pseudo-opcode to define a substitution.
map_coreop[".define_2"] = function(params, nparams)
    if not params then
        return nparams == 1 and "name" or "name, subst"
    end
    local name, def = params[1], params[2] or "1"
    if not match(name, "^[%a_][%w_]*$") then
        werror("bad or duplicate define")
    end
    map_def[name] = def
end
map_coreop[".define_1"] = map_coreop[".define_2"]

-- Define a substitution on the command line.
function opt_map.D(args)
    local namesubst = optparam(args)
    local name, subst = match(namesubst, "^([%a_][%w_]*)=(.*)$")
    if name then
        map_def[name] = subst
    elseif match(namesubst, "^[%a_][%w_]*$") then
        map_def[namesubst] = "1"
    else
        opterror("bad define")
    end
end

-- Undefine a substitution on the command line.
function opt_map.U(args)
    local name = optparam(args)
    if match(name, "^[%a_][%w_]*$") then
        map_def[name] = nil
    else
        opterror("bad define")
    end
end

-- Helper for definesubst.
local gotsubst

local function definesubst_one(word)
    local subst = map_def[word]
    if subst then
        gotsubst = word;
        return subst
    else
        return word
    end
end

-- Iteratively substitute defines.
local function definesubst(stmt)
    -- Limit number of iterations.
    for i = 1, 100 do
        gotsubst = false
        stmt = gsub(stmt, "#?[%w_]+", definesubst_one)
        if not gotsubst then
            break
        end
    end
    if gotsubst then
        wfatal("recursive define involving `" .. gotsubst .. "'")
    end
    return stmt
end

-- Dump all defines.
local function dumpdefines(out, lvl)
    local t = {}
    for name in pairs(map_def) do
        t[#t + 1] = name
    end
    sort(t)
    out:write("Defines:\n")
    for _, name in ipairs(t) do
        local subst = map_def[name]
        if g_arch then
            subst = g_arch.revdef(subst)
        end
        out:write(format("  %-20s %s\n", name, subst))
    end
    out:write("\n")
end

------------------------------------------------------------------------------

-- Support variables for conditional assembly.
local condlevel = 0
local condstack = {}

-- Evaluate condition with a Lua expression. Substitutions already performed.
local function cond_eval(cond)
    local func, err
    if setfenv then
        func, err = loadstring("return " .. cond, "=expr")
    else
        -- No globals. All unknown identifiers evaluate to nil.
        func, err = load("return " .. cond, "=expr", "t", {})
    end
    if func then
        if setfenv then
            setfenv(func, {}) -- No globals. All unknown identifiers evaluate to nil.
        end
        local ok, res = pcall(func)
        if ok then
            if res == 0 then
                return false
            end -- Oh well.
            return not not res
        end
        err = res
    end
    wfatal("bad condition: " .. err)
end

-- Skip statements until next conditional pseudo-opcode at the same level.
local function stmtskip()
    local dostmt_save = dostmt
    local lvl = 0
    dostmt = function(stmt)
        local op = match(stmt, "^%s*(%S+)")
        if op == ".if" then
            lvl = lvl + 1
        elseif lvl ~= 0 then
            if op == ".endif" then
                lvl = lvl - 1
            end
        elseif op == ".elif" or op == ".else" or op == ".endif" then
            dostmt = dostmt_save
            dostmt(stmt)
        end
    end
end

-- Pseudo-opcodes for conditional assembly.
map_coreop[".if_1"] = function(params)
    if not params then
        return "condition"
    end
    local lvl = condlevel + 1
    local res = cond_eval(params[1])
    condlevel = lvl
    condstack[lvl] = res
    if not res then
        stmtskip()
    end
end

map_coreop[".elif_1"] = function(params)
    if not params then
        return "condition"
    end
    if condlevel == 0 then
        wfatal(".elif without .if")
    end
    local lvl = condlevel
    local res = condstack[lvl]
    if res then
        if res == "else" then
            wfatal(".elif after .else")
        end
    else
        res = cond_eval(params[1])
        if res then
            condstack[lvl] = res
            return
        end
    end
    stmtskip()
end

map_coreop[".else_0"] = function(params)
    if condlevel == 0 then
        wfatal(".else without .if")
    end
    local lvl = condlevel
    local res = condstack[lvl]
    condstack[lvl] = "else"
    if res then
        if res == "else" then
            wfatal(".else after .else")
        end
        stmtskip()
    end
end

map_coreop[".endif_0"] = function(params)
    local lvl = condlevel
    if lvl == 0 then
        wfatal(".endif without .if")
    end
    condlevel = lvl - 1
end

-- Check for unfinished conditionals.
local function checkconds()
    if g_errcount ~= "fatal" and condlevel ~= 0 then
        wprinterr(g_fname, ":*: error: unbalanced conditional\n")
    end
end

------------------------------------------------------------------------------

-- Search for a file in the given path and open it for reading.
local function pathopen(path, name)
    local dirsep = package and match(package.path, "\\") and "\\" or "/"
    for _, p in ipairs(path) do
        local fullname = p == "" and name or p .. dirsep .. name
        local fin = io.open(fullname, "r")
        if fin then
            g_fname = fullname
            return fin
        end
    end
end

-- Include a file.
map_coreop[".include_1"] = function(params)
    if not params then
        return "filename"
    end
    local name = params[1]
    -- Save state. Ugly, I know. but upvalues are fast.
    local gf, gl, gcl, gi = g_fname, g_lineno, g_curline, g_indent
    -- Read the included file.
    local fatal = readfile(pathopen(g_opt.include, name) or
            wfatal("include file `" .. name .. "' not found"))
    -- Restore state.
    g_synclineno = -1
    g_fname, g_lineno, g_curline, g_indent = gf, gl, gcl, gi
    if fatal then
        wfatal("in include file")
    end
end

-- Make .include and conditionals initially available, too.
map_op[".include_1"] = map_coreop[".include_1"]
map_op[".if_1"] = map_coreop[".if_1"]
map_op[".elif_1"] = map_coreop[".elif_1"]
map_op[".else_0"] = map_coreop[".else_0"]
map_op[".endif_0"] = map_coreop[".endif_0"]

------------------------------------------------------------------------------

-- Support variables for macros.
local mac_capture, mac_lineno, mac_name
local mac_active = {}
local mac_list = {}

-- Pseudo-opcode to define a macro.
map_coreop[".macro_*"] = function(mparams)
    if not mparams then
        return "name [, params...]"
    end
    -- Split off and validate macro name.
    local name = remove(mparams, 1)
    if not name then
        werror("missing macro name")
    end
    if not (match(name, "^[%a_][%w_%.]*$") or match(name, "^%.[%w_%.]*$")) then
        wfatal("bad macro name `" .. name .. "'")
    end
    -- Validate macro parameter names.
    local mdup = {}
    for _, mp in ipairs(mparams) do
        if not match(mp, "^[%a_][%w_]*$") then
            wfatal("bad macro parameter name `" .. mp .. "'")
        end
        if mdup[mp] then
            wfatal("duplicate macro parameter name `" .. mp .. "'")
        end
        mdup[mp] = true
    end
    -- Check for duplicate or recursive macro definitions.
    local opname = name .. "_" .. #mparams
    if map_op[opname] or map_op[name .. "_*"] then
        wfatal("duplicate macro `" .. name .. "' (" .. #mparams .. " parameters)")
    end
    if mac_capture then
        wfatal("recursive macro definition")
    end

    -- Enable statement capture.
    local lines = {}
    mac_lineno = g_lineno
    mac_name = name
    mac_capture = function(stmt)
        -- Statement capture function.
        -- Stop macro definition with .endmacro pseudo-opcode.
        if not match(stmt, "^%s*.endmacro%s*$") then
            lines[#lines + 1] = stmt
            return
        end
        mac_capture = nil
        mac_lineno = nil
        mac_name = nil
        mac_list[#mac_list + 1] = opname
        -- Add macro-op definition.
        map_op[opname] = function(params)
            if not params then
                return mparams, lines
            end
            -- Protect against recursive macro invocation.
            if mac_active[opname] then
                wfatal("recursive macro invocation")
            end
            mac_active[opname] = true
            -- Setup substitution map.
            local subst = {}
            for i, mp in ipairs(mparams) do
                subst[mp] = params[i]
            end
            local mcom
            if g_opt.maccomment and g_opt.comment then
                mcom = " MACRO " .. name .. " (" .. #mparams .. ")"
                wcomment("{" .. mcom)
            end
            -- Loop through all captured statements
            for _, stmt in ipairs(lines) do
                -- Substitute macro parameters.
                local st = gsub(stmt, "[%w_]+", subst)
                st = definesubst(st)
                st = gsub(st, "%s*%.%.%s*", "") -- Token paste a..b.
                if mcom and sub(st, 1, 1) ~= "|" then
                    wcomment(st)
                end
                -- Emit statement. Use a protected call for better diagnostics.
                local ok, err = pcall(dostmt, st)
                if not ok then
                    -- Add the captured statement to the error.
                    wprinterr(err, "\n", g_indent, "|  ", stmt,
                            "\t[MACRO ", name, " (", #mparams, ")]\n")
                end
            end
            if mcom then
                wcomment("}" .. mcom)
            end
            mac_active[opname] = nil
        end
    end
end

-- An .endmacro pseudo-opcode outside of a macro definition is an error.
map_coreop[".endmacro_0"] = function(params)
    wfatal(".endmacro without .macro")
end

-- Dump all macros and their contents (with -PP only).
local function dumpmacros(out, lvl)
    sort(mac_list)
    out:write("Macros:\n")
    for _, opname in ipairs(mac_list) do
        local name = sub(opname, 1, -3)
        local params, lines = map_op[opname]()
        out:write(format("  %-20s %s\n", name, concat(params, ", ")))
        if lvl > 1 then
            for _, line in ipairs(lines) do
                out:write("  |", line, "\n")
            end
            out:write("\n")
        end
    end
    out:write("\n")
end

-- Check for unfinished macro definitions.
local function checkmacros()
    if mac_capture then
        wprinterr(g_fname, ":", mac_lineno,
                ": error: unfinished .macro `", mac_name, "'\n")
    end
end

------------------------------------------------------------------------------

-- Support variables for captures.
local cap_lineno, cap_name
local cap_buffers = {}
local cap_used = {}

-- Start a capture.
map_coreop[".capture_1"] = function(params)
    if not params then
        return "name"
    end
    wflush()
    local name = params[1]
    if not match(name, "^[%a_][%w_]*$") then
        wfatal("bad capture name `" .. name .. "'")
    end
    if cap_name then
        wfatal("already capturing to `" .. cap_name .. "' since line " .. cap_lineno)
    end
    cap_name = name
    cap_lineno = g_lineno
    -- Create or continue a capture buffer and start the output line capture.
    local buf = cap_buffers[name]
    if not buf then
        buf = {};
        cap_buffers[name] = buf
    end
    g_capbuffer = buf
    g_synclineno = 0
end

-- Stop a capture.
map_coreop[".endcapture_0"] = function(params)
    wflush()
    if not cap_name then
        wfatal(".endcapture without a valid .capture")
    end
    cap_name = nil
    cap_lineno = nil
    g_capbuffer = nil
    g_synclineno = 0
end

-- Dump a capture buffer.
map_coreop[".dumpcapture_1"] = function(params)
    if not params then
        return "name"
    end
    wflush()
    local name = params[1]
    if not match(name, "^[%a_][%w_]*$") then
        wfatal("bad capture name `" .. name .. "'")
    end
    cap_used[name] = true
    wline(function(out)
        local buf = cap_buffers[name]
        if buf then
            wdumplines(out, buf)
        end
    end)
    g_synclineno = 0
end

-- Dump all captures and their buffers (with -PP only).
local function dumpcaptures(out, lvl)
    out:write("Captures:\n")
    for name, buf in pairs(cap_buffers) do
        out:write(format("  %-20s %4s)\n", name, "(" .. #buf))
        if lvl > 1 then
            local bar = rep("=", 76)
            out:write("  ", bar, "\n")
            for _, line in ipairs(buf) do
                out:write("  ", line, "\n")
            end
            out:write("  ", bar, "\n\n")
        end
    end
    out:write("\n")
end

-- Check for unfinished or unused captures.
local function checkcaptures()
    if cap_name then
        wprinterr(g_fname, ":", cap_lineno,
                ": error: unfinished .capture `", cap_name, "'\n")
        return
    end
    for name in pairs(cap_buffers) do
        if not cap_used[name] then
            wprinterr(g_fname, ":*: error: missing .dumpcapture ", name, "\n")
        end
    end
end

------------------------------------------------------------------------------

-- Sections names.
local map_sections = {}

-- Pseudo-opcode to define code sections.
-- TODO: Data sections, BSS sections. Needs extra C code and API.
map_coreop[".section_*"] = function(params)
    if not params then
        return "name..."
    end
    if #map_sections > 0 then
        werror("duplicate section definition")
    end
    wflush()
    for sn, name in ipairs(params) do
        local opname = "." .. name .. "_0"
        if not match(name, "^[%a][%w_]*$") or
                map_op[opname] or map_op["." .. name .. "_*"] then
            werror("bad section name `" .. name .. "'")
        end
        map_sections[#map_sections + 1] = name
        wline(format("#define DASM_SECTION_%s\t%d", upper(name), sn - 1))
        map_op[opname] = function(params)
            g_arch.section(sn - 1)
        end
    end
    wline(format("#define DASM_MAXSECTION\t\t%d", #map_sections))
end

-- Dump all sections.
local function dumpsections(out, lvl)
    out:write("Sections:\n")
    for _, name in ipairs(map_sections) do
        out:write(format("  %s\n", name))
    end
    out:write("\n")
end

------------------------------------------------------------------------------

-- Replacement for customized Lua, which lacks the package library.
local prefix = ""
if not require then
    function require(name)
        local fp = assert(io.open(prefix .. name .. ".lua"))
        local s = fp:read("*a")
        assert(fp:close())
        return assert(loadstring(s, "@" .. name .. ".lua"))()
    end
end

-- Load architecture-specific module.
local function loadarch(arch)
    if not match(arch, "^[%w_]+$") then
        return "bad arch name"
    end
    local ok, m_arch = pcall(require, "dasm_" .. arch)
    if not ok then
        return "cannot load module: " .. m_arch
    end
    g_arch = m_arch
    wflush = m_arch.passcb(wline, werror, wfatal, wwarn)
    m_arch.setup(arch, g_opt)
    map_op, map_def = m_arch.mergemaps(map_coreop, map_def)
end

-- Dump architecture description.
function opt_map.dumparch(args)
    local name = optparam(args)
    if not g_arch then
        local err = loadarch(name)
        if err then
            opterror(err)
        end
    end

    local t = {}
    for name in pairs(map_coreop) do
        t[#t + 1] = name
    end
    for name in pairs(map_op) do
        t[#t + 1] = name
    end
    sort(t)

    local out = stdout
    local _arch = g_arch._info
    out:write(format("%s version %s, released %s, %s\n",
            _info.name, _info.version, _info.release, _info.url))
    g_arch.dumparch(out)

    local pseudo = true
    out:write("Pseudo-Opcodes:\n")
    for _, sname in ipairs(t) do
        local name, nparam = match(sname, "^(.+)_([0-9%*])$")
        if name then
            if pseudo and sub(name, 1, 1) ~= "." then
                out:write("\nOpcodes:\n")
                pseudo = false
            end
            local f = map_op[sname]
            local s
            if nparam ~= "*" then
                nparam = nparam + 0
            end
            if nparam == 0 then
                s = ""
            elseif type(f) == "string" then
                s = map_op[".template__"](nil, f, nparam)
            else
                s = f(nil, nparam)
            end
            if type(s) == "table" then
                for _, s2 in ipairs(s) do
                    out:write(format("  %-12s %s\n", name, s2))
                end
            else
                out:write(format("  %-12s %s\n", name, s))
            end
        end
    end
    out:write("\n")
    exit(0)
end

-- Pseudo-opcode to set the architecture.
-- Only initially available (map_op is replaced when called).
map_op[".arch_1"] = function(params)
    if not params then
        return "name"
    end
    local err = loadarch(params[1])
    if err then
        wfatal(err)
    end
    wline(format("#if DASM_VERSION != %d", _info.vernum))
    wline('#error "Version mismatch between DynASM and included encoding engine"')
    wline("#endif")
end

-- Dummy .arch pseudo-opcode to improve the error report.
map_coreop[".arch_1"] = function(params)
    if not params then
        return "name"
    end
    wfatal("duplicate .arch statement")
end

------------------------------------------------------------------------------

-- Dummy pseudo-opcode. Don't confuse '.nop' with 'nop'.
map_coreop[".nop_*"] = function(params)
    if not params then
        return "[ignored...]"
    end
end

-- Pseudo-opcodes to raise errors.
map_coreop[".error_1"] = function(params)
    if not params then
        return "message"
    end
    werror(params[1])
end

map_coreop[".fatal_1"] = function(params)
    if not params then
        return "message"
    end
    wfatal(params[1])
end

-- Dump all user defined elements.
local function dumpdef(out)
    local lvl = g_opt.dumpdef
    if lvl == 0 then
        return
    end
    dumpsections(out, lvl)
    dumpdefines(out, lvl)
    if g_arch then
        g_arch.dumpdef(out, lvl)
    end
    dumpmacros(out, lvl)
    dumpcaptures(out, lvl)
end

------------------------------------------------------------------------------

-- Helper for splitstmt.
local splitlvl

local function splitstmt_one(c)
    if c == "(" then
        splitlvl = ")" .. splitlvl
    elseif c == "[" then
        splitlvl = "]" .. splitlvl
    elseif c == "{" then
        splitlvl = "}" .. splitlvl
    elseif c == ")" or c == "]" or c == "}" then
        if sub(splitlvl, 1, 1) ~= c then
            werror("unbalanced (), [] or {}")
        end
        splitlvl = sub(splitlvl, 2)
    elseif splitlvl == "" then
        return " \0 "
    end
    return c
end

-- Split statement into (pseudo-)opcode and params.
local function splitstmt(stmt)
    -- Convert label with trailing-colon into .label statement.
    local label = match(stmt, "^%s*(.+):%s*$")
    if label then
        return ".label", { label }
    end

    -- Split at commas and equal signs, but obey parentheses and brackets.
    splitlvl = ""
    stmt = gsub(stmt, "[,%(%)%[%]{}]", splitstmt_one)
    if splitlvl ~= "" then
        werror("unbalanced () or []")
    end

    -- Split off opcode.
    local op, other = match(stmt, "^%s*([^%s%z]+)%s*(.*)$")
    if not op then
        werror("bad statement syntax")
    end

    -- Split parameters.
    local params = {}
    for p in gmatch(other, "%s*(%Z+)%z?") do
        params[#params + 1] = gsub(p, "%s+$", "")
    end
    if #params > 16 then
        werror("too many parameters")
    end

    params.op = op
    return op, params
end

-- Process a single statement.
dostmt = function(stmt)
    -- Ignore empty statements.
    if match(stmt, "^%s*$") then
        return
    end

    -- Capture macro defs before substitution.
    if mac_capture then
        return mac_capture(stmt)
    end

    stmt = definesubst(stmt)
    -- Emit C code without parsing the line.
    if sub(stmt, 1, 1) == "|" then
        local tail = sub(stmt, 2)
        wflush()
        if sub(tail, 1, 2) == "//" then
            wcomment(tail)
        else
            wline(tail, true)
        end
        return
    end

    -- Split into (pseudo-)opcode and params.
    local op, params = splitstmt(stmt)

    -- Get opcode handler (matching # of parameters or generic handler).
    local f = map_op[op .. "_" .. #params] or map_op[op .. "_*"]

    if not f then
        if not g_arch then
            wfatal("first statement must be .arch")
        end
        -- Improve error report.
        for i = 0, 9 do
            if map_op[op .. "_" .. i] then
                werror("wrong number of parameters for `" .. op .. "'")
            end
        end
        werror("unknown statement `" .. op .. "'")
    end

    -- Call opcode handler or special handler for template strings.
    if type(f) == "string" then
        map_op[".template__"](params, f)
    else
        f(params)
    end
end

-- Process a single line.
local function doline(line)
    if g_opt.flushline then
        wflush()
    end

    -- Assembler line?
    local indent, aline = match(line, "^(%s*)%|(.*)$")
    if not aline then
        -- No, plain C code line, need to flush first.
        wflush()
        wsync()
        wline(line, false)
        return
    end

    g_indent = indent -- Remember current line indentation.

    -- Emit C code (even from macros). Avoids echo and line parsing.
    if sub(aline, 1, 1) == "|" then
        if not mac_capture then
            wsync()
        elseif g_opt.comment then
            wsync()
            wcomment(aline)
        end
        dostmt(aline)
        return
    end

    -- Echo assembler line as a comment.
    if g_opt.comment then
        wsync()
        wcomment(aline)
    end

    -- Strip assembler comments.
    aline = gsub(aline, "//.*$", "")

    -- Split line into statements at semicolons.
    if match(aline, ";") then
        for stmt in gmatch(aline, "[^;]+") do
            dostmt(stmt)
        end
    else
        dostmt(aline)
    end
end

------------------------------------------------------------------------------

-- Write DynASM header.
local function dasmhead(out)
    out:write(format([[
/*
** This file has been pre-processed with DynASM.
** %s
** DynASM version %s, DynASM %s version %s
** DO NOT EDIT! The original file is in "%s".
*/

]], _info.url,
            _info.version, g_arch._info.arch, g_arch._info.version,
            g_fname))
end

-- Read input file.
readfile = function(fin)
    g_indent = ""
    g_lineno = 0
    g_synclineno = -1

    -- Process all lines.
    for line in fin:lines() do
        g_lineno = g_lineno + 1
        g_curline = line
        local ok, err = pcall(doline, line)
        if not ok and wprinterr(err, "\n") then
            return true
        end
    end
    wflush()

    -- Close input file.
    assert(fin == stdin or fin:close())
end

-- Write output file.
local function writefile(outfile)
    local fout

    -- Open output file.
    if outfile == nil or outfile == "-" then
        fout = stdout
    else
        fout = assert(io.open(outfile, "w"))
    end

    -- Write all buffered lines
    wdumplines(fout, g_wbuffer)

    -- Close output file.
    assert(fout == stdout or fout:close())

    -- Optionally dump definitions.
    dumpdef(fout == stdout and stderr or stdout)
end

-- Translate an input file to an output file.
local function translate(infile, outfile)
    g_wbuffer = {}
    g_indent = ""
    g_lineno = 0
    g_synclineno = -1

    -- Put header.
    wline(dasmhead)

    -- Read input file.
    local fin
    if infile == "-" then
        g_fname = "(stdin)"
        fin = stdin
    else
        g_fname = infile
        fin = assert(io.open(infile, "r"))
    end
    readfile(fin)

    -- Check for errors.
    if not g_arch then
        wprinterr(g_fname, ":*: error: missing .arch directive\n")
    end
    checkconds()
    checkmacros()
    checkcaptures()

    if g_errcount ~= 0 then
        stderr:write(g_fname, ":*: info: ", g_errcount, " error",
                (type(g_errcount) == "number" and g_errcount > 1) and "s" or "",
                " in input file -- no output file generated.\n")
        dumpdef(stderr)
        exit(1)
    end

    -- Write output file.
    writefile(outfile)
end

------------------------------------------------------------------------------

-- Print help text.
function opt_map.help()
    stdout:write("DynASM -- ", _info.description, ".\n")
    stdout:write("DynASM ", _info.version, " ", _info.release, "  ", _info.url, "\n")
    stdout:write [[

Usage: dynasm [OPTION]... INFILE.dasc|-

  -h, --help           Display this help text.
  -V, --version        Display version and copyright information.

  -o, --outfile FILE   Output file name (default is stdout).
  -I, --include DIR    Add directory to the include search path.

  -c, --ccomment       Use /* */ comments for assembler lines.
  -C, --cppcomment     Use // comments for assembler lines (default).
  -N, --nocomment      Suppress assembler lines in output.
  -M, --maccomment     Show macro expansions as comments (default off).

  -L, --nolineno       Suppress CPP line number information in output.
  -F, --flushline      Flush action list for every line.

  -D NAME[=SUBST]      Define a substitution.
  -U NAME              Undefine a substitution.

  -P, --dumpdef        Dump defines, macros, etc. Repeat for more output.
  -A, --dumparch ARCH  Load architecture ARCH and dump description.
]]
    exit(0)
end

-- Print version information.
function opt_map.version()
    stdout:write(format("%s version %s, released %s\n%s\n\n%s",
            _info.name, _info.version, _info.release, _info.url, _info.copyright))
    exit(0)
end

-- Misc. options.
function opt_map.outfile(args)
    g_opt.outfile = optparam(args)
end
function opt_map.include(args)
    insert(g_opt.include, 1, optparam(args))
end
function opt_map.ccomment()
    g_opt.comment = "/*|";
    g_opt.endcomment = " */"
end
function opt_map.cppcomment()
    g_opt.comment = "//|";
    g_opt.endcomment = ""
end
function opt_map.nocomment()
    g_opt.comment = false
end
function opt_map.maccomment()
    g_opt.maccomment = true
end
function opt_map.nolineno()
    g_opt.cpp = false
end
function opt_map.flushline()
    g_opt.flushline = true
end
function opt_map.dumpdef()
    g_opt.dumpdef = g_opt.dumpdef + 1
end

------------------------------------------------------------------------------

-- Short aliases for long options.
local opt_alias = {
    h = "help", ["?"] = "help", V = "version",
    o = "outfile", I = "include",
    c = "ccomment", C = "cppcomment", N = "nocomment", M = "maccomment",
    L = "nolineno", F = "flushline",
    P = "dumpdef", A = "dumparch",
}

-- Parse single option.
local function parseopt(opt, args)
    opt_current = #opt == 1 and "-" .. opt or "--" .. opt
    local f = opt_map[opt] or opt_map[opt_alias[opt]]
    if not f then
        opterror("unrecognized option `", opt_current, "'. Try `--help'.\n")
    end
    f(args)
end

-- Parse arguments.
local function parseargs(args)
    -- Default options.
    g_opt.comment = "//|"
    g_opt.endcomment = ""
    g_opt.cpp = true
    g_opt.dumpdef = 0
    g_opt.include = { "" }

    -- Process all option arguments.
    args.argn = 1
    repeat
        local a = args[args.argn]
        if not a then
            break
        end
        local lopt, opt = match(a, "^%-(%-?)(.+)")
        if not opt then
            break
        end
        args.argn = args.argn + 1
        if lopt == "" then
            -- Loop through short options.
            for o in gmatch(opt, ".") do
                parseopt(o, args)
            end
        else
            -- Long option.
            parseopt(opt, args)
        end
    until false

    -- Check for proper number of arguments.
    local nargs = #args - args.argn + 1
    if nargs ~= 1 then
        if nargs == 0 then
            if g_opt.dumpdef > 0 then
                return dumpdef(stdout)
            end
        end
        opt_map.help()
    end

    -- Translate a single input file to a single output file
    -- TODO: Handle multiple files?
    translate(args[args.argn], g_opt.outfile)
end

------------------------------------------------------------------------------

-- Add the directory dynasm.lua resides in to the Lua module search path.
local arg = arg
if arg and arg[0] then
    prefix = match(arg[0], "^(.*[/\\])")
    if package and prefix then
        package.path = prefix .. "?.lua;" .. package.path
    end
end

-- Start DynASM.
parseargs { ... }

------------------------------------------------------------------------------

