From 6c9a9f0cd64b9d2c6cbbe3ec0ca1774a0a582c9d Mon Sep 17 00:00:00 2001
From: Andre Murbach Maidl <andremm@gmail.com>
Date: Sun, 4 Aug 2013 10:40:15 -0300
Subject: [PATCH] Uploading Lua Assembler/Disassembler for Lua 5.1

---
 5.1/assembler.lua      |  844 +++++++++++++++++++++++++++++++++
 5.1/disassembler.lua   | 1016 ++++++++++++++++++++++++++++++++++++++++
 5.1/manual/logo1.png   |  Bin 0 -> 11125 bytes
 5.1/manual/manual.html |  739 +++++++++++++++++++++++++++++
 4 files changed, 2599 insertions(+)
 create mode 100644 5.1/assembler.lua
 create mode 100644 5.1/disassembler.lua
 create mode 100644 5.1/manual/logo1.png
 create mode 100644 5.1/manual/manual.html

diff --git a/5.1/assembler.lua b/5.1/assembler.lua
new file mode 100644
index 0000000..fb89b18
--- /dev/null
+++ b/5.1/assembler.lua
@@ -0,0 +1,844 @@
+--[[
+Lua Assembler
+Version 0.1
+Author: Andre Murbach Maidl
+]]
+
+-- requires LPeg re module
+require "re"
+
+-- usage message
+USAGE = [[
+usage: %s [options] [filename]
+Available options are:
+-h	print this help
+-b	big endian (default is little endian)
+-o name output to file name (default is %s)
+]]
+
+-- global settings
+config = {}
+config.SIGNATURE   = "\27Lua"
+config.VERSION     = 81
+config.FORMAT      = 0
+config.ENDIANNESS  = 1
+config.INT         = 4
+config.SIZE_T      = 8
+config.INSTRUCTION = 4
+config.LUA_NUMBER  = 8
+config.INTEGRAL    = 0
+config.SIZE_C      = 9
+config.SIZE_B      = 9
+config.SIZE_Bx     = config.SIZE_C + config.SIZE_B
+config.SIZE_A      = 8
+config.SIZE_OP     = 6
+config.POS_OP      = 0
+config.POS_A       = config.POS_OP + config.SIZE_OP
+config.POS_C       = config.POS_A + config.SIZE_A
+config.POS_B       = config.POS_C + config.SIZE_C
+config.POS_Bx      = config.POS_C
+config.iABC 	   = { config.SIZE_OP, config.SIZE_A, config.SIZE_C,  config.SIZE_B }
+config.MASK_OP 	   = math.ldexp(1, config.SIZE_OP)
+config.MASK_A      = math.ldexp(1, config.SIZE_A)
+config.MASK_B      = math.ldexp(1, config.SIZE_B)
+config.MASK_C      = math.ldexp(1, config.SIZE_C)
+config.MASK_Bx     = math.ldexp(1, config.SIZE_Bx)
+config.MAXARG_sBx  = math.floor((config.MASK_Bx - 1) / 2)
+config.BITRK       = math.ldexp(1, config.SIZE_B - 1)
+
+-- global types
+types = {}
+types.LUA_TNIL     = 0
+types.LUA_TBOOLEAN = 1
+types.LUA_TNUMBER  = 3
+types.LUA_TSTRING  = 4
+
+-- opcodes
+opcode = {}
+opcode = { ["MOVE"] = 0, ["LOADK"] = 1, ["LOADBOOL"] = 2, ["LOADNIL"] = 3,
+           ["GETUPVAL"] = 4, ["GETGLOBAL"] = 5, ["GETTABLE"] = 6,
+           ["SETGLOBAL"] = 7, ["SETUPVAL"] = 8, ["SETTABLE"] = 9,
+           ["NEWTABLE"] = 10, ["SELF"] = 11, ["ADD"] = 12, ["SUB"] = 13,
+           ["MUL"] = 14, ["DIV"] = 15, ["MOD"] = 16, ["POW"] = 17,
+           ["UNM"] = 18, ["NOT"] = 19, ["LEN"] = 20, ["CONCAT"] = 21,
+           ["JMP"] = 22, ["EQ"] = 23, ["LT"] = 24, ["LE"] = 25, ["TEST"] = 26,
+           ["TESTSET"] = 27, ["CALL"] = 28, ["TAILCALL"] = 29, ["RETURN"] = 30,
+           ["FORLOOP"] = 31, ["FORPREP"] = 32, ["TFORLOOP"] = 33, ["SETLIST"] = 34,
+           ["CLOSE"] = 35, ["CLOSURE"] = 36, ["VARARG"] = 37 }
+
+-- opcode modes
+opmode = {}
+opmode.iABC  = 0
+opmode.iABx  = 1
+opmode.iAsBx = 2
+
+-- global options
+options = {}
+options.INPUT   = nil
+options.OUTPUT  = "d.out"
+options.GENOUT  = true
+
+-- table to store parsed data
+parsed = {}
+
+num_par = {}
+num_par["main"] = 0
+
+-- Assembly grammar
+grammar = [[
+  prog <- ( <function> )* -> {}
+  function <- <header> ( <instruction> )+ -> {}
+  header <- ( %nl )* <s> (<user> / <main>) <s> ( %nl )+
+  user <- ( "function" <s> {<name>} <s> ":" )
+  main <- ( {"main"} <s> "function" <s> ":" )
+  number <- <hex> / <float> / <int>
+  int <- "-"? [0-9]+
+  e <- [eE][+-]?[0-9]+
+  float <- "-"? ([0-9]+"."[0-9]* / "."[0-9]+) <e>? / "-"? [0-9]+ <e>
+  hex <- "-"? "0"[xX][0-9a-fA-F]+
+  name <- [a-zA-Z_][a-zA-Z0-9_]*
+  label <- <name> ":"
+  string <- '"' ('\\' / '\"' / !'"' .)* '"'
+  instruction <- ( <s> ( {<label>} / <number>)? <s> <ln>? <s> {<op>} ( <s> {<param>} )+ <s> ( %nl )+ ) -> {}
+  op <- [A-Z]+
+  param <- <register> / <number> / <name> / <string>
+  register <- ( "R[" <number> "]" )
+  s <- ( !%nl %s )*
+  ln <- "[" <number> "]"
+]]
+
+-- prints usage message
+function usage(msg)
+  if msg ~= nil then
+    io.write(string.format("%s: %s\n", arg[0], msg))
+  end
+  io.write(string.format(USAGE, arg[0], options.OUTPUT))
+  os.exit(1)
+end
+
+-- parse args
+function doargs()
+  local i = 1
+  while i <= #arg do
+    if string.find(arg[i], "^-") == nil then
+      options.INPUT = arg[i]
+      break
+    elseif arg[i] == "-h" then usage()
+    elseif arg[i] == "-b" then config.ENDIANNESS = 0
+    elseif arg[i] == "-o" then
+      i = i + 1
+      if arg[i] == nil then usage("'-o' needs argument") else options.OUTPUT = arg[i] end
+    else usage(string.format("'%s' unkown option", arg[i]))
+    end
+    i = i + 1
+  end
+end
+
+-- print table - debug only
+function print_table(table)
+  for k,v in pairs(table) do if k > 2 then print_table (table[k]) end end
+end
+
+-- print error message
+function print_error(msg)
+  io.write(string.format("ERROR: %s\n", msg))
+end
+
+-- check if is function or instructions table
+function is_func_name(n)
+  if n % 2 ~= 0 then return true end
+  return false
+end
+
+-- parse a register
+function parse_reg(r)
+  local pattern = re.compile [[ reg <- "R[" {%d+} "]" -> "" ]]
+  return (pattern:match(r))
+end
+
+-- parse constant type
+function parse_const_type(c)
+  local pattern = re.compile [[ c <- <nil> / <n> / <b> / <s>
+nil <- "nil" -> "0"
+b <- t / f / tt / ff
+t <- "TRUE" -> "1"
+f <- "FALSE" -> "1"
+tt <- "true" -> "1"
+ff <- "false" -> "1"
+n <- float / int
+int <- "-"? [0-9]+ -> "3"
+float <- "-"? [0-9]+? "."? [0-9]+ ( [eE] "-"? [0-9]+)? -> "3"
+s <- nc / bc
+nc <- %w+ -> "4" 
+bc <- '"' ( !'"' . / '\"' .)* '"' -> "4"
+]]
+  return (pattern:match(c))
+end
+
+-- parse boolean
+function parse_bool(b)
+  if b == "TRUE" then return 1 end
+  return 0
+end
+
+-- get opcode mode
+function get_op_mode(o)
+  if o == "JMP" or o == "FORLOOP" or o == "FORPREP" then
+    return opmode.iAsBx
+  elseif o == "LOADK" or o == "GETGLOBAL" or o == "SETGLOBAL" or o == "CLOSURE" then
+    return opmode.iABx
+  end
+  return opmode.iABC
+end
+
+-- set a register if it doesn't exist on table parsed
+function set_reg(r, parsed)
+  if not parsed["register"] then
+    parsed["max_stack_size"] = 0
+    parsed["register"] = {}
+  end
+  if not parsed["register"][r] then
+    local n = parsed["max_stack_size"]
+    if tonumber(r) >= parsed["max_stack_size"] then parsed["max_stack_size"] = tonumber(r)+1 end
+    parsed["register"][r] = n
+  end
+end
+
+-- set an opcode for instruction n
+function set_op(o, parsed, n)
+  parsed["instruction"][n]["O"] = o
+end
+
+-- set argument A for instruction n
+function set_arg_a(a, parsed, n)
+  parsed["instruction"][n]["A"] = a
+end
+
+-- set argument B for instruction n
+function set_arg_b(b, parsed, n)
+  parsed["instruction"][n]["B"] = b
+end
+
+-- set argument C for instruction n
+function set_arg_c(c, parsed, n)
+  parsed["instruction"][n]["C"] = c
+end
+
+-- set argument Bx for instruction n
+function set_arg_bx(bx, parsed, n)
+  parsed["instruction"][n]["Bx"] = bx
+end
+
+-- set argument sBx for instrction n
+function set_arg_sbx(bx, parsed, n)
+  parsed["instruction"][n]["sBx"] = bx
+end
+
+-- set a constant if it doesn't exist
+function set_const(c, parsed)
+  if not parsed["number_of_constants"] then
+    parsed["number_of_constants"] = 0
+    parsed["const"] = {}
+    parsed["constant"] = {}
+  end
+
+  local t = parse_const_type(c)
+
+  if not parsed["const"][c] then
+    local n = parsed["number_of_constants"] + 1
+    parsed["number_of_constants"] = n
+    parsed["const"][c] = n
+    parsed["constant"][n] = {}
+    parsed["constant"][n]["c_type"] = t
+    parsed["constant"][n]["value"] = c
+  end
+end
+
+-- set a function if it doesn't exist
+function set_func(f, parsed)
+  if not parsed["number_of_functions"] then
+    parsed["number_of_functions"] = 0
+    parsed["func"] = {}
+    parsed["function"] = {}
+  end
+
+  if not parsed["func"][f] then
+    local n = parsed["number_of_functions"] + 1
+    parsed["number_of_functions"] = n
+    parsed["func"][f] = n
+    parsed["function"][n] = f
+  end
+end
+
+-- set an upvalue if it doesn't exist
+function set_upval(u, parsed)
+  if not parsed["number_of_upvalues"] then
+    parsed["number_of_upvalues"] = 0
+    parsed["upval"] = {}
+    parsed["upvalue"] = {}
+  end
+
+  if not parsed["upval"][u] then
+    local n = parsed["number_of_upvalues"] + 1
+    parsed["number_of_upvalues"] = n
+    parsed["upval"][u] = n
+    parsed["upvalue"][n] = u
+  end
+end
+
+-- check if a string is a label
+function check_label(x)
+  return string.find(x,":")
+end
+
+-- set a label if it doesn't exist
+function set_label(label, parsed, n)
+  if not parsed["label"] then parsed["label"] = {} end
+
+  if not parsed["label"][label] then
+    parsed["label"][label] = n
+  else
+    options.GENOUT = false
+    print_error("label " .. label .. " already defined at " .. parsed["id"])
+  end
+end
+
+-- parse an instruction
+function parse_inst(table, parsed, n)
+  local op = ""
+  local a = 2
+  local b = 3
+  local c = 4
+  if check_label(table[1]) == nil then
+    op = table[1]
+  else
+    set_label(table[1], parsed, n)
+    op = table[2]
+    a = 3
+    b = 4
+    c = 5
+  end
+
+  set_op(op, parsed, n)
+
+  if op ~= "JMP" then
+    set_reg(parse_reg(table[a]), parsed)
+    set_arg_a(parse_reg(table[a]), parsed, n)
+  end
+
+  if op == "MOVE" or op == "LOADNIL" or
+     op == "UNM" or op == "NOT" or op == "LEN" then
+    set_reg(parse_reg(table[b]), parsed)
+    set_arg_b(parse_reg(table[b]), parsed, n)
+    set_arg_c(0, parsed, n)
+  elseif op == "LOADK" then
+    set_const(table[b], parsed)
+    set_arg_bx(parsed["const"][table[b]], parsed, n)
+  elseif op == "LOADBOOL" then
+    set_const(table[b], parsed)
+    set_arg_b(parse_bool(table[b]), parsed, n)
+    set_arg_c(table[c], parsed, n)
+  elseif op == "GETUPVAL" or op == "SETUPVAL" then
+    set_upval(table[b], parsed)
+    set_arg_b(parsed["upval"][table[b]]-1, parsed, n)
+    set_arg_c(0, parsed, n)
+  elseif op == "GETGLOBAL" or op == "SETGLOBAL" then
+    set_const(table[b], parsed)
+    set_arg_bx(parsed["const"][table[b]], parsed, n)
+  elseif op == "GETTABLE" or op == "SETTABLE" or op == "SELF" or
+         op == "ADD" or op == "SUB" or op == "MUL" or
+         op == "DIV" or op == "MOD" or op == "POW" or
+         op == "EQ" or op == "LT" or op == "LE" then
+    if not parse_reg(table[b]) then
+      set_const(table[b], parsed)
+      set_arg_b(max_int() + (parsed["const"][table[b]]-1), parsed, n)
+    else
+      set_reg(parse_reg(table[b]), parsed)
+      set_arg_b(parse_reg(table[b]), parsed, n)
+    end
+    if not parse_reg(table[c]) then
+      set_const(table[c], parsed)
+      set_arg_c(max_int() + (parsed["const"][table[c]]-1), parsed, n)
+    else
+      set_reg(parse_reg(table[c]), parsed)
+      set_arg_c(parse_reg(table[c]), parsed, n)
+    end
+  elseif op == "NEWTABLE" or op == "CALL" or op == "TAILCALL" or
+         op == "SETLIST" then
+    set_arg_b(table[b], parsed, n)
+    set_arg_c(table[c], parsed, n)
+  elseif op == "CONCAT" then
+    set_reg(parse_reg(table[b]), parsed)
+    set_arg_b(parse_reg(table[b]), parsed, n)
+    set_reg(parse_reg(table[c]), parsed)
+    set_arg_c(parse_reg(table[c]), parsed, n)
+  elseif op == "JMP" then
+    set_arg_a(0, parsed, n)
+    set_arg_sbx(table[a], parsed, n)
+  elseif op == "FORLOOP" or op == "FORPREP" then
+    set_arg_sbx(table[b], parsed, n)
+  elseif op == "TEST" or op == "TESTSET" then
+    set_reg(parse_reg(table[b]), parsed)
+    set_arg_b(parse_reg(table[b]), parsed, n)
+    set_arg_c(parse_bool(table[c]), parsed, n)
+  elseif op == "RETURN" then
+    set_arg_b(table[b], parsed, n)
+    set_arg_c(0, parsed, n)
+  elseif op == "TFORLOOP" then
+    set_arg_b(0, parsed, n)
+    set_arg_c(table[b], parsed, n)
+  elseif op == "CLOSE" then
+    set_arg_b(0, parsed, n)
+    set_arg_c(0, parsed, n)
+  elseif op == "CLOSURE" then
+    set_func(table[b], parsed)
+    set_arg_bx(parsed["func"][table[b]], parsed, n)
+    num_par[table[b]] = tonumber(table[c])
+  elseif op == "VARARG" then
+    set_arg_b(table[b], parsed, n)
+    set_arg_c(0, parsed, n)
+    parsed["is_vararg"] = table[b] - 1
+    num_par[parsed["id"]] = 0
+  else
+    -- shouldn't enter here
+    options.GENOUT = false
+    print_error(op .. " : not a valid operator")
+  end
+end
+
+-- parse a function
+function parse_func(table, parsed)
+  parsed["instruction"] = {}
+  local n = 0
+  for k in pairs (table) do
+    parsed["instruction"][k] = {}
+    parse_inst(table[k], parsed, k)
+    n = k
+  end
+  parsed["number_of_instructions"] = n
+end
+
+-- set a vararg function
+function set_vararg(parsed, f)
+  if f == "main" then parsed["is_vararg"] = 2 else parsed["is_vararg"] = 0 end
+end
+
+-- fix function values
+function fix_function_values(parsed)
+  if parsed["max_stack_size"] < 2 then parsed["max_stack_size"] = 2 end
+  if not parsed["number_of_parameters"] then parsed["number_of_parameters"] = 0 end
+  if not parsed["number_of_upvalues"] then parsed["number_of_upvalues"] = 0 end
+end
+
+-- start parsing process
+function parse_all(table, parsed)
+  local f
+  for k,v in pairs (table) do
+    if is_func_name(k) then
+      f = v
+      parsed[f] = {}
+      parsed[f]["id"] = f
+    else
+      set_vararg(parsed[f], f)
+      parse_func(table[k], parsed[f])
+      fix_function_values(parsed[f])
+    end
+  end
+end
+
+-- write a byte to output
+function write_byte(output, byte)
+  if byte ~= 0 then
+    output:write(string.format("%c", byte))
+  else
+    output:write('\0')
+  end
+end
+
+-- write source name to output
+function write_source_name(output, name)
+  write_str(output, name)
+end
+
+-- write header to output
+function write_header(output)
+  for i=1,string.len(config.SIGNATURE) do
+    write_byte (output, string.byte(config.SIGNATURE,i))
+  end
+  write_byte (output, config.VERSION)
+  write_byte (output, config.FORMAT)
+  write_byte (output, config.ENDIANNESS)
+  write_byte (output, config.INT)
+  write_byte (output, config.SIZE_T)
+  write_byte (output, config.INSTRUCTION)
+  write_byte (output, config.LUA_NUMBER)
+  write_byte (output, config.INTEGRAL)
+end
+
+-- gen max int
+function max_int()
+  return ( 2 ^ 8 )
+end
+
+-- converts int to little endian
+function gen_int(n)
+  local t = {}
+  n = math.floor(n)
+  if n >= 0 then
+    for i=1,config.INT do
+      t[i] = n % max_int()
+      n = math.floor(n / max_int())
+    end
+  end
+  return t
+end
+
+-- writes an integer
+function write_int(output, n)
+  local i = gen_int(n)
+  if config.ENDIANNESS == 1 then
+    for k=1,config.INT do write_byte(output, i[k]) end
+  else
+    for k=config.INT,1,-1 do write_byte(output, i[k]) end
+  end
+end
+
+-- write function values
+function write_function_values(output, parsed)
+  parsed["number_of_parameters"] = num_par[parsed["id"]]
+  write_byte(output,parsed["number_of_upvalues"])
+  write_byte(output,parsed["number_of_parameters"])
+  write_byte(output,parsed["is_vararg"])
+  write_byte(output,parsed["max_stack_size"])
+end
+
+-- gen iABC instruction
+function gen_iABC(O, A, B, C)
+  local field = {O, A, C, B}
+  local v, i = {}, 0
+  local cValue, cBits, cPos = 0, 0, 1
+  -- encode an instruction
+  while i < config.INSTRUCTION do
+    -- if need more bits, suck in a field at a time
+    while cBits < 8 do
+      cValue = field[cPos] * math.ldexp(1, cBits) + cValue
+      cBits = cBits + config.iABC[cPos]; cPos = cPos + 1
+    end
+    -- extract bytes to instruction string
+    while cBits >= 8 do
+      v[i+1] = (cValue % 256)
+      cValue = math.floor(cValue / 256)
+      cBits = cBits - 8; i = i + 1
+    end
+  end
+  return v
+end
+
+-- gen iABx instruction
+function gen_iABx(O, A, Bx)
+  return gen_iABC(O, A, math.floor(Bx / config.MASK_C), (Bx % config.MASK_C))
+end
+
+-- gen iAsBx instruction
+function gen_iAsBx(O, A, sBx)
+  return gen_iABx(O, A, (sBx + config.MAXARG_sBx))
+end
+
+-- write instruction to output
+function write_instruction(output, parsed, n)
+  local i = parsed["instruction"][n]
+  local o = opcode[i["O"]]
+  local m = get_op_mode(i["O"])
+  local t = {}
+
+  if m == opmode.iABC then
+    t = gen_iABC(o,i["A"],i["B"],i["C"])
+  elseif m == opmode.iABx then
+    t = gen_iABx(o,i["A"],i["Bx"] - 1)
+  elseif m == opmode.iAsBx then
+    local sbx
+    if tonumber(parse_const_type(i["sBx"])) == types.LUA_TSTRING then
+      local label = i["sBx"] .. ":"
+      if not parsed["label"][label] then
+        sbx = 1
+        print_error("label " .. label .. " not defined at " .. parsed["id"])
+      else
+        sbx = (parsed["label"][label] - n) - 1
+      end
+    else
+      sbx = (i["sBx"] - n) - 1
+    end
+    t = gen_iAsBx(o,i["A"], sbx)
+  end
+
+  if config.ENDIANNESS == 1 then
+    for k=1,config.INSTRUCTION do write_byte(output, t[k]) end
+  else
+    for k=config.INSTRUCTION,1,-1 do write_byte(output, t[k]) end
+  end
+end
+
+-- write all instructions
+function write_instructions(output, parsed)
+  -- number of instructions
+  write_int(output, parsed["number_of_instructions"])
+  for i=1,parsed["number_of_instructions"] do
+    write_instruction(output, parsed, i)
+  end
+end
+
+-- gen a string length
+function gen_len(n)
+  local t = {}
+  n = math.floor(n)
+  if n >= 0 then
+    for i=1,config.SIZE_T do
+      t[i] = n % max_int()
+      n = math.floor(n / max_int())
+    end
+  end
+  return t
+end
+
+-- write string length to output
+function write_len(output, n)
+  local l = gen_len(n)
+  if config.ENDIANNESS == 1 then
+    for k=1,config.SIZE_T do write_byte(output, l[k]) end
+  else
+    for k=config.SIZE_T,1,-1 do write_byte(output, l[k]) end
+  end
+end
+
+-- fix a string
+function fix_str(str)
+  if string.find(str, "\\\"") then str = string.gsub(str, "\\\"", '"') end
+  if string.find(str, "\\\\") then str = string.gsub(str, "\\\\", '\\') end
+  if string.find(str, "\\a") then str = string.gsub(str, "\\a", '\a') end
+  if string.find(str, "\\b") then str = string.gsub(str, "\\b", '\b') end
+  if string.find(str, "\\f") then str = string.gsub(str, "\\f", '\f') end
+  if string.find(str, "\\n") then str = string.gsub(str, "\\n", '\n') end
+  if string.find(str, "\\r") then str = string.gsub(str, "\\r", '\r') end
+  if string.find(str, "\\t") then str = string.gsub(str, "\\t", '\t') end
+  if string.find(str, "\\v") then str = string.gsub(str, "\\v", '\v') end
+  if string.find(str, "\\0") then str = string.gsub(str, "\\0", "\0") end
+  if string.find(str, "\\[0-9]+") then str = string.gsub(str, "\\([0-9]+)", function (s) return string.format("%c", tonumber(s)) end) end
+  return str
+end
+
+-- write a string to output
+function write_str(output, str)
+  if (string.byte(str, 1) == 34 or string.byte(str, 1) == 39) and
+     (string.byte(str, string.len(str)) == 34 or string.byte(str, string.len(str)) == 39) then
+    str = string.sub(str, 2, string.len(str) - 1)
+    str = fix_str(str)
+  end
+  local len = string.len(str)
+  write_len(output, len + 1)
+  if config.ENDIANNESS == 1 then
+    for i=1,len do write_byte(output, string.byte(str, i)) end
+    write_byte(output, 0)
+  else
+    wirte_byte(output, 0)
+    for i=len,1,-1 do write_byte(output, string.byte(str, i)) end
+  end
+end
+
+-- get a byte
+function get_byte(v)
+  return math.floor(v / 256), string.char(math.floor(v) % 256)
+end
+
+-- converts float to little endian
+function convert_number(x)
+  local sign = 0
+  if x < 0 then sign = 1; x = -x end
+  local mantissa, exponent = math.frexp(x)
+  if x == 0 then -- zero
+    mantissa, exponent = 0, 0
+  else
+    mantissa = (mantissa * 2 - 1) * math.ldexp(0.5, 53)
+    exponent = exponent + 1022
+  end
+  local v, byte = {}, "" -- convert to bytes
+  x = mantissa
+  for i = 1,6 do
+    x, byte = get_byte(x); v[i] = string.byte(byte)
+  end
+  x, byte = get_byte(exponent * 16 + x); v[7] = string.byte(byte)
+  x, byte = get_byte(sign * 128 + x); v[8] = string.byte(byte)
+  return v
+end
+
+-- write a float to output
+function write_number(output, n)
+  local t = convert_number(tonumber(n))
+  if config.ENDIANNESS == 1 then
+    for k=1,config.LUA_NUMBER do write_byte(output, t[k]) end
+  else
+    for k=config.LUA_NUMBER,1,-1 do write_byte(output, t[k]) end
+  end
+end
+
+-- write a constant to output
+function write_constant(output, parsed)
+  local t = tonumber(parsed["c_type"])
+  write_byte(output, t)
+  if t == types.LUA_TNIL then
+    -- do not need to right anything
+  elseif t == types.LUA_TBOOLEAN then
+    if parsed["value"] == "TRUE" or parsed["value"] == "true" then write_byte(output, 1) else write_byte(output, 0) end
+  elseif t == types.LUA_TNUMBER then
+    write_number(output, parsed["value"])
+  elseif t == types.LUA_TSTRING then
+    write_str(output, parsed["value"])
+  end
+end
+
+-- write all constants
+function write_constants(output, parsed)
+  if not parsed["number_of_constants"] then parsed["number_of_constants"] = 0 end
+  write_int(output, parsed["number_of_constants"])
+  for i=1,parsed["number_of_constants"] do
+    write_constant(output, parsed["constant"][i])
+  end
+end
+
+-- write locals to output
+function write_locals(output, parsed)
+  if not parsed["number_of_locals"] then parsed["number_of_locals"] = 0 end
+  write_int(output, parsed["number_of_locals"])
+  for i=1,parsed["number_of_locals"] do
+    write_str(output, parsed["local"][i])
+  end
+end
+
+-- write upvalues to output
+function write_upvalues(output, parsed)
+  if not parsed["number_of_upvalues"] then parsed["number_of_upvalues"] = 0 end
+  write_int(output, parsed["number_of_upvalues"])
+  for i=1,parsed["number_of_upvalues"] do
+    write_str(output, parsed["upvalue"][i])
+  end
+end
+
+-- write a function block
+function write_function_block(output, parsed, to_be_parsed)
+  local nf = 0
+  -- line defined
+  write_int(output, 0)
+  -- last line defined
+  write_int(output, 0)
+  write_function_values(output, parsed)
+  write_instructions(output, parsed)
+  write_constants(output, parsed)
+  if parsed["number_of_functions"] then nf = parsed["number_of_functions"] end
+  write_int(output, nf)
+  for n=1,nf do
+    write_len(output, 0)
+    write_function_block(output, to_be_parsed[parsed["function"][n]], to_be_parsed)
+  end
+  -- source line positions
+  write_int(output, 0)
+  -- locals
+  write_int(output, 0)
+  -- upvalues
+  write_int(output, 0)
+end
+
+-- write binary file
+function write_bin(output, parsed)
+  write_header(output)
+  write_source_name(output, "@")
+  write_function_block(output, parsed["main"], parsed)
+end
+
+-- do a pre scan at file to be parsed
+function scan_file(file)
+  local scan = {}
+  local f
+  local main = true
+  for line in io.lines(file) do
+    if not string.byte(line) then -- new line, do nothing
+    elseif string.find(line, "main function:") and main then
+      f = "main"
+      scan[f] = {}
+      scan[f]["line"] = {}
+      scan[f]["noi"] = 0
+      main = false
+    elseif string.find(line, "function [a-zA-Z_][a-zA-Z0-9_]*:") then
+      f = string.gsub(string.gsub(string.gsub(line,"function", ""),":",""),"%s+","")
+      scan[f] = {}
+      scan[f]["line"] = {}
+      scan[f]["noi"] = 0
+    else
+      if f then scan[f]["noi"] = scan[f]["noi"] + 1 ; scan[f]["line"][scan[f]["noi"]] = line end
+    end
+  end
+  return scan
+end
+
+-- check if file could be parsed
+function check_table(table, scan)
+  local f
+  if not table[1] then
+    print_error("main could not be parsed")
+    return false
+  end
+  for k,v in pairs (table) do
+    if is_func_name(k) then
+      f = v
+    else
+      if scan[f]["noi"] ~= #v then
+        print_error("at function " .. f .. " could not parse instruction " .. #v + 1)
+        print (scan[f]["line"][#v + 1])
+        return false
+      end
+    end
+  end
+  return true
+end
+
+-- check if file exists
+function exists(file)
+  local f = io.open(file, "r")
+  if f then
+    f:close()
+    return true
+  end
+  return false
+end
+
+if #arg < 1 then
+  usage("no input file given");
+end
+
+doargs()
+
+if options.INPUT == nil then
+  usage("no input file given")
+end
+
+if not exists(options.INPUT) then
+  usage(options.INPUT .. " not found")
+end
+
+local parser = re.compile(grammar)
+
+input = io.open(options.INPUT, "r")
+contents = input:read("*a")
+input:close()
+
+local scan = scan_file(options.INPUT)
+
+local table = parser:match(contents)
+
+if check_table(table, scan) then parse_all(table, parsed) else options.GENOUT = false end
+
+if options.GENOUT then
+  output = io.open(options.OUTPUT, "wb")
+  write_bin(output, parsed)
+  output:close()
+end
+
+os.exit(0)
diff --git a/5.1/disassembler.lua b/5.1/disassembler.lua
new file mode 100644
index 0000000..c255865
--- /dev/null
+++ b/5.1/disassembler.lua
@@ -0,0 +1,1016 @@
+--[[
+Lua Disassembler
+Version 0.1
+Author: Andre Murbach Maidl
+]]
+
+-- usage message
+USAGE = [[
+usage: %s [options] [filename]
+Available options are:
+-h	print this help
+-l	list on luac style
+-o name output to file name (default is %s)
+]]
+
+-- global settings
+config = {}
+config.SIGNATURE   = "\27Lua"
+config.VERSION     = 81
+config.FORMAT      = 0
+config.ENDIANNESS  = 1
+config.INT         = 4
+config.SIZE_T      = 8
+config.INSTRUCTION = 4
+config.LUA_NUMBER  = 8
+config.INTEGRAL    = 0
+config.BLOCK       = 4
+config.HEADERBLOCK = 12
+config.SIZE_C      = 9
+config.SIZE_B      = 9
+config.SIZE_Bx     = config.SIZE_C + config.SIZE_B
+config.SIZE_A      = 8
+config.SIZE_OP     = 6
+config.POS_OP      = 0
+config.POS_A       = config.POS_OP + config.SIZE_OP
+config.POS_C       = config.POS_A + config.SIZE_A
+config.POS_B       = config.POS_C + config.SIZE_C
+config.POS_Bx      = config.POS_C
+
+-- global types
+types = {}
+types.LUA_TNIL     = 0
+types.LUA_TBOOLEAN = 1
+types.LUA_TNUMBER  = 3
+types.LUA_TSTRING  = 4
+
+-- opcodes
+opcode = {}
+opcode = { "MOVE", "LOADK", "LOADBOOL", "LOADNIL",
+           "GETUPVAL", "GETGLOBAL", "GETTABLE",
+           "SETGLOBAL", "SETUPVAL", "SETTABLE",
+           "NEWTABLE", "SELF", "ADD", "SUB", "MUL", "DIV",
+           "MOD", "POW", "UNM", "NOT", "LEN", "CONCAT",
+           "JMP", "EQ", "LT", "LE", "TEST", "TESTSET",
+           "CALL", "TAILCALL", "RETURN", "FORLOOP",
+           "FORPREP", "TFORLOOP", "SETLIST", "CLOSE",
+           "CLOSURE", "VARARG" }
+
+-- opcode modes
+opmode = {}
+opmode.iABC  = 0
+opmode.iABx  = 1
+opmode.iAsBx = 2
+
+-- opcode masks
+opargmask = {}
+opargmask.OpArgN = 0
+opargmask.OpArgU = 1
+opargmask.OpArgR = 2
+opargmask.OpArgK = 3
+
+-- global options
+options = {}
+options.INPUT   = nil
+options.OUTPUT  = "d.asm"
+options.LISTING = false
+options.TMP     = "luac_tmp.out"
+
+-- table to store parsed data
+parsed = {}
+
+-- prints usage message
+function usage(msg)
+  if msg ~= nil then
+    io.write(string.format("%s: %s\n", arg[0], msg))
+  end
+  io.write(string.format(USAGE, arg[0], options.OUTPUT))
+  os.exit(1)
+end
+
+-- parse arguments
+function doargs()
+  local i = 1
+  while i <= #arg do
+    if string.find(arg[i], "^-") == nil then
+      options.INPUT = arg[i]
+      break
+    elseif arg[i] == "-h" then usage()
+    elseif arg[i] == "-l" then
+      options.LISTING = true
+    elseif arg[i] == "-o" then
+      i = i + 1
+      if arg[i] == nil then usage("'-o' needs argument") else options.OUTPUT = arg[i] end
+    else usage(string.format("'%s' unkown option", arg[i]))
+    end
+    i = i + 1
+  end
+end
+
+-- print a table - debug only
+function print_table(table)
+  for k,p in pairs(table) do print (k,p) end
+end
+
+-- print a chunk - debug only
+function print_chunk(binary_chunk)
+  for b in string.gfind(binary_chunk, ".") do
+    io.write(string.format("%d ", string.byte(b)))
+  end
+  io.write(string.rep("    ", config.BLOCK - string.len(binary_chunk) + 1))
+  io.write(string.gsub(binary_chunk, "%c", "."), "\n")
+end
+
+-- print what still needs to be parsed - debug only
+function print_rest(file)
+  while true do
+    binary_chunk = file:read(config.BLOCK)
+    if not binary_chunk then break else print_chunk(binary_chunk) end
+  end
+end
+
+-- get a bit from an hex string
+function get_bit(x,a,b)
+  return (math.floor((x / 2^a) % 2^b))
+end
+
+-- generate an hex string
+function get_hex_string(x)
+  str = "0x"
+  if config.ENDIANNESS == 1 then
+    for i=config.BLOCK,1,-1 do
+      str = str .. string.format("%02x", string.byte(x,i))
+    end
+  else
+    for i=1,config.BLOCK do
+      str = str .. string.format("%02x", string.byte(x,i))
+    end
+  end
+
+  return str
+end
+
+-- get an int from a chunk
+function get_int(binary_chunk)
+  i = 0
+  if config.ENDIANNESS == 1 then
+    for p=config.INT,2,-1 do
+      i = i + (256 * string.byte(binary_chunk,p))
+    end
+    i = i + string.byte(binary_chunk,1)
+  else
+    for p=1,config.INT-1 do
+      i = i + (256 * string.byte(binary_chunk,p))
+    end
+    i = i + string.byte(binary_chunk,config.INT)
+  end
+  return i
+end
+
+-- revert chunk
+function revert(x)
+  reverted = ""
+  for k=config.LUA_NUMBER,1,-1 do
+    reverted = reverted .. string.format("%c", string.byte(x,k))
+  end
+  return reverted
+end
+
+-- convert little endian number to float
+function convert_little_endian(x)
+  sign = 1
+  mantissa = string.byte(x, 7) % 16
+  for i=6,1,-1 do mantissa = mantissa * 256 + string.byte(x,i) end
+  if string.byte(x,8) > 127 then sign = -1 end
+  exponent = (string.byte(x,8) % 128) * 16 + math.floor(string.byte(x,7) / 16)
+  if exponent == 0 then return 0 end
+  mantissa = (math.ldexp(mantissa, -52) + 1) * sign
+  return math.ldexp(mantissa, exponent - 1023)
+end
+
+-- convert big endian number to float
+function convert_big_endian(x)
+  sign = 1
+  mantissa = string.byte(x, 2) % 16
+  for i=3,config.LUA_NUMBER do mantissa = mantissa * 256 + string.byte(x,i) end
+  if string.byte(x,1) > 127 then sign = -1 end
+  exponent = (string.byte(x,1) % 128) * 16 + math.floor(string.byte(x,2) / 16)
+  if exponent == 0 then return 0 end
+  mantissa = (math.ldexp(mantissa, -52) + 1) * sign
+  return math.ldexp(mantissa, exponent - 1023)
+end
+
+-- convert a number
+function convert_number(x)
+  if config.ENDIANNESS == 1 then
+    return convert_little_endian(x)
+  end
+
+  return convert_big_endian(x)
+end
+
+-- get string length
+function get_str_len(binary_chunk)
+  if config.ENDIANNESS == 1 then
+    i = string.byte(binary_chunk,1)
+    for p=2,config.LUA_NUMBER do
+      i = i + (256 * string.byte(binary_chunk,p))
+    end
+  else
+    i = string.byte(binary_chunk,config.INT)
+    for p=config.INT-1,1,-1 do
+      i = i + (256 * string.byte(binary_chunk,p))
+    end
+  end
+  return i
+end
+
+-- get boolean value
+function get_boolean(binary_chunk)
+  if string.byte(binary_chunk,1) == 0 then return "false" end
+  return "true"
+end
+
+-- check if is a control char
+function iscntrl(x)
+  if (x >= 0 and x <= 31) or (x == 127) then return true end
+  return false
+end
+
+-- check if is a printable char
+function isprint(x)
+  return not iscntrl(x)
+end
+
+-- load header from file
+function load_header(file)
+  return file:read(config.HEADERBLOCK)
+end
+
+-- check Lua signature
+function check_signature(header_chunk)
+  if (string.sub(header_chunk, 1, string.len(config.SIGNATURE)) == config.SIGNATURE) then
+    return true
+  end
+
+  return false
+end
+
+-- check Lua version for 5.1
+function check_version(header_chunk)
+  if (string.byte(header_chunk,5) == config.VERSION) then
+    return true
+  end
+
+  return false
+end
+
+-- set flags detected from file
+function set_auto_flags(header_chunk)
+  config.ENDIANNESS  = string.byte(header_chunk,7)
+  config.INT         = string.byte(header_chunk,8)
+  config.SIZE_T      = string.byte(header_chunk,9)
+  config.INSTRUCTION = string.byte(header_chunk,10)
+  config.LUA_NUMBER  = string.byte(header_chunk,11)
+  config.INGETRAL    = string.byte(header_chunk,12)
+end
+
+-- get a string based on its length
+function get_string(file, str_len)
+  binary_chunk = file:read(str_len)
+  local str = ""
+  for i=1,str_len do
+    local byte = string.byte(binary_chunk, i)
+    if byte ~= 0 then
+      str = str .. string.format("%c", string.byte(binary_chunk,i))
+    else
+      str = str .. '\0'
+    end
+  end
+
+  return str
+end
+
+-- get source name from file
+function get_source_name(file)
+  binary_chunk = file:read(config.SIZE_T)
+  str_len = get_str_len(binary_chunk)
+  return get_string(file, str_len)
+end
+
+-- get line defined from file
+function get_line_defined(file, parsed)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["line_defined"] = get_int(binary_chunk)
+end
+
+-- get last line defined from file
+function get_last_line_defined(file, parsed)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["last_line_defined"] = get_int(binary_chunk)
+end
+
+-- get function values from file
+function get_function_values(file, parsed)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["number_of_upvalues"]   = string.byte(binary_chunk,1)
+  parsed["number_of_parameters"] = string.byte(binary_chunk,2)
+  parsed["is_vararg"]            = string.byte(binary_chunk,3)
+  parsed["max_stack_size"]       = string.byte(binary_chunk,4)
+end
+
+-- get instruction from file
+function get_instruction(file, parsed, n)
+  if not parsed["instruction"] then parsed["instruction"] = {} end
+
+  binary_chunk = file:read(config.BLOCK)
+  parsed["instruction"][n] = get_hex_string(binary_chunk)
+end
+
+-- get all instructions from file
+function get_instructions(file, parsed)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["number_of_instructions"] = get_int(binary_chunk)
+
+  for n=1,parsed["number_of_instructions"] do
+    get_instruction(file, parsed, n)
+  end
+end
+
+-- get a constant from file
+function get_constant(file, parsed, n)
+  if not parsed["constant"] then parsed["constant"] = {} end
+  if not parsed["constant"][n] then parsed["constant"][n] = {} end
+
+  binary_chunk = file:read(1)
+  c_type = string.byte(binary_chunk,1)
+
+  if c_type == types.LUA_TNIL then
+    parsed["constant"][n]["c_type"] = types.LUA_TNIL
+    parsed["constant"][n]["value"] = "nil"
+  elseif c_type == types.LUA_TBOOLEAN then
+    parsed["constant"][n]["c_type"] = types.LUA_TBOOLEAN
+    binary_chunk = file:read(1)
+    parsed["constant"][n]["value"] = get_boolean(binary_chunk)
+  elseif c_type == types.LUA_TNUMBER then
+    parsed["constant"][n]["c_type"] = types.LUA_TNUMBER
+    binary_chunk = file:read(config.LUA_NUMBER)
+    parsed["constant"][n]["value"] = convert_number(binary_chunk)
+  elseif c_type == types.LUA_TSTRING then
+    parsed["constant"][n]["c_type"] = types.LUA_TSTRING
+    binary_chunk = file:read(config.SIZE_T)
+    parsed["constant"][n]["str_len"] = get_str_len(binary_chunk)
+    parsed["constant"][n]["value"] = get_string(file, parsed["constant"][n]["str_len"])
+  end
+end
+
+-- get all constants from file
+function get_constants(file, parsed)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["number_of_constants"] = get_int(binary_chunk)
+
+  for n=1,parsed["number_of_constants"] do
+    get_constant(file, parsed, n)
+  end
+end
+
+-- get number of functions from file
+function get_number_of_functions(file, parsed)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["number_of_functions"] = get_int(binary_chunk)
+end
+
+-- get source line positions from file
+function get_source_line_position(file, parsed, n)
+  if not parsed["instruction_line"] then parsed["instruction_line"] = {} end
+
+  binary_chunk = file:read(config.BLOCK)
+  parsed["instruction_line"][n] = get_int(binary_chunk)
+end
+
+-- get all source line positions from file
+function get_source_line_positions(file, parsed)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["number_of_instruction_lines"] = get_int(binary_chunk)
+
+  for n=1,parsed["number_of_instruction_lines"] do
+    get_source_line_position(file, parsed, n)
+  end
+end
+
+-- get a local variable from file
+function get_local(file, parsed, n)
+  if not parsed["local"] then parsed["local"] = {} end
+  if not parsed["local"][n] then parsed["local"][n] = {} end
+
+  binary_chunk = file:read(config.SIZE_T)
+  parsed["local"][n]["str_len"] = get_str_len(binary_chunk)
+  parsed["local"][n]["varname"] = get_string(file, parsed["local"][n]["str_len"])
+  binary_chunk = file:read(config.BLOCK)
+  parsed["local"][n]["startpc"] = string.byte(binary_chunk,1)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["local"][n]["endpc"] = string.byte(binary_chunk,1)
+end
+
+-- get all local variables from file
+function get_locals(file, parsed)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["number_of_locals"] = get_int(binary_chunk)
+
+  for n=1,parsed["number_of_locals"] do
+    get_local(file, parsed, n)
+  end
+end
+
+-- get an upvalue from file
+function get_upvalue(file, parsed, n)
+  if not parsed["upvalue"] then parsed["upvalue"] = {} end
+  if not parsed["upvalue"][n] then parsed["upvalue"][n] = {} end
+
+  binary_chunk = file:read(config.SIZE_T)
+  parsed["upvalue"][n]["str_len"] = get_str_len(binary_chunk)
+  parsed["upvalue"][n]["value"] = get_string(file, parsed["upvalue"][n]["str_len"])
+end
+
+-- get all upvalues from file
+function get_upvalues(file, parsed)
+  binary_chunk = file:read(config.BLOCK)
+  parsed["size_of_upvalues"] = get_int(binary_chunk)
+
+  for n=1,parsed["size_of_upvalues"] do
+    get_upvalue(file, parsed, n)
+  end
+end
+
+-- get function block from file
+function get_function_block(file, parsed, source_name, parent)
+  parsed["source_name"] = source_name
+  get_line_defined(file, parsed)
+  get_last_line_defined(file, parsed)
+  get_function_values(file, parsed)
+  get_instructions(file, parsed)
+  get_constants(file, parsed)
+  get_number_of_functions(file, parsed)
+  for n=1,parsed["number_of_functions"] do
+    binary_chunk = file:read(config.SIZE_T)
+    if not parsed["function"] then parsed["function"] = {} end
+    if not parsed["function"][n] then parsed["function"][n] = {} end
+    parsed["function"][n]["parent"] = parent
+    parsed["function"][n]["id"] = n
+    get_function_block(file, parsed["function"][n], source_name, parent+1)
+  end
+  get_source_line_positions(file, parsed)
+  get_locals(file, parsed)
+  get_upvalues(file, parsed)
+end
+
+-- output header
+function print_header(parsed)
+
+  local function SS(x) if x == 1 then return "" else return "s" end end
+  local function S(x) return x,SS(X) end
+
+  func_name = "function"
+  is_vararg = ""
+
+  if parsed["line_defined"] == 0 and parsed["id"] == 0 then func_name = "main" end
+  if parsed["is_vararg"] ~= 0 then is_vararg = "+" end
+
+  io.write(string.format("\n%s <%s:%d,%d> (%d instruction%s, %d bytes at %d)\n",
+			  func_name, parsed["source_name"], parsed["line_defined"], parsed["last_line_defined"],
+			  parsed["number_of_instructions"], SS(parsed["number_of_instructions"]),
+			  parsed["number_of_instructions"] * config.BLOCK, 0))
+  io.write(string.format("%d%s param%s, %d slot%s, %d upvalue%s, ",
+			  parsed["number_of_parameters"], is_vararg, SS(parsed["number_of_parameters"]),
+			  parsed["max_stack_size"], SS(parsed["max_stack_size"]),
+			  parsed["number_of_upvalues"], SS(parsed["number_of_upvalues"])))
+ io.write(string.format("%d local%s, %d constant%s, %d function%s\n",
+			  parsed["number_of_locals"], SS(parsed["number_of_locals"]),
+			  parsed["number_of_constants"], SS(parsed["number_of_constants"]),
+			  parsed["number_of_functions"], SS(parsed["number_of_functions"])))
+
+end
+
+-- get an opcode
+function get_opcode(inst)
+  return get_bit(inst,config.POS_OP,config.SIZE_OP)
+end
+
+-- get argument A
+function getarg_a(inst)
+  return get_bit(inst,config.POS_A,config.SIZE_A)
+end
+
+-- get argument B
+function getarg_b(inst)
+  return get_bit(inst,config.POS_B,config.SIZE_B)
+end
+
+-- get argument C
+function getarg_c(inst)
+  return get_bit(inst,config.POS_C,config.SIZE_C)
+end
+
+-- get argument Bx
+function getarg_bx(inst)
+  return get_bit(inst,config.POS_Bx,config.SIZE_Bx)
+end
+
+-- get max argument for Bx
+function maxarg_bx()
+  return (2 ^ config.SIZE_Bx) - 1
+end
+
+-- get max argument for sBx
+function maxarg_sbx()
+  return get_bit(maxarg_bx(),1,32)
+end
+
+-- get argument sBx
+function getarg_sbx(inst)
+  return getarg_bx(inst)-maxarg_sbx()
+end
+
+-- get opcode mode
+function get_op_mode(o)
+  if opcode[o] == "JMP" or opcode[o] == "FORLOOP" or opcode[o] == "FORPREP" then
+    return opmode.iAsBx
+  elseif opcode[o] == "LOADK" or opcode[o] == "GETGLOBAL" or
+         opcode[o] == "SETGLOBAL" or opcode[o] == "CLOSURE" then
+    return opmode.iABx
+  end
+  return opmode.iABC
+end
+
+-- get B mask
+function get_b_mode(o)
+  if opcode[o] == "TFORLOOP" or opcode[o] == "CLOSE" then
+    m = opargmask.OpArgN
+  elseif opcode[o] == "LOADBOOL" or opcode[o] == "GETUPVAL" or
+         opcode[o] == "SETUPVAL" or opcode[o] == "NEWTABLE" or
+         opcode[o] == "CALL" or opcode[o] == "TAILCALL" or
+         opcode[o] == "RETURN" or opcode[o] == "SETLIST" or
+         opcode[o] == "CLOSURE" or opcode[o] == "VARARG" then
+    m = opargmask.OpArgU
+  elseif opcode[o] == "MOVE" or opcode[o] == "LOADNIL" or
+         opcode[o] == "GETTABLE" or opcode[o] == "SELF" or
+         opcode[o] == "UNM" or opcode[o] == "NOT" or
+         opcode[o] == "LEN" or opcode[o] == "CONCAT" or
+         opcode[o] == "JMP" or opcode[o] == "TEST" or
+         opcode[o] == "TESTSET" or opcode[o] == "FORLOOP" or opcode[o] == "FORPREP" then
+    m = opargmask.OpArgR
+   elseif opcode[o] == "LOADK" or opcode[o] == "GETGLOBAL" or
+          opcode[o] == "SETGLOBAL" or opcode[o] == "SETTABLE" or
+          opcode[o] == "ADD" or opcode[o] == "SUB" or opcode[o] == "MUL" or
+          opcode[o] == "DIV" or opcode[o] == "MOD" or opcode[o] == "POW" or
+          opcode[o] == "EQ" or opcode[o] == "LT" or opcode[o] == "LE" then
+    m = opargmask.OpArgK
+  end
+  return m
+end
+
+-- get C mask
+function get_c_mode(o)
+  if opcode[o] == "MOVE" or opcode[o] == "LOADK" or
+     opcode[o] == "LOADNIL" or opcode[o] == "GETUPVAL" or
+     opcode[o] == "GETGLOBAL" or opcode[o] == "SETGLOBAL" or
+     opcode[o] == "SETUPVAL" or opcode[o] == "UNM" or
+     opcode[o] == "NOT" or opcode[o] == "LEN" or opcode[o] == "JMP" or
+     opcode[o] == "RETURN" or opcode[o] == "FORLOOP" or
+     opcode[o] == "FORPREP" or opcode[o] == "CLOSE" or
+     opcode[o] == "CLOSURE" or opcode[o] == "VARARG" then
+    m = opargmask.OpArgN
+  elseif opcode[o] == "LOADBOOL" or opcode[o] == "NEWTABLE" or
+         opcode[o] == "TEST" or opcode[o] == "TESTSET" or
+         opcode[o] == "CALL" or opcode[o] == "TAILCALL" or
+         opcode[o] == "TFORLOOP" or opcode[o] == "SETLIST" then
+    m = opargmask.OpArgU
+  elseif opcode[o] == "CONCAT" then
+    m = opargmask.OpArgR
+  elseif opcode[o] == "GETTABLE" or opcode[o] == "SETTABLE" or
+         opcode[o] == "SELF" or opcode[o] == "ADD" or opcode[o] == "SUB" or
+         opcode[o] == "MUL" or opcode[o] == "DIV" or opcode[o] == "MOD" or
+         opcode[o] == "POW" or opcode[o] == "EQ" or opcode[o] == "LT" or opcode[o] == "LE" then
+    m = opargmask.OpArgK
+  end
+  return m
+end
+
+-- get BITRK
+function bitrk()
+  return (2 ^ (config.SIZE_B - 1))
+end
+
+-- get ~BITRK
+function not_bitrk()
+  return (bitrk() + 1) * -1
+end
+
+-- get ISK
+function isk(x)
+  if x >= bitrk() then return true end
+  return false
+end
+
+-- get INDEXK
+function indexk(x)
+  if x >= bitrk() then return not_bitrk() + (x + 1) else return x end
+end
+
+-- output string
+function print_string(parsed)
+  io.write(string.format("\""))
+  for i=1,parsed["str_len"]-1 do
+    char = string.byte(parsed["value"],i)
+    if char == 34 then io.write(string.format("\\\""))
+    elseif char == 92 then io.write(string.format("\\\\"))
+    elseif char == 7 then io.write(string.format("\\a"))
+    elseif char == 8 then io.write(string.format("\\b"))
+    elseif char == 12 then io.write(string.format("\\f"))
+    elseif char == 10 then io.write(string.format("\\n"))
+    elseif char == 13 then io.write(string.format("\\r"))
+    elseif char == 9 then io.write(string.format("\\t"))
+    elseif char == 11 then io.write(string.format("\\v"))
+    else
+      if isprint(char) then
+        io.write(string.format("%c", char))
+      else
+        io.write(string.format("\\%03d", char))
+      end
+    end
+  end
+  io.write(string.format("\""))
+end
+
+-- output a constant
+function print_constant(parsed, n)
+  c_type = parsed["constant"][n]["c_type"]
+  value = parsed["constant"][n]["value"]
+  if c_type == types.LUA_TNIL then
+    io.write(string.format("%s", value))
+  elseif c_type == types.LUA_TBOOLEAN then
+    io.write(string.format("%s", value))
+  elseif c_type == types.LUA_TNUMBER then
+    io.write(string.format("%s", value))
+  elseif c_type == types.LUA_TSTRING then
+    print_string(parsed["constant"][n])
+  end
+end
+
+-- output code
+function print_code(parsed)
+  for n=1,parsed["number_of_instructions"] do
+    i = parsed["instruction"][n]
+    o = get_opcode(i) + 1
+    a = getarg_a(i)
+    b = getarg_b(i)
+    c = getarg_c(i)
+    bx = getarg_bx(i)
+    sbx = getarg_sbx(i)
+    if parsed["number_of_instruction_lines"] > 0 then line = parsed["instruction_line"][n] else line = 0 end
+
+    io.write(string.format("\t%d\t", n))
+    if line > 0 then
+      io.write(string.format("[%d]\t", line))
+    else
+      io.write(string.format("[-]\t"))
+    end
+    io.write(string.format("%-9s\t", opcode[o]))
+
+    if get_op_mode(o) == opmode.iABC then
+      io.write(string.format("%d", a))
+      if get_b_mode(o) ~= opargmask.OpArgN then
+        if isk(b) then
+          io.write(string.format(" %d", -1-indexk(b)))
+        else
+          io.write(string.format(" %d", b))
+        end
+      end
+      if get_c_mode(o) ~= opargmask.OpArgN then
+        if isk(c) then
+          io.write(string.format(" %d", -1-indexk(c)))
+        else
+          io.write(string.format(" %d", c))
+        end
+      end
+    elseif get_op_mode(o) == opmode.iABx then
+      if get_b_mode(o) == opargmask.OpArgK then
+        io.write(string.format("%d %d", a, -1-bx))
+      else
+        io.write(string.format("%d %d", a, bx))
+      end
+    elseif get_op_mode(o) == opmode.iAsBx then
+      if opcode[o] == "JMP" then
+        io.write(string.format("%d", sbx))
+      else
+        io.write(string.format("%d %d", a, sbx))
+      end
+    end
+
+    if opcode[o] == "LOADK" then
+      io.write(string.format("\t; "))
+      print_constant(parsed, bx+1)
+    elseif opcode[o] == "GETUPVAL" or opcode[o] == "SETUPVAL" then
+      if parsed["number_of_upvalues"] > 0 then myupvalue = parsed["upvalue"][b+1]["value"] else myupvalue = "-" end
+      io.write(string.format("\t; %s", myupvalue))
+    elseif opcode[o] == "GETGLOBAL" or opcode[o] == "SETGLOBAL" then
+      io.write(string.format("\t; %s", parsed["constant"][bx+1]["value"]))
+    elseif opcode[o] == "GETTABLE" or opcode[o] == "SELF" then
+      if isk(c) then
+        io.write(string.format("\t; "))
+        print_constant(parsed, indexk(c+1))
+      end
+    elseif opcode[o] == "SETTABLE" or opcode[o] == "ADD" or
+           opcode[o] == "SUB" or opcode[o] == "MUL" or
+           opcode[o] == "DIV" or opcode[o] == "POW" or
+           opcode[o] == "EQ" or opcode[o] == "LT" or opcode[o] == "LE" then
+      if isk(b) or isk(c) then
+        io.write(string.format("\t; "))
+        if isk(b) then print_constant(parsed, indexk(b+1)) else io.write(string.format("-")) end
+        io.write(string.format(" "))
+        if isk(c) then print_constant(parsed, indexk(c+1)) else io.write(string.format("-")) end
+      end
+    elseif opcode[o] == "JMP" or opcode[o] == "FORLOOP" or opcode[o] == "FORPREP" then
+      io.write(string.format("\t; to %d", sbx+n+1))
+    elseif opcode[o] == "CLOSURE" then
+      io.write(string.format("\t; 0x"))
+    elseif opcode[o] == "SETLIST" then
+      if c == 0 then
+        io.write(string.format("\t; %d", 0))
+      else
+        io.write(string.format("\t; %d", c))
+      end
+    end
+
+    io.write(string.format("\n"))
+  end
+end
+
+-- output a function
+function print_function(parsed)
+  print_header(parsed)
+  print_code(parsed)
+
+  for i=1,parsed["number_of_functions"] do
+    print_function(parsed["function"][i])
+  end
+end
+
+-- output header to a file
+function write_header(output, parsed)
+  if parsed["line_defined"] == 0 and parsed["id"] == 0 then
+    func_name = "main function:"
+  else
+    func_name = string.format("function F_%s_%s:", parsed["parent"], parsed["id"])
+  end
+
+  output:write(string.format("\n%s\n", func_name))
+end
+
+-- output a string to a file
+function write_string(output, parsed)
+  output:write(string.format("\""))
+  for i=1,parsed["str_len"]-1 do
+    char = string.byte(parsed["value"],i)
+    if char == 34 then output:write(string.format("\\\""))
+    elseif char == 92 then output:write(string.format("\\\\"))
+    elseif char == 7 then output:write(string.format("\\a"))
+    elseif char == 8 then output:write(string.format("\\b"))
+    elseif char == 12 then output:write(string.format("\\f"))
+    elseif char == 10 then output:write(string.format("\\n"))
+    elseif char == 13 then output:write(string.format("\\r"))
+    elseif char == 9 then output:write(string.format("\\t"))
+    elseif char == 11 then output:write(string.format("\\v"))
+    else
+      if isprint(char) then
+        output:write(string.format("%c", char))
+      else
+        output:write(string.format("\\%d", char))
+      end
+    end
+  end
+  output:write(string.format("\""))
+end
+
+-- output a constant to a file
+function write_constant(output, parsed, n)
+  c_type = parsed["constant"][n]["c_type"]
+  value = parsed["constant"][n]["value"]
+  if c_type == types.LUA_TNIL or c_type == types.LUA_TBOOLEAN or c_type == types.LUA_TNUMBER then
+    output:write(string.format("%s", value))
+  elseif c_type == types.LUA_TSTRING then
+    write_string(output, parsed["constant"][n])
+  end
+end
+
+-- output a boolean to a file
+function write_boolean(output, b)
+  if b == 0 then
+    output:write(string.format("FALSE"))
+  else
+    output:write(string.format("TRUE"))
+  end
+end
+
+-- output a register to a file
+function write_register(output, i)
+  output:write(string.format("R[%s]", i))
+end
+
+-- output a constant or register to a file
+function write_rk(output, parsed, x)
+  if isk(x) then
+    write_constant(output, parsed, indexk(x+1))
+  else
+    write_register(output, x)
+  end
+end
+
+-- output an index to a file
+function write_index(output, x)
+  if isk(x) then
+    output:write(string.format("%s", -1-indexk(x)))
+  else
+    output:write(string.format("%s", x))
+  end
+end
+
+-- output function id to a file
+function write_function_id(output, parsed, i)
+  local parent = parsed["function"][i]["parent"]
+  local id = parsed["function"][i]["id"]
+  local np = parsed["function"][i]["number_of_parameters"]
+  output:write(string.format("F_%s_%s %d", parent, id, np))
+end
+
+-- output an space to a file
+function write_space(output)
+  output:write(string.format(" "))
+end
+
+-- output instruction to a file
+function write_code(output, parsed)
+  for n=1,parsed["number_of_instructions"] do
+    i = parsed["instruction"][n]
+    o = get_opcode(i) + 1
+    a = getarg_a(i)
+    b = getarg_b(i)
+    c = getarg_c(i)
+    bx = getarg_bx(i)
+    sbx = getarg_sbx(i)
+    if parsed["number_of_instruction_lines"] > 0 then line = parsed["instruction_line"][n] else line = 0 end
+
+    output:write(string.format("\t%d\t", n))
+    if line > 0 then
+      output:write(string.format("[%d]\t", line))
+    else
+      output:write(string.format("[0]\t"))
+    end
+    output:write(string.format("%-9s\t", opcode[o]))
+
+    if opcode[o] ~= "JMP" then
+      write_register(output, a)
+    else
+      output:write(string.format("%s", sbx+n+1))
+    end
+
+    if opcode[o] == "MOVE" or opcode[o] == "LOADNIL" or
+      opcode[o] == "UNM" or opcode[o] == "NOT" or opcode[o] == "LEN" then
+      write_space(output)
+      write_register(output, b)
+    elseif opcode[o] == "LOADK" then
+      write_space(output)
+      write_constant(output, parsed, bx+1)
+    elseif opcode[o] == "LOADBOOL" then
+      write_space(output)
+      write_boolean(output, b)
+      write_space(output)
+      write_index(output, c)
+    elseif opcode[o] == "GETUPVAL" or opcode[o] == "SETUPVAL" then
+      write_space(output)
+      output:write(string.format("%s", parsed["upvalue"][b+1]["value"]))
+    elseif opcode[o] == "GETGLOBAL" or opcode[o] == "SETGLOBAL" then
+      write_space(output)
+      output:write(string.format("%s", parsed["constant"][bx+1]["value"]))
+    elseif opcode[o] == "GETTABLE" or opcode[o] == "SELF" then
+      write_space(output)
+      write_register(output, b)
+      write_space(output)
+      write_rk(output, parsed, c)
+    elseif opcode[o] == "SETTABLE" or
+           opcode[o] == "ADD" or opcode[o] == "SUB" or opcode[o] == "MUL" or
+           opcode[o] == "DIV" or opcode[o] == "MOD" or opcode[o] == "POW" or
+           opcode[o] == "EQ" or opcode[o] == "LT" or opcode[o] == "LE" then
+      write_space(output)
+      write_rk(output, parsed, b)
+      write_space(output)
+      write_rk(output, parsed, c)
+    elseif opcode[o] == "NEWTABLE" or opcode[o] == "CALL" or opcode[o] == "TAILCALL" or
+           opcode[o] == "SETLIST" then
+      write_space(output)
+      write_index(output, b)
+      write_space(output)
+      write_index(output, c)
+    elseif opcode[o] == "CONCAT" then
+      write_space(output)
+      write_register(output, b)
+      write_space(output)
+      write_register(output, c)
+    elseif opcode[o] == "FORLOOP" or opcode[o] == "FORPREP" then
+      write_space(output)
+      output:write(string.format("%s", sbx+n+1))
+    elseif opcode[o] == "TEST" or opcode[o] == "TESTSET" then
+      write_space(output)
+      write_register(output, b)
+      write_space(output)
+      write_boolean(output, c)
+    elseif opcode[o] == "RETURN" or opcode[o] == "VARARG" then
+      write_space(output)
+      write_index(output, b)
+    elseif opcode[o] == "TFORLOOP" then
+      write_space(output)
+      write_index(output, c)
+    elseif opcode[o] == "CLOSE" then
+    elseif opcode[o] == "CLOSURE" then
+      write_space(output)
+      write_function_id(output, parsed, bx+1)
+    end
+
+    output:write(string.format("\n"))
+  end
+
+end
+
+-- output a function to a file
+function write_function(output, parsed)
+  write_header(output, parsed)
+  write_code(output, parsed)
+
+  for i=1,parsed["number_of_functions"] do
+    write_function(output, parsed["function"][i])
+  end
+end
+
+if #arg < 1 then
+  usage("no input file given");
+end
+
+doargs()
+
+if options.INPUT == nil then
+  usage("no input file given")
+end
+
+if not (loadfile(options.INPUT)) then
+  usage(options.INPUT .. " can not be loaded")
+end
+
+contents = string.dump(loadfile(options.INPUT))
+
+tmp = assert(io.open(options.TMP, "wb"))
+tmp:write(contents)
+tmp:close()
+
+input = assert(io.open(options.TMP, "rb"))
+
+if not input then
+  io.write(string.format("Couldn't open %s!\n", options.TMP))
+end
+
+header_chunk = load_header(input)
+
+-- check if Lua version is 5.1
+if not (check_version(header_chunk)) then
+  io.write(string.format("Can't proceed. It works only with Lua 5.1.\n"))
+  input:close()
+  os.exit(1)
+end
+
+-- set flags got in the input file
+set_auto_flags(header_chunk)
+
+if not parsed["main"] then parsed["main"] = {} end
+
+-- check source name
+source_name = get_source_name(input, parsed["main"])
+
+-- scan input file
+parsed["main"]["id"] = 0
+get_function_block(input, parsed["main"], source_name, parsed["main"]["id"])
+
+input:close()
+os.remove(options.TMP)
+
+if options.LISTING then print_function(parsed["main"]) end
+
+output = assert(io.open(options.OUTPUT, "w"))
+
+if not output then
+  io.write(string.format("Couldn't open %s!\n", options.OUTPUT))
+end
+
+write_function(output, parsed["main"])
+
+output:close()
+
+os.exit(0)
diff --git a/5.1/manual/logo1.png b/5.1/manual/logo1.png
new file mode 100644
index 0000000000000000000000000000000000000000..714be3d6dcfec6391adc84b9bd0645d3ad253525
GIT binary patch
literal 11125
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
E0H=rgJpcdz

literal 0
HcmV?d00001

diff --git a/5.1/manual/manual.html b/5.1/manual/manual.html
new file mode 100644
index 0000000..c00ac52
--- /dev/null
+++ b/5.1/manual/manual.html
@@ -0,0 +1,739 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Lua Assembler/Disassembler</title>
+<style type=text/css>
+<!--
+hr {
+	background-color: #BCAE79;
+	border-width: 1px;
+	color: #BCAE79;
+	height: 1px;
+	padding: 0;
+	width: 98%;
+}
+
+a {
+	text-decoration: none;
+}
+
+h3 {
+	color: #3175A2;
+}
+
+body {
+	background: #F4F4F4;
+	font-size: 12px;
+	line-height: 150%;
+	font-family: verdana, sans-serif
+}
+
+div#container {
+	width: 80%;
+	margin-left: 10%;
+	margin-right: 10%;
+	border: 1px solid #F0F0F0;
+	background: white;
+}
+
+div#logo {
+	margin: 2px 2px 2px 2px;
+}
+
+div#content {
+	margin: 20px 10px 10px 10px;
+	border: 1px solid #F0F0F0;
+	padding-left: 10px;
+	padding-right: 10px;
+	text-align: justify;
+}
+
+div#menu {
+	margin: 2px 2px 2px 20px;
+}
+
+div#footer {
+	margin: 2px 10px 20px 10px;
+	clear: both;
+	border: 1px solid #F0F0F0;
+}
+
+.lua-code {
+	background-color: #F4F4F4;
+	border: 1px solid silver;
+	font-family: "Andale Mono", monospace;
+	margin-left: 1em;
+	margin-right: 1em;
+	padding: 1em;
+}
+
+pre span {color:gray}
+
+code {
+	font-size: medium;
+	font-weight: bold;
+	color: gray;
+}
+
+table#solid {
+    border: 1px solid black;
+	border-collapse: collapse;
+    margin-left: auto;
+    margin-right: auto;
+}
+
+table#solid th {
+    border: 1px solid black;
+    padding: 0.5em;
+}
+
+table#solid td {
+    border: 1px solid black;
+    padding: 0.5em;
+}
+
+span.function {
+	color: #00008BA2;
+	font-weight: bold;
+}
+
+table.func-parts {
+	padding-left: 10px;
+	padding-bottom: 10px;
+}
+
+table.func-parts td.part {
+	font-weight: bold;
+}
+
+div.api {
+	padding-left: 10px;
+	padding-top: 10px;
+}
+
+//
+-->
+</style>
+</head>
+<body>
+<div id="container">
+<div id="logo">
+<center><img alt="xmlparser logo" src="logo1.png"></center>
+<div id="menu">
+<center>
+<h3>Lua Assembler/Disassembler</h3>
+<a href="#description">Description</a> | <a href="#requirements">Requirements</a> | <a href="#install">Install</a> |
+<a href="#assembler_options">Assembler Options</a> | <a href="#disassembler_options">Disassembler Options</a> |
+<a href="#how-to-use">How To Use</a> | <a href="#examples">Examples</a> | <a href="#syntax">Assembly Syntax</a> |
+<a href="#opcodes">Instructions</a> | <a href="#notes">Notes</a> | <a href="#licence">Licence</a>
+</center>
+</div>
+</div>
+<div id="content">
+<h3><a name="description">Description</a></h3>
+
+<p><code>Lua Assembler/Disassembler</code> is a set of two applications. The former is the disassembler, which
+can be used to generate assembly code from Lua code or Lua bytecode, while the latter is the assembler, which
+can be used to generate Lua byte code from assembly code.
+
+The assembler uses <a href="http://www.inf.puc-rio.br/~roberto/lpeg/">Lpeg</a> in order to implement the parser
+for the assembly syntax, which is presented on this document.
+</p>
+
+<hr>
+
+<h3><a name="requirements">Requirements</a></h3>
+<code>Lua Assembler/Disassembler</code> is compatible with Lua version 5.1.4 and Lpeg version 0.10.
+<hr />
+
+<h3><a name="install">Install</a></h3>
+<p>
+To run <code>Lua Assembler/Disassembler</code> in your computer, first you need install the
+<a href="http://www.lua.org/manual/5.1/manual.html#pdf-package.path">Lua language</a> and the
+<a href="http://www.inf.puc-rio.br/~roberto/lpeg/#download">Lpeg</a> library.
+The <code>Lua Assembler/Disassembler</code> is an application composed by 2 files.
+To install you need to <a href="">download</a> and just copy the following files
+to a directory in your computer or to your $PATH (which will depend on the operating system).
+
+<ul>
+	<li><code>assembler.lua</code></li>
+	<li><code>disassembler.lua</code></li>
+</ul>
+
+</p>
+
+<hr />
+
+<h3><a name="assembler_options">Assembler Options</a></h3>
+
+The following synopsis should be used:
+
+<pre class="lua-code">
+lua assembler.lua [options] [filename]
+</pre>
+
+<p>Available options are listed below and must be separate.</p>
+
+<a name="op-com"><h3 style="color:#00008B;">-h</h3></a>
+<p>
+Just prints a help message listing all available options and a brief explanation about them.
+</p>
+<a name="op-mat"><h3 style="color:#00008B;">-b</h3></a>
+<p>
+Output file on <b>big endian</b>, instead of the default <b>little endian</b>.
+</p>
+<a name="op-ver"><h3 style="color:#00008B;">-o file</h3></a>
+<p>
+Output to <b>file</b>, instead of the default <b>d.out</b>.
+Be careful to not overwrite precious files since you might specify the output file as an existent source file.
+</p>
+
+<hr />
+
+<h3><a name="disassembler_options">Disassembler Options</a></h3>
+
+The following synopsis should be used:
+
+<pre class="lua-code">
+lua disassembler.lua [options] [filename]
+</pre>
+
+<p>Available options are listed below and must be separate.</p>
+
+<a name="op-com"><h3 style="color:#00008B;">-h</h3></a>
+<p>
+Just prints a help message listing all available options and a brief explanation about them.
+</p>
+<a name="op-mat"><h3 style="color:#00008B;">-l</h3></a>
+<p>
+Produce a listing of the compiled bytecode for Lua's virtual machine on <b>luac -l</b> style.
+</p>
+<a name="op-ver"><h3 style="color:#00008B;">-o file</h3></a>
+<p>
+Output to <b>file</b>, instead of the default <b>d.asm</b>.
+Be careful to not overwrite precious files since you might specify the output file as an existent source file.
+</p>
+
+<hr />
+
+<h3><a name="how-to-use">How To Use</a></h3>
+
+<p>The following command line shows how to use the <code>disassembler</code> in order to generate the assembly code
+for a Lua source file:
+<pre class="lua-code">
+$ lua disassembler.lua -o hello.asm hello.lua
+</pre>
+
+The above command line outputs <b>hello.asm</b> which contains the assembly code for <b>hello.lua</b>.
+<br><br>
+It is important to remember that the <code>disassembler</code> can be used with a Lua bytecode too, as we shown below:
+<pre class="lua-code">
+$ lua disassembler.lua luac.out
+</pre>
+
+Notice that in this case we haven't specified the output file, in this way the output will be the default <b>d.asm</b>.
+<br><br>
+<p>The following command line shows how to use the <code>assembler</code> in order to generate Lua bytecode from
+our assembly code:
+<pre class="lua-code">
+$ lua assembler.lua -o hello.out hello.asm
+</pre>
+
+The above command line outputs <b>hello.out</b> which contains Lua bytecode for <b>hello.asm</b> and can be executed using lua.
+<br><br>
+It is important to remember that if you do not specify the output file, then Lua bytecode will be generated as <b>d.out</b> by default.
+
+<hr />
+
+<h3><a name="examples">Examples</a></h3>
+
+In this section we show some examples of our <b>assembly</b> language. The complete syntax can be checked
+at <a href="#syntax">Assembly Syntax</a> as well as opcodes can be checked at <a href="#opcodes">Instructions</a>.
+
+Here we show the assembly code that were generated, on above section, for <b>hello.lua</b> which is a simple
+<b>hello world</b> program.
+
+<pre class="lua-code">
+main function:
+        1       [1]     GETGLOBAL       R[0] print
+        2       [1]     LOADK           R[1] "hello world!"
+        3       [1]     CALL            R[0] 2 1
+        4       [1]     RETURN          R[0] 1
+</pre>
+
+Once we use the <code>assembler</code> to output the Lua bytecode we can execute it using lua, as follows:
+
+<pre class="lua-code">
+$ lua hello.out
+hello world!
+$
+</pre>
+
+Now we define a recursive factorial in our assembly language. Notice that although <b>line number</b> and
+<b>source line number</b> are optionals when we are writting the assembly code, <b>instructions</b>
+as well as its arguments are still mandatory.
+
+<pre class="lua-code">
+main function:
+        CLOSURE         R[0] fat_rec 1
+        SETGLOBAL       R[0] fat
+        GETGLOBAL       R[0] print
+        GETGLOBAL       R[1] fat
+        LOADK           R[2] 5
+        CALL            R[1] 2 0
+        CALL            R[0] 0 1
+        RETURN          R[0] 1
+
+function fat_rec:
+        EQ              R[0] R[0] 0
+        JMP             label1
+        LOADK           R[1] 0
+        RETURN          R[1] 2
+        JMP             label3
+label1: EQ              R[0] R[0] 1
+        JMP             label2
+        LOADK           R[1] 1
+        RETURN          R[1] 2
+        JMP             label3
+label2: GETGLOBAL       R[1] fat
+        SUB             R[2] R[0] 1
+        CALL            R[1] 2 2
+        MUL             R[1] R[0] R[1]
+        RETURN          R[1] 2
+label3: RETURN          R[0] 1
+</pre>
+
+In this example we haven't used <b>line number</b> or <b>source line number</b>.
+However, we have used <b>labels</b> on <b>fat_rec</b> function since it is easier to check where to jump.
+
+<hr />
+
+<h3><a name="syntax">Assembly Syntax</a></h3>
+
+Here is the complete syntax of Assembly in <code>lpeg re</code> module.
+
+<pre class="lua-code">
+  prog <- ( function )*
+  function <- header ( instruction )+
+  header <- ( %nl )* s (user / main) s ( %nl )+
+  user <- ( "function" s name s ":" )
+  main <- ( "main" s "function" s ":" )
+  number <- hex / float / int
+  int <- "-"? [0-9]+
+  float <- "-"? [0-9]+? "."? [0-9]+ ( [eE] ("-" / "+")? [0-9]+)? /
+           "-"? ([0-9]+ ".")? [0-9]+ ( [eE] ("-" / "+")? [0-9]+)?
+  hex <- "0x" [a-zA-Z0-9]+
+  name <- [a-zA-Z_][a-zA-Z0-9_]*
+  label <- name ":"
+  string <- '"' ('\\' / '\"' / !'"' .)* '"'
+  instruction <- ( s ( label / number)? s ln? s op ( s param )+ s ( %nl )+ ) 
+  op <- [A-Z]+
+  param <- register / number / name / string
+  register <- ( "R[" number "]" )
+  s <- ( !%nl %s )*
+  ln <- "[" number "]"
+</pre>
+<hr />
+
+<h3><a name="opcodes">Instructions</a></h3>
+
+<p>
+We have three main types of instructions, they are so called <b>iABC</b>, <b>iABx</b> and <b>iAsBx</b>
+and should be used as follows:
+</p>
+
+<center>
+<table id='solid'>
+        <tr>
+                <td><strong>Instruction type</strong></td>
+                <td><strong>Pattern</strong></td>
+        </tr>
+        <tr>
+                <td>iABC</td>
+                <td>OPCODE A B C</td>
+        </tr>
+        <tr>
+                <td>iABx</td>
+                <td>OPCODE A Bx</td>
+        </tr>
+        <tr>
+                <td>iAsBx</td>
+                <td>OPCODE A sBx</td>
+        </tr>
+</table>
+</center>
+
+<p>
+Some <b>iABC</b> instructions do not use argument B or C and below we specify when that is the case.
+Nonetheless, most of the <b>iABC</b> instructions follow the pattern described in above table.
+</p>
+
+<p>
+It is also important to keep in mind that parameters should comply with the <a href="#syntax">Assembly Syntax</a>.
+Here a some examples:
+</p>
+
+<center>
+<table id='solid'>
+        <tr>
+                <td><strong>Parameter type</strong></td>
+                <td><strong>Example</strong></td>
+        </tr>
+        <tr>
+                <td>Register</td>
+                <td>R[0], R[1], R[2], ...</td>
+        </tr>
+        <tr>
+                <td>Number</td>
+                <td>0, 1, 2, ... / -1, -2, ... / 0.1, 0.2, ..., 1.0, 1.1, ... / -0.1, -0.2, ..., -1.0, -1,1, ...</td>
+        </tr>
+        <tr>
+                <td>Name</td>
+                <td>F_0_1, blah, foo, ...</td>
+        </tr>
+        <tr>
+                <td>Nil</td>
+                <td>NIL</td>
+        </tr>
+        <tr>
+                <td>Boolean</td>
+                <td>TRUE / FALSE</td>
+        </tr>
+        <tr>
+                <td>String</td>
+                <td>"oi, tudo bem?", "hello world", "%s, string", ...</td>
+        </tr>
+</table>
+</center>
+
+<p>
+We will use a instruction notation as follows to show how to use each opcode.
+</p>
+
+<center>
+<table id='solid'>
+        <tr>
+                <td><strong>Notation</strong></td>
+                <td><strong>Meaning</strong></td>
+        </tr>
+        <tr>
+                <td>R(A), R(B), R(C)</td>
+                <td>Register specified in field A, B or C.</td>
+        </tr>
+        <tr>
+                <td>PC</td>
+                <td>Program Counter.</td>
+        </tr>
+        <tr>
+                <td>Kst(n)</td>
+                <td>A constant that will be translated to a number n.</td>
+        </tr>
+        <tr>
+                <td>Upvalue[n]</td>
+                <td>An upvalue name that will be translated to a number n.</td>
+        </tr>
+        <tr>
+                <td>Gbl[sym]</td>
+                <td>A global variable.</td>
+        </tr>
+        <tr>
+                <td>RK(B), RK(C)</td>
+                <td>A field that could be a register or a constant.</td>
+        </tr>
+        <tr>
+                <td>sBx</td>
+                <td>Signal displacement for all kinds of jumps. It can be a number or a label.</td>
+        </tr>
+</table>
+</center>
+
+<p>
+Below we show each opcode that is available in our assembly language as well as their respective arguments.
+</p>
+
+<a name="op-com"><h3 style="color:#00008B;">MOVE A B</h3></a>
+R(A) := R(B)
+<p>
+Copies the value of register R(B) into register R(A).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">LOADK A Bx</h3></a>
+R(A) := Kst(Bx)
+<p>
+Loads constant Kst(Bx) into register R(A). Constants can be numbers or strings.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">LOADBOOL A B C</h3></a>
+R(A) := (Bool)B; if (C) pc++
+<p>
+Loads a boolean value B (<b>TRUE</b> or <b>FALSE</b> should be used as B) into register R(A).
+If C is not zero then next instruction is skipped.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">LOADNIL A B</h3></a>
+R(A) := ... := R(B) := nil
+<p>
+Sets a range of registers from R(A) to R(B) to <b>nil</b>.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">GETUPVAL A B</h3></a>
+R(A) := UpValue[B]
+<p>
+Copies the value in UpValue[B] into register R(A).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">GETGLOBAL A Bx</h3></a>
+R(A) := Gbl[Kst(Bx)]
+<p>
+Copies the value of a global variable Gbl[Kst(Bx)] into register R(A).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">GETTABLE A B C</h3></a>
+R(A) := R(B)[RK(C)]
+<p>
+Copies the value from a table element into register R(A).
+The table is referenced by register R(B), while the index to the table is given by
+RK(C), which may be register R(C) or a constant Kst(C).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">SETGLOBAL A Bx</h3></a>
+Gbl[Kst(Bx)] := R(A)
+<p>
+Copies the value from register R(A) to a global variable Gbl[Kst(Bx)].
+</p>
+<a name="op-com"><h3 style="color:#00008B;">SETUPVAL A B</h3></a>
+UpValue[B] := R(A)
+<p>
+Copies the value from register R(A) into UpValue[B].
+</p>
+<a name="op-com"><h3 style="color:#00008B;">SETTABLE A B C</h3></a>
+R(A)[RK(B)] := RK(C)
+<p>
+Copies the value from register R(C) or constant Kst(C) into a table element.
+The table is referenced by register R(A), while the index to the table is given by
+RK(B), which may be register R(B) or a constant Kst(B).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">NEWTABLE A B C</h3></a>
+R(A) := {} (size = B,C)
+<p>
+Creates a new empty table at register R(A).
+Argument B is the size of the array part, while C is the size of the hash part.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">SELF A B C</h3></a>
+R(A+1) := R(B); R(A) := R(B)[RK(C)]
+<p>
+It is used for object-oriented programming using tables.
+Retrieves a function reference from a table element and places it in register R(A),
+then a reference to the table itself is placed in the next register R(A+1).
+R(B) is the register holding the reference to the table with the method,
+while the method function is found using the table index RK(C), that can be
+a register R(C) or a constant Kst(C).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">ADD A B C</h3></a>
+R(A) := RK(B) + RK(C)
+<p>
+Adds RK(B) and RK(C) and holds the result into register R(A).
+Both RK(B) and RK(C) may be either registers or constants.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">SUB A B C</h3></a>
+R(A) := RK(B) - RK(C)
+<p>
+Subtracts RK(B) and RK(C) and holds the result into register R(A).
+Both RK(B) and RK(C) may be either registers or constants.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">MUL A B C</h3></a>
+R(A) := RK(B) * RK(C)
+<p>
+Multiplies RK(B) and RK(C) and holds the result into register R(A).
+Both RK(B) and RK(C) may be either registers or constants.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">DIV A B C</h3></a>
+R(A) := RK(B) / RK(C)
+<p>
+Divides RK(B) and RK(C) and holds the result into register R(A).
+Both RK(B) and RK(C) may be either registers or constants.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">MOD A B C</h3></a>
+R(A) := RK(B) % RK(C)
+<p>
+Performs modulus between RK(B) and RK(C) and holds the result into register R(A).
+Both RK(B) and RK(C) may be either registers or constants.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">POW A B C</h3></a>
+R(A) := RK(B) ^ RK(C)
+<p>
+Performs exponentiation between RK(B) and RK(C) and holds the result into register R(A).
+Both RK(B) and RK(C) may be either registers or constants.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">UNM A B</h3></a>
+R(A) := -R(B)
+<p>
+Performs unary minus where register R(B) is negated and the value is placed in register R(A).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">NOT A B</h3></a>
+R(A) := not R(B)
+<p>
+Applies a boolean <b>not</b> to the value in register R(B) and holds the result in register R(A).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">LEN A B</h3></a>
+R(A) := length of R(B)
+<p>
+Returns the length of object in register R(B) and holds the result in register R(A).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">CONCAT A B C</h3></a>
+R(A) := R(B).. ... ..R(C)
+<p>
+Performs the concatenation among two or more strings. The start register is R(B) and the
+final register is R(C), meaning that R(C) should always be greater then R(B).
+The result is stored in register R(A).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">JMP sBx</h3></a>
+pc+=sBx
+<p>
+Performs an unconditional jump to sBx, which should be the instruction number that should jump to.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">EQ A B C</h3></a>
+if ((RK(B) == RK(C)) ~= A) then pc++
+<p>
+Performs a <b>equality</b> test between RK(B) and RK(C), wich may be registers or constants.
+If the boolean is not A then next instruction is skipped.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">LT A B C</h3></a>
+if ((RK(B) <  RK(C)) ~= A) then pc++
+<p>
+Performs a <b>less than</b> test between RK(B) and RK(C), wich may be registers or constants.
+If the boolean is not A then next instruction is skipped.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">LE A B C</h3></a>
+if ((RK(B) <= RK(C)) ~= A) then pc++
+<p>
+Performs a <b>less than or equal to</b> test between RK(B) and RK(C), wich may be registers or constants.
+If the boolean is not A then next instruction is skipped.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">TEST A C</h3></a>
+if not (R(A) <=> C) then pc++
+<p>
+Can be used to implement <b>and</b>/<b>or</b> logical operators, or for testing
+a single register in a conditional statement.
+TEST should be used when a assignment operation is not needed and works same way TESTSET.
+For more details, please, look at TESTSET.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">TESTSET A B C</h3></a>
+if (R(B) <=> C) then R(A) := R(B) else pc++
+<p>
+Also can be used to implement <b>and</b>/<b>or</b> logical operators, or for testing
+a single register in a conditional statement.
+Register R(B) is coerced into a boolean and compared to the boolean field C.
+If R(B) matches C then next instruction is skipped, otherwise R(B) is assigned to R(A).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">CALL A B C</h3></a>
+R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1))
+<p>
+Performs a function call. R(A) holds the reference to the function object to be called.
+Parameters to the function should be placed in the registers following R(A).
+<br><br>
+If B is 1, the function has no parameters. If B is 2 or more there are B-1 parameters.
+If B is 0 the function parameters range from R(A+1) to the top of the stack.
+<br><br>
+Results returned by the function call are placed in a range of registers starting from R(A).
+If C is 1 no return results. If C is 2 or more there are C-1 results saved.
+If C is 0 then multiple return results are saved.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">TAILCALL A B C</h3></a>
+return R(A)(R(A+1), ... ,R(A+B-1))
+<p>
+Performs a tail call which happens when a <b>return</b> statement has a single function call as the expression.
+Exactly like CALL, register R(A) is the reference to the function object to be called,
+while B encodes the number of paramenters. However, even tough C is not used by TAILCALL, 0 should be
+used to denote multiple return results.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">RETURN A B</h3></a>
+return R(A), ... ,R(A+B-2)
+<p>
+Returns to the calling function with options return values.
+<br><br>
+If B is 1 there are no return values. If B is 2 or more, there are B-1 return values.
+If B is 0, the set of values from R(A) to the top of the stack is returned.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">FORLOOP A sBx</h3></a>
+R(A)+=R(A+2) ; if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A)
+<p>
+Should be used to initialize a numeric <b>for</b> loop.
+A numeric for loop requires 4 registers on the stack where R(A) hold the initial value,
+R(A+1) is the limit, R(A+2) is the stepping value and R(A+3) is the actual loop variable
+that is local to the <b>for</b> block.
+The argument sBx should be the instruction number that should jump unconditionally to FORLOOP.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">FORPREP A sBx</h3></a>
+R(A)-=R(A+2); pc+=sBx
+<p>
+Should be used to perform an iteration of a numeric <b>for</b> loop.
+The argument sBx should be the instruction number that should jump back to the loop body.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">TFORLOOP A C</h3></a>
+R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)) ; if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++
+<p>
+Should be used to perform an iteration of a generic <b>for</b> loop, where
+R(A) is the iterator function, R(A+1) is the state and R(A+2) is the enumeration index.
+The loop variables are specified at locations R(A+3) and their count is defined by operand C,
+which should be at least 1.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">SETLIST A B C</h3></a>
+R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B
+<p>
+Sets the values for a range of arrays elements in a table referenced by R(A),
+argument B is the number of elements to set and argument C is the number of blocks
+to be initialized.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">CLOSE A</h3></a>
+close all variables in the stack up to (>=) R(A)
+<p>
+Closes all local variables in the stack up to register R(A).
+</p>
+<a name="op-com"><h3 style="color:#00008B;">CLOSURE A Bx N</h3></a>
+R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))
+<p>
+Should be used to create an instance of a closure of a function where Bx is the
+function name and R(A) is the register that assigns the reference to the instantiated
+function object. Although it is a <b>iABx</b> instruction the parameter N should specify
+the number of parameters for the function that is being defined.
+</p>
+<a name="op-com"><h3 style="color:#00008B;">VARARG A B</h3></a>
+R(A), R(A+1), ..., R(A+B-1) = vararg
+<p>
+Copies B-1 parameters into a number of registers starting from R(A).
+If B is 0, VARARG copies as many values as it can based on the number of parameters passed.
+If a fixed number of values is required, B is a value greater than 1.
+If any number of values is required then B is 0.
+</p>
+
+<hr />
+
+<h3><a name="notes">Notes</a></h3>
+<p>
+The current version of <code>Lua Assembler/Disassembler</code> is 0.1.
+</p>
+<hr />
+
+<h3><a name="licence">Licence</a></h3>
+<p>
+Copyright &copy; 2010 Andre Murbach Maidl.
+</p>
+<p>
+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:
+</p>
+<p>
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+</p>
+<p>
+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.
+</p>
+
+</div>
+<div id="footer">
+<center>
+	<small>Last modified by Andre Murbach Maidl</small>
+</center>
+</div>
+</div>
+</body>
+</html>