Средства разработки многопоточных скриптов в QUIK.

local aliases = { }     

local function escape ( s )
    s = tostring ( s ):gsub ( "\n", "\\n" )
    return s
end

 local function dumpstr ( t, alias, seen )
    alias, seen = alias or aliases, seen or { }
    if seen[ t ]  then return "" else seen[ t ] = true end
    local s, mt = string.format ( "newtable %s\n", alias[ t ] or escape ( t ) ), getmetatable ( t )
    if mt then s = string.format ( "%smetatable %s\n", s, alias [ mt ] or escape ( mt ) ) end
 local k_t, v_t                                                                                                                     
    for k, v in pairs ( t ) do
       k_t, v_t  = alias[ k ] or escape ( k ),  alias[ v ] or escape ( v )                                         
      if k_t == 'charpattern' then v_t = '%[' end                                    ----     ??? --- и без этого все работает, но если этот символ оставить в покое, обрубается виализация результата dumpstr ?
        s = string.format ( "%sk %s %s\nv %s %s\n", s, type ( k ), k_t, type ( v ), v_t )                
    end
    if mt  then  s = string.format ( "%s%s", s, dumpstr ( mt, alias, seen ) )  end
    for k, v in pairs ( t ) do
        if type ( k ) == 'table'  then s = string.format ( "%s%s", s, dumpstr ( k, alias, seen ) ) end
        if type ( v ) == 'table' then s = string.format ( "%s%s", s, dumpstr ( v, alias, seen ) ) end
    end 
    return s
end

local function unescape ( s )
    s = s:gsub ( "\\n", "\n" )
    return s
end
---------------                                                         ! Символами ###  выделены измененные места, для  исправления ошибок    -------
local function loadstr ( s, alias )
    alias = alias or aliases
    do local t = { } for k, v in pairs ( alias ) do t[ v ] = k end alias = t end
    local tlist, tcurr, kcurr, troot = { }, nil, nil, nil
   local tmt, ttb 
    for l in s:gmatch ( "([^\n]+)\n" ) do
        local nt = l:match ( "newtable (.+)" )
        local mt = l:match ( "metatable (.+)" )
        local kt, k = l:match ( "k ([^ ]+) (.+)" )
        local vt, v = l:match ( "v ([^ ]+) (.+)" )
        if nt     then    if tmt then setmetatable ( ttb, tmt ); tmt, ttb  = nil, nil  end                      --- ###   1. setmetatable выполняется после завершения формирования  ttb (смотрите п.2)
            tlist[ nt ] = tlist [ nt ] or alias[ nt ] or { }; tcurr = tlist[ nt ]; troot = troot or tcurr;  d_nt = nt 
        elseif mt then tlist[ mt ] = tlist[ mt ] or alias [ mt ] or { };  ttb = tcurr; tmt = tlist [ mt ]        --  ###  2. setmetatable  нужно выполнять после того как будет полностью сформирована tcurr. 
        elseif k then                                                                                                             ----         Иначе могут срабатывать метаметоды, если метатаблица была сформирована раньше. 
            if   kt == 'table' then  tlist[ k ] = tlist[ k ] or alias[ k ] or { }; kcurr = tlist[ k ]
            elseif kt == 'number' then kcurr = alias[ k ] or tonumber ( k ) or 0/0
            elseif kt == 'string' then kcurr = alias[ k ] or unescape ( k )
         elseif kt == 'boolean'  then  kcurr = alias[ k ] or  k                                                 ----- ###   3.  добавлено (учет типа boolean): elseif  kt == 'boolean'  then  kcurr = alias[ k ] or  k  ---
            else kcurr = alias[ k ]  or  k                                                                                 ----- ###   4.   добавлено (учет:элеметов не входящих в alias)   or  k   ---
            end
        elseif v and tcurr and kcurr ~= nil then
            if   vt == 'table' then tlist[ v ] = tlist[ v ] or alias[ v ] or { }; tcurr[ kcurr ] = tlist[ v ]
            elseif vt == 'number' then  tcurr[ kcurr ] = alias[ v ] or tonumber ( v ) or 0/0           
            elseif vt == 'string' then tcurr[ kcurr ] = alias[ v ] or unescape ( v )
         elseif vt == 'boolean' then  tcurr [ kcurr ] = alias[ v ] or  v                                        ---- ###   5.   добавлено: elseif vt == 'boolean' then  tcurr [ kcurr ] = alias[ v ] or  v ---
            else tcurr [ kcurr ] = alias[ v ] or  v                                                                       ----- ###   6.   добавлено:  or  v   ---                
            end
        end
    end
   if tmt then setmetatable ( ttb, tmt )   end                                                                         --- ###   7. Выполняется в поледней обработанной таблице (! если у нее есть метатаблица)
    return troot
end

local function dumpfile ( file, t, alias, seen )
    alias, seen = alias or aliases, seen or { }
    if seen[ t ] then return else seen[ t ] = true end
    local mt = getmetatable ( t )
    file:write ( string.format ( "newtable %s\n", alias[ t ] or escape ( t ) ) )  
    if mt then file:write ( string.format ( "metatable %s\n", alias [ mt ] or escape ( mt ) ) ) end
    for k, v in pairs ( t ) do
        file:write ( string.format ( "k %s %s\nv %s %s\n", type ( k ), alias[ k ] or escape ( k ), type ( v ), alias[ v ] or escape ( v ) ) )
    end
    if mt then dumpfile ( file, mt, alias, seen ) end
    for k, v in pairs ( t ) do
        if type ( k ) == 'table' then dumpfile ( file, k, alias, seen ) end
        if type ( v ) == 'table' then dumpfile ( file, v, alias, seen) end
    end
end

local function addalias ( item, path, deep, seen )
    if item == nil and path == nil and deep == nil and seen == nil then item, path, deep = _G, "_G", true end
    seen = seen or { }
    if item == nil or path == nil or seen[ item ] ~= nil then
        return
    elseif type ( item ) == 'table' and deep then
        seen[ item ] = true
        for k, v in pairs ( item ) do
            if type ( v ) == 'table'  then
                addalias ( v, string.format ( "%s.%s", path , escape( k ) ), deep, seen )   
            elseif type ( v ) ~= 'string' and type ( v ) ~= 'number' and type ( v ) ~= 'boolean' then         ----- ###  8.   добавлено (учет boolean):  and type ( v ) ~= 'boolean' 
                aliases[ v ] = string.format ( "%s.%s", path, escape ( k ) )  
            end
        end
    else
        aliases[ item ] = path
    end
end
 
addalias ( math.huge, "math.huge" )
addalias ( -math.huge, "-math.huge" )

return { dumpstr = dumpstr, dumpfile = dumpfile, loadstr = loadstr, addalias = addalias }

elseif kt == 'boolean' then kcurr = alias[ k ] or k        
elseif vt == 'boolean' then tcurr [ kcurr ] = alias[ v ] or v

if kcurr ~= nil and kcurr == kcurr then rawset ( tcurr, kcurr, v ) end

do
    local smt = getmetatable ( "" )
    local __index = smt.__index
    smt.__index = function ( s, k )
        if type ( k ) == 'number' then
            return s:sub ( k, k )
        else
            return __index[ k ]
        end
    end
    smt.__len = function ( s ) 
        return s:len ( )
    end
end

local s = "foo bar"for i = 1, #s do print ( i, s[ i ] ) end

К несчастью, то ж бывает у людей:
Как ни полезна вещь, — цены не зная ей,
Невежда про нее свой толк все к худу клонит;
А ежели невежда познатней,
Так он ее еще и гонит.