---- Модуль сереализация (с сылочными данными) ----
----------------------------------
----------------------------------
--- Вывод любых данных Lua. В том числе любых таблиц, в виде таблицы-массива строк (либо в виде строки) ------
------ Параметры: 
-- 1) t - любой тип; если таблица, то выводятся все вложения до значения параметра limit; 
-- 2) i - начальная строка формирования отступа при выводе вложений (например, ' ') 
---- 3) limit - уровень вложенности до которого просматривается таблица (если = 0, то все уровни)-----
---- 4) pr - (не обязательный) <Вид выдачи результата: 0 (по умолчанию)– строка (образ таблицы); 1 - таблица-массив строк образа таблицы>
---- 5) list - (не обязательный) <Таблица имен элементов (задаваемых в ключах) , не разворачиваемых далее >
--- ! Результат (если t - таблица): таблица-массив строк или строка, в зависимости от параметра pr. 
--- Элемент результата вывода таблицы: заголовок таблицы. Остальные элементы - строковые представления структуры таблицы t 
--- с дополнительными служебными описаниями вложенных в t таблиц. 
local function dump_tbl(t, i, limit, pr, list)
 if type(t) ~= 'table' or i == nil then
 return 'Тип ' .. type(t) .. ': ' .. tostring(t)
 end 
 
 list = list or {} 
 if type(list) ~= 'table' then
 return nil, '! Ошибка. Параметр list не таблица'
 end 
 pr = pr or 0
 limit = limit or 0
 local tbl = {}; --- для сбора результата ----
 tbl[#tbl + 1] = '===== Таблица (текстовая сортировка по возрастанию индексов таблиц): ' .. tostring(t) 
 .. ' \n ! Количество выводимых уровней вложенности (если = 0, то выводятся все) = ' .. limit .. '\n' 
 local seen={} -- просмотренные --
 local Level = 0
 ---------------------------------
 local function dump(t,i, nm) 
 nm = nm or 'T'
 if seen[t] then 
 return seen[t] 
 end 
 ------ 
 seen[t] = nm 
 local t_v, t_k, nm_tm, v_tm
 Level = Level + 1 --- Уровень вложенности таблицы ----
 
 --- Обработка метатаблицы ----
 local mt = debug.getmetatable(t) 
 if mt then 
 nm_tm = seen[mt] 
 if nm_tm then 
 tbl[#tbl + 1] = i .. 'У таблицы ' .. nm .. ' есть существующая метатаблица -> ' .. nm_tm .. '\n'
 else 
 nm_tm = tostring(mt) 
 tbl[#tbl + 1] = i .. 'Вложенность: ' .. Level .. ' === Содержимое метатаблицы ### : ' .. nm_tm .. '\n'
 dump(mt, i..'\t', nm_tm)
 tbl[#tbl +1] = i .. 'Вложенность: ' .. Level .. ' === Конец метатаблицы ## ' .. nm_tm .. '\n' 
 end 
 end 
 ---------------------------------
 if next(t) == nil then ---- Таблица пустая ---
 tbl[#tbl + 1] = i .. 'Вложенность: ' .. Level .. ' Таблица: ' .. nm .. ' пустая ### '.. '\n' 
 Level = Level - 1 
 return '' 
 end
 
 local s={} --- массив хранение имен ключей (строк) для сортировки ---
 local ss={} -- массив для хранения самих ключей -- 
 local n=0
 local ks=0
 for k, v in next, t do
 ks = tostring(k)
 n=n+1 
 s[n] = ks
 ss[ks] = k 
 end
 table.sort(s)
 
 for k,v in ipairs(s) do --- s - таблица-массив ---
 t_k = ss [v] -- ключ записи в t, v - имя ключа (tostring(t_k)) --
 t_v = t [t_k] -- значение записи в t --
 
 if Level < (limit + 2) or limit == 0 then
 --- Обработка ключа --- 
 v_tm = '[' .. v .. '] (' 
 if type(t_k) == 'table' then --- Обработка ключа-таблицы --- 
 nm_tm = seen[t_k]
 if nm_tm then 
 v_tm = '[' .. tostring(t_k) .. ' - cсылка на существующую таблицу-ключ -> ' .. nm_tm .. '] (' -- !! будет вместо v_tm
 else 
 tbl[#tbl + 1] = i .. 'Вложенность: ' .. Level .. ' === Содержимое ключа-таблица $$ : ' .. v .. '\n' 
 dump(t_k, i..'\t', tostring(t_k)) 
 tbl[#tbl + 1] = i .. 'Вложенность: ' .. Level .. ' === Конец ключа-таблицы $$ ' .. v .. '\n' 
 end 
 end 
 ----- Обработка поля -----
 if type(t_v) == 'table' then --- Обработка поля-таблицы ---- 
 nm_tm = seen[t_v] 
 if nm_tm then -- таблица уже обработана ---
 tbl[#tbl + 1] = i .. v_tm .. type(t_v) .. ') = ' .. tostring(t_v) .. ' ссылка на существующую таблицу -> ' .. nm_tm .. '\n'
 else
 if list[v] then
 tbl[#tbl + 1] = i .. v_tm .. type(t_v) .. ') = ' .. tostring(t_v) .. ' | Терминальная таблица (в печати задано далее не разворачивать) ### \n'
 else
 tbl[#tbl + 1] = i .. v_tm .. type(t_v) .. ') = ' .. tostring(t_v) .. '\n' 
 tbl[#tbl + 1] = i .. 'Вложенность: ' .. Level .. ' === Содержимое таблицы : ' .. v .. '\n'
 dump(t_v, i..'\t', tostring(t_k))
 tbl[#tbl + 1] = i .. 'Вложенность: ' .. Level .. ' === Конец таблицы ' .. v .. '\n'
 end
 end
 else
 tbl[#tbl + 1] = i .. v_tm .. type(t_v) .. ') = ' .. tostring(t_v) .. '\n' 
 end 
 ----------------------------- 
 end
 end
 Level = Level - 1
 return ''
 end
 --------------
 dump(t, i, tostring(t)) 
 if pr == 1 then --- Выдача результата в виде массива строк --- 
 return tbl 
 else return table.concat(tbl) --- Выдача результата в виде строки ---
 end 
end
 
 -------------- Общие данные модуля сереализации --------------
--- 1. Для выделения строк используется скобки [[ ]] и поэтому внутри них не надо никаких преобразований (типа замены \ на \\ и т.д).
-- 2. В выдаваемых стоках для удобства анализа, места, на которые надо обращать внимание в первую очередь, выделены символом ###.
----
local load_Lua = load
local tbl_cont_default = _ENV --- Таблица контекста сереализации по умолчанию ---
if _VERSION == "Lua 5.1" then
 load_Lua = loadstring
 tbl_cont_default = _G 
end
local tbl_cont_result --- Таблица контекста сереализации (результат) ---
----------- Таблицы связи с ссылочными данными контекста --
local aliases_cont = { } --- Записи таблицы: [<Внутреннее имя ссылочного данного (формируемое функцией tostring)>] 
 --- = <Внешнее имя ссылочного данного в контексте (в виде '###: CONT.<Имя1>.<Имя2>....)>
local aliases_v_cont = { } --- Записи таблицы: [<Внешнее имя ссылочного данного в контексте>] = <Ссылочное данное в контексте>
local wo_creator -- Признак кем сформирована таблицы 
local context_tbl = 'CONT' -- Имя, присвоенное контексту
 
------------------
-- Параметры 
-- 1) 1-й параметр либо <таблица контекста>, либо пользовательская функция создания таблиц контекста (по образцу аналогично тому, 
-- как это делается в creating_link_tables). В случае функции, при создании, изменении контекстом вместо creating_link_tables 
-- запускается пользовательская функция.
-- 2) необязательный, если он не эквивалентен false, то обязательное обновление таблиц, сформированных в функции ранее.
-- Если нет обязательного обновления и если tbl_cont_result == <таблица контекста>, то вызов функции creating_link_tables, 
-- таблицы aliases_cont, aliases_v_cont не изменяет.
-- Результаты : две таблицы формируемые в ней (aliases_cont, aliases_v_cont).
---
local function creating_link_tables(context, pr)
 if type(context) == 'function' then
 wo_creator = 'no creating_link_tables' 
 local cont, v_cont = context( pr) --- context должен выдавать два результата ---
 if type(cont) == 'table' and type(v_cont) == 'table' then 
 aliases_cont, aliases_v_cont = cont, v_cont 
 else
 return nil, '!!! Ошибка. Оба результата функции context должны быть таблицами'
 end
 return aliases_cont, aliases_v_cont 
 end
 ---------
 if pr then tbl_cont_result = nil end
 context = context or tbl_cont_default
 if type(context) ~= 'table' then return nil, '!!! Ошибка. type(context) ~= table ' end 
 if context == tbl_cont_result then return aliases_cont, aliases_v_cont end ---- ! не надо обновлять aliases_cont, aliases_v_cont
 ---------
 aliases_cont, aliases_v_cont = {}, {} -- Будет обновление таблиц ---
 ----
 wo_creator = 'creating_link_tables'
 local path = '###: ' .. context_tbl
 ----------------------------
 local function cr_link_tables(item, path, seen) -- Рекурсивная функция ---
 seen = seen or { }
 path = path or context_tbl
 local mt
 if item == nil or seen[item] ~= nil then
 return
 elseif type(item) == 'table' then
 seen [item] = true 
 -- Обработка метатаблицы (если есть в item)---
 mt = debug.getmetatable(item)
 if type(mt) == 'table' then cr_link_tables(mt, path .. '.' .. '.metatable###', seen) end
 ---
 local path_tm, kl_tm, k_tm
 for k, v in pairs(item) do
 if type(v) == 'table' then ---- таблица-значение --
 cr_link_tables (v, path .. '.' .. tostring(k), seen)
 else 
 if not (type(v) == 'number' or type(v) == 'boolean' or type(v) == 'string') then
 if type(k) == 'string' then kl_tm = '.' .. tostring(k) else kl_tm = '[' .. tostring(k) .. '] ' end
 path_tm = path .. kl_tm -- составное внешнее имя строки таблицы (имя элемента) 
 k_tm = tostring(v)
 if not aliases_cont[k_tm] then aliases_cont[k_tm] = path_tm end --- ### ?? возможна перезапись ---
 aliases_v_cont[path_tm] = v 
 end
 end
 ----
 if type(k) == 'table' then ---- таблица-ключ --
 cr_link_tables (k, path ..'.' .. tostring(k), seen)
 else 
 if not (type(k) == 'number' or type(k) == 'boolean' or type(k) == 'string') then
 if type(k) == 'string' then kl_tm = '.' .. tostring(k) else kl_tm = '[' .. tostring(k) .. '] ' end
 path_tm = '### ключ: ' .. path .. kl_tm
 k_tm = tostring(k)
 if not aliases_cont[k_tm] then aliases_cont[k_tm] = path_tm end --- ### ?? возможна перезапись ---
 aliases_v_cont[path_tm] = k 
 end
 end
 end
 end
 end
 ----
 if next(context) then --- таблица context не пустая ----
 cr_link_tables(context, path)
 end
 tbl_cont_result = context
 return aliases_cont, aliases_v_cont 
end
 
-- creating_link_tables() --- !! Подготовка контекста по умолчанию заранее ----
 
-- Обработка внешних локальных ссылочных данных контекста сереализации ---
local function creating_link_local()
 local level = 3, ii, name, value 
 local k_tm, path_tm
 while 1 do
 if debug.getinfo(level, 'n') then
 ii = 1
 while 1 do
 name, value = debug.getlocal(level, ii)
 if name then
 if not (type(value) == 'table' or type(value) == 'number' or type(value) == 'boolean' or type(value) == 'string') then
 k_tm = tostring(value)
 path_tm = '###: LOC.' .. tostring(level) .. '.' .. tostring(ii) .. '.' .. name
 if not aliases_cont[k_tm] then aliases_cont[k_tm] = path_tm end --- ### ?? возможна перезапись ---
 aliases_v_cont[path_tm] = value
 end
 else
 break 
 end
 ii = ii + 1
 end
 else
 break
 end
 level = level + 1
 end
 ------
end
 
------------------------------------------------------------
-- Функция tbl_to_str создает строку-скрипт Lua либо байт-код, при запуске которого восстанавливается (если <Количество неразрешенных ссылок> = 0) таблица t. 
-- В этот же байт-код либо строку-скрипт в конец добавляется две таблицы ссылочных данных 
---- Параметры:
-- 1. t - сереализуемая таблица 
-- 2. ph_f - (не обязательный) путь файл сброса строки-скрипта либо признак (0 (по умолчанию) | 1) выдачи образа в виде (строки - скрипта | байт-кода)
-- 3. context - (не обязательный) контекст
-- 4. exclude - (не обязательный) таблица исключений вида: { [<элемент-исключение>] = '<Описание>' ........}
-- ! <элемент-исключение> при сереализации заменяется строкой: 
-- '### Элемент-исключение: ' .. type (<элемент-исключение>) .. ' - ' .. <Описание>
-- Результат в зависимости от входных параметров: 1) байт-код скрипта или nil (если ошибка компиляции скрипта), <Таблица неразрешенных ссылок>
-- nil или <Таблица неразрешенных ссылок>, nil или текст ошибки компиляции скрипта
-- | 2) <Строка-скрипт>, nil или <Таблица неразрешенных ссылок> 
-- | 3) Возвращается nil или <Таблица неразрешенных ссылок> и выполняется запись строки-скрипта в файл
local function tbl_to_str(t, ph_f, context, exclude) 
 ----Контроль параметров ---
 if type(t) ~= 'table' then 
 return nil, '!! Ошибка. Параметр t не таблица.' 
 end
 ph_f = ph_f or 0
 local f_t 
 if type(ph_f) == 'string' then
 f_t = io.open(ph_f, 'w') 
 if type(f_t) ~= 'userdata' then return nil, '!! Ошибка при открытии файла' end
 end
 
 local context_yes, context_local_yes 
 ------
 local name_alias = 'alias' --- для формирования команд с учетом alias ---- 
 local env_t = context_tbl
 local env = env_t .. '.t' --- #####
 local path = '###: TBL'
 local t_str = {} --- для сбора строк 
 local level_t = 0 --- используется для формирования имен таблиц --
 --
 local context_err = {} --- таблица неразрешимых ссылок в context ---
 ---
 local function f_context_err(message, v) -- обработка ошибок ----
 context_err[v] = message
 return message .. v
 end 
 ---
 exclude = exclude or {}
 local name_t, context_t = {}, {}
 -----------------------------------------
 local function tbl_str( t, path, seen )
 seen = seen or { }
 if seen[ t ] then 
 return false, seen[ t ] 
 end 
 -------
 level_t = level_t + 1 --- для формирования имени таблицы -- 
 local n_t, mt = env .. tostring (level_t ), debug.getmetatable(t) 
 seen [t] = n_t 
 t_str [#t_str + 1] = n_t .. ' = {} --- создание таблицы: ' .. tostring(t) .. ' -- \n' 
 local n_kt, n_vt , st, nm_t, path_t, aliases_cont_nm_t 
 
 for k, v in pairs(t) do 
 ---- Обработка поля -----
 if exclude[v] then v = '### Элемент-исключение: ' .. type(v) .. ' - ' .. tostring(exclude [v]) end --- обработка исключенных элементов ---
 if type(v) == 'string' then
 if v:find(']') then --- ! есть варианты строк, котрые не компилируются, например, строка [[ [[]] ]] ----
 n_vt = 'string.gsub([[' .. v:gsub(']', '@$#') .. ']], "@$#", "]")'
 else
 n_vt = '[[' .. v .. ']]'
 end 
 elseif (type(v) == 'number' or type(v) == 'boolean') then 
 n_vt = tostring (v)
 if n_vt == '1.#INF' or n_vt == 'inf' then n_vt = [[type (math) == 'table' and math.huge or '*** не вычисленное huge в поле таблицы']] end
 elseif type(v) == 'table' then --- Таблица-значение --
 n_vt = tostring(k)
 t_str[#t_str + 1] = ' --- ' .. n_vt .. ' - значение-таблица (начало) @ \n'
 st, n_vt = tbl_str(v, path .. '.' .. n_vt, seen) 
 if not st then t_str[#t_str + 1] = ' -- Таблица ' .. n_vt .. ' была создана ранее ----\n ' end
 t_str[#t_str + 1] = ' --- ' .. n_vt .. ' - [' .. tostring(v) .. '] значение-таблица (конец) @ \n' 
 else --- Ссылочное данное ---
 if not context_yes then --- создание контекста ---
 context_yes = true 
 creating_link_tables(context) 
 end 
 nm_t = tostring(v)
 path_t = path .. '.' .. tostring(k) 
 aliases_cont_nm_t = aliases_cont[nm_t] 
 if not aliases_cont_nm_t and not context_local_yes then 
 --- Добавление локального контекста --
 context_local_yes = true 
 creating_link_local()
 -----------------
 aliases_cont_nm_t = aliases_cont[nm_t] --- повторное вычисление после добавления локального контекста --
 end 
 
 context_t[nm_t] = aliases_cont_nm_t or f_context_err('*** в контексте сереализации нет ссылочного данного ', nm_t )
 if name_t[nm_t] then 
 name_t[nm_t] = name_t [nm_t] .. ' | ' .. path_t 
 else name_t[nm_t] = path_t 
 end 
 n_vt = name_alias .. '[ [[' .. nm_t .. ']] ]' or '### err' 
 end
 
 --- Обработка ключа ----
 if exclude[k] then k = '### Элемент-исключение: ' .. type(k) .. ' - ' .. tostring(exclude[k]) end --- обработка исключенных элементов ---
 if type(k) == 'string' then
 if k:find(']') then --- ! есть варианты строк, котрые не компилируются, например, строка [[ [[]] ]] ----
 n_kt = 'string.gsub([[' .. k:gsub(']', '@$#') .. ']], "@$#", "]")'
 else
 n_kt = '[[' .. k .. ']]'
 end 
 elseif (type(k) == 'number' or type(k) == 'boolean') then 
 n_kt = tostring (k)
 if n_kt == '1.#INF' or n_kt == 'inf' then n_kt = [[type (math) == 'table' and math.huge or '*** не вычисленное huge в ключе таблицы']] end
 elseif type(k) == 'table' then --- Таблица-ключ ---
 n_kt = tostring(k)
 t_str[#t_str + 1] = ' --- ' .. n_kt .. ' - ключ-таблица (начало) @ \n' 
 st, n_kt = tbl_str(k, path .. '.' .. n_kt, seen) --- Создание таблицы ключа и ее 'скобок' ----
 if not st then t_str[#t_str + 1] = ' -- Таблица ' .. tostring(k) .. ' была создана ранее ----\n ' end
 t_str[#t_str + 1] = ' --- ' .. n_kt .. ' - [' .. tostring(k) .. '] ключ таблица (конец) @ \n' --- 
 else --- Ссылочное данное ключа ---
 if not context_yes then --- создание контекста ---
 context_yes = true 
 creating_link_tables(context) 
 end 
 nm_t = tostring(k)
 path_t = path .. '.' .. nm_t .. '.ключ###' --- #### ---
 aliases_cont_nm_t = aliases_cont[nm_t] 
 if not aliases_cont_nm_t and not context_local_yes then 
 --- Добавление локального контекста --
 context_local_yes = true 
 creating_link_local()
 ---
 aliases_cont_nm_t = aliases_cont[nm_t] --- повторное вычисление после добавления локального контекста --
 end 
 
 context_t[nm_t] = aliases_cont_nm_t or f_context_err('*** в контексте сереализации нет ссылочного ключа ', nm_t )
-- name_t[nm_t] = path .. '.' .. nm_t .. '.ключ###' --- #### ---
 if name_t[nm_t] then 
 name_t[nm_t] = name_t[nm_t] .. ' | ' .. path_t 
 else name_t[nm_t] = path_t 
 end 
 n_kt = name_alias .. '[ [[' .. nm_t .. ']] ]' or '### err' 
 end
 
 t_str[#t_str + 1] = n_t .. ' [ ' .. n_kt .. ' ] = ' .. n_vt .. ' \n' 
 end
 
 --- Обработка метатаблицы ----
 if mt then -- создание и подключение метатаблицы в конце прохода по таблице с тем, чтобы она не мешала заполнять таблицу. ---
 t_str[#t_str + 1] = ' --- Создание метатаблицы --- \n'
 st, mt = tbl_str(mt, path .. '.' .. tostring(mt), seen)
 if not st then t_str[#t_str + 1] = '-- Метатаблица ' .. mt .. ' была создана ранее ----\n ' end
 t_str[#t_str + 1] = 'debug.setmetatable(' .. n_t .. ', ' .. mt .. ') --- подключение метатаблицы ' .. mt .. ' --- \n' 
 end
 return true, n_t --- 1 - й результат - признак создания таблицы
 end
 ---------------------
 tbl_str(t, path) 
 if not next(context_err) then context_err = nil end
 --- Формирование фрагментов скрипта -----
 local scr1 = 'local '.. name_alias .. ' = {...}; ' .. name_alias .. ' = ' .. name_alias .. ' [1] ; local ' .. env_t .. ' = {} \n' 
 .. '\n if type(' .. name_alias .. ') == "table" then \n'
 local scr2 = '\n return ' .. context_tbl .. '.t1 \n else \n--- Две таблицы внутренних имен ссылочных данных : \n ' 
 .. ' -- 1) name_cont [<Внутреннее имя ссылочного данного>] = ###: <Составное имя значения в контексте сереализации таблицы> \n'
 .. ' -- 2) name_t [<Внутреннее имя ссылочного данного>] = ###: <Список составных имен таблицы, ссылающиеся на значение > \n'
 .. '--- ! Составные имена таблицы (если их неколько) разделены символом | . \n'
 
 local scr3 = '\n local name_cont = { '
 local scr4= '\n local name_t= { ' 
 local scr5 = '\n} '
 local scr6 = '\n return name_cont, name_t end \n '
 ----------------------------
 if type(f_t) == 'userdata' then --- Запись строки-скрипта в файл ----
 f_t: write(scr1) 
 for i = 1, #t_str do f_t:write(t_str[i]) end
 f_t: write(scr2) 
 f_t:write(scr3) 
 for k, v in pairs(context_t) do f_t:write('\n [ [[' .. k .. ']] ] = [[' .. v ..']],') end
 f_t:write(scr5)
 f_t:write(scr4) 
 for k, v in pairs(name_t) do f_t:write('\n [ [[' .. k .. ']] ] = [[' .. v ..']],') end
 f_t:write(scr5)
 f_t:write(scr6)
 f_t:close()
 return context_err --- таблица неразрешенных ссылок ---
 else ----------------------
 local s_a = {} --- для сбора строк ----
 ----
 local s = scr1 .. table.concat(t_str)
 s_a[#s_a + 1] = scr2
 s_a[#s_a + 1] = scr3 
 for k, v in pairs(context_t) do s_a[ #s_a + 1 ] = '\n [ [[' .. k .. ']] ] = [[' .. v ..']],' end
 s_a[#s_a + 1] = scr5 
 s_a[#s_a + 1] = scr4 
 for k, v in pairs(name_t) do s_a[ #s_a + 1 ] = '\n [ [[' .. k .. ']] ] = [[' .. v ..']],' end
 s_a[#s_a + 1] = scr5 
 s_a[#s_a + 1] = scr6
 s_a = table.concat(s_a) -- массив строк -> строка
 -----
 s = s .. s_a 
 if ph_f == 0 then 
 return s, context_err --- строка-скрипт и таблица неразрешенных ссылок ----
 else 
 local f, er = load_Lua(s) 
 return f, context_err, er
 end 
 end
 ------
end
----------------------------------------------------------------------
--- str_to_tbl (<Байт-код скрипта для восстановления <T>, либо строка-скрипт)>
-- [, <Контекст (таблица или функция создания контекста восстановления)>] )
--- Результаты. Их может быть один или три (если есть висячие ссылочные данные):
-- 1-й - восстановленная таблица с пометкой висячих ссылок, если такие существуют в виде составных имен в контексте сереализации.
-- Второй и третий – nil, если висячих ссылок нет или две таблицы:
-- - таблица висячих ссылок с указанием составных имен-адресов в кон-тексте сереализации;
-- - таблица висячих ссылок с указанием составных имен –адресов в <T>. 
-- В таблицах висячих ссылок есть данные, облегчающие восстановление этих ссылок.-
------
local function str_to_tbl(str_fun, context)
-- MessageDb (2, 0, 'Скрипт', ' str_fun str_fun: \n' .. dump_str ( str_fun , ' ', 0))
 if type(str_fun) ~= 'string' and type(str_fun) ~= 'function' then
 return nil, '! Ошибка в первом параметре ф-ции str_to_tbl (он должен быть типа string или function )'
 end
 
 local err 
 if type(str_fun) == 'string' then
 if str_fun == '' then return nil, '! Ошибка в первом параметре ф-ции str_to_tbl (он не должен пустой строкой)' end 
 str_fun , err = load_Lua(str_fun); if err ~= nil then return nil, err end 
 end 
 --------- 
 local cont_t, tbl_t = str_fun()
 if type(cont_t) ~= 'table' or type(tbl_t) ~= 'table' then return nil, '! Ошибка в ф-ции str_to_tbl (cont_t или tbl_t не таблица)' end 
 if next(cont_t) then --- cont_t не пустая таблица: создание контекста ---
 creating_link_tables(context) 
 --- Добавление локального контекста --
 creating_link_local()
 end
 
 --- Проверка существования ссылочных данных таблицы -----
 local cont_err, t_err = {}, {} 
 local N_err = 0 
 local v_tm
 --- Первый этап разрешения ссылок ---
 for k, v in pairs(cont_t) do ---- k - внутреннее имя, v - внешнее имя
 v_tm = aliases_v_cont[v] 
 if v_tm then --- есть ссылочное данное ---
 cont_t[k] = v_tm
 else --- сбор неразрешенных ссылок ---
 N_err = N_err + 1 
 cont_err[k] = v --- v - внешнее имя в контексте --
 t_err [k] = tbl_t[k] ---- tbl_t[k] - список внешних имен в таблице ---
 end
 end 
 --- Второй этап разрешения ссылок (имеет смысл для быстрого поиска использовать таблицу,
 -- созданную по данным aliases_v_cont: {[<Последняя составляющая внешнего имени контекста>] = <Ссылочное данное>} ---
-- MessageDlg(1, 1, 'Скрипт str_to_tbl -----------------------', 'N_err = ' .. dump_tbl(N_err, ' ', 0, 1))
 if N_err > 0 then
 local i_mt, l_v, nm_v 
 local aliases_v_cont_t = {} -- вспомогательная таблица для быстрого поиска последней составляющей внешнего имени ---
-- if N_err > 10 then
 for k_k, v_v in pairs(aliases_v_cont) do --- 
 l_v = # k_k
 i_mt = 0
 for i = l_v , 1, -1 do if k_k:sub(i, i) == '.' then i_mt = i; break end end --- #### Для выделения последней составляющей внешнего имени ---
 l_v = -(l_v - i_mt) 
 aliases_v_cont_t[k_k:sub(l_v)] = v_v
 end
-- end
-- MessageDlg(1, 1, 'Скрипт str_to_tbl -----------------------', 'N_err = ' .. dump_tbl(N_err, ' ', 0, 1)) 
 for k, v in pairs(cont_err) do
 if not (v:find( '*** в контексте сереализации нет')) then 
 l_v = # v
 i_mt = 0
 for i = l_v , 1, -1 do if v:sub(i, i) == '.' then i_mt = i; break end end --- #### Для выделения последней составляющей внешнего имени (.<Имя>)---
 l_v = -(l_v - i_mt) --- для выделение последней составляющей внешнего имени (отрицательное число) --- 
 nm_v = aliases_v_cont_t[v:sub(l_v)] 
 if nm_v then
 cont_t[k] = m_v
 N_err = N_err -1
 cont_err[k] = nil
 t_err[k] = nil 
 end
 end 
 end 
 end
 -----
 if N_err > 0 then
 return str_fun(cont_t), cont_err, t_err
 else
 return str_fun(cont_t)
 end
end
 
----- Вывод таблицы в строку ------
-- Преобразование таблицы без ее метатаблицы (ключи и значения : table, boolean, number, string) в текстовое представление 
-- в соответствии с синтаксисом языка lua ---
---- Можно использовать для сохранения таблиц в текстовом виде, с возможностью последующего восстановления 
-- со следующими ! ограничениями:
-- 1) ключи и поля типа: table, boolean, number, string;
-- 2) все элементы таблицы (ключи и поля) типа table должны быть уникальными (в пределах таблицы с учетом всех ее вложенностей).
------ Параметры: 1) t - таблица (выводятся все вложения ); 
-- 2) не обязательный i - начальная строка формирования отступа при выводе вложений (например, " "); если i = '', 
-- то строки таблицы выводятся без отступов 
-- Результат (два): 1) строка (тремя звездочками помечены проблемные места); 
-- 2) количество записей, которые нельзя представить в текстовом виде для последующего восстановления таблицы ----
local key_tbl_stateOS= "--таблица: "
-----
local function tbl_to_string(t, i)
 if type(t) ~= "table" then
 return nil
 end 
 i = i or ''
 local tab = "\t"
 if i == '' then tab ='' end
 
 local ltime_str 
 if GetLocalTimeMls then
 ltime_str= GetLocalTimeMls()
 else
 ltime_str= os.time() --- #### для пакета в котором недоступен GetLocalTimeMls
 end
 
 local tbl = {} --- для результата ----
 local no_unpack =0
 -----------
 local function dump(t, i, seen) ---------
 if seen then
 if seen[t] then 
 return seen[t] 
 end 
 tbl[#tbl + 1] = " { -- " .. tostring(t) .. "\n" 
 else
 seen={} -- просмотренные --
 tbl[#tbl + 1] = "{" .. key_tbl_stateOS .. string.format("%.0f", ltime_str) .. " -- время создания os.time() \n"
 end
 seen[t] = tostring(t)
 if debug.getmetatable(t) then 
 no_unpack = no_unpack + 1; 
 tbl [#tbl + 1] = i .. ' --- *** У таблицы ' .. tostring(t) .. ' есть метатаблица, которая в функции tbl_to_string не обрабатывается \n' 
 end
 local bracket = true -- скобка (начало) ---
 --
 for k,v in next, t do
 if type(k) == "table" then
 if bracket then tbl [#tbl + 1] = i .. " [\n"; bracket = false else tbl [#tbl +1] = i .. ", [\n" end 
 if dump(k, i .. tab, seen) then
 tbl [#tbl + 1] = "*** -> " .. tostring(k) .. '\n' 
 no_unpack = no_unpack + 1 
 end
 tbl [#tbl + 1] = i .. " ] = " 
 else
 if bracket then tbl [#tbl + 1] = i .. " [ "; bracket = false else tbl [#tbl +1] = i .. ", [ " end 
 if type(k) == "function" or type(k) == "userdata" or type(k) == "thread" then
 tbl [#tbl +1] = "*** " .. type(k)
 no_unpack = no_unpack + 1
 end 
 if type(k) == "string" then
 tbl [#tbl + 1] = "'".. tostring(k) .. "'"
 else
 tbl [#tbl + 1] = tostring(k)
 end
 tbl [#tbl + 1] = " ] = " 
 end 
 
 if type(v) == "table" then
 if seen[v] then
 tbl [#tbl + 1] = "*** -> " .. tostring(v) .. '\n' 
 no_unpack = no_unpack + 1 
 else 
 dump(v, i .. tab, seen) --- 
 end
 else
 if type(v) == "function" or type(v) == "userdata" or type(v) == "thread" then
 no_unpack = no_unpack +1
 tbl [#tbl + 1] = "*** " .. tostring(v) .. '\n'
 else
 if type(v) == "string" then
 tbl [#tbl + 1]= '"' .. v .. '" \n'
 else
 tbl [#tbl + 1] = tostring(v) .. "\n"
 end
 end
 end
 end
 --
 tbl[#tbl + 1] = i .. " } \n"
 end
 ---------------------
 dump(t,i) 
 tbl[#tbl] = i .. "}".. key_tbl_stateOS .. string.format("%.0f", ltime_str) .. "\n" --- !!! заменяется последняя фугурная скобка ---
 return table.concat(tbl), no_unpack ----- Результат: 1) строка ; 2) количество значений, не представимых в виде строки ----
end
-----
---- Преобразование строки - таблицы в таблицу --------------------
--- Результат: таблица ------
local function string_to_tbl(str_tbl)
-- Msg_Message (" string_to_tbl ", "return " .. str_tbl)
 if str_tbl:find("{") == nil then return nil end --- если в строке str_tbl нет {
 local tbl , err_tbl = load_Lua ("return " .. str_tbl) ---- assert (load_OS ( "retur " .. 4)) -- $$$$
 if err_tbl ~= nil then
 if Msg_Message and MessageDlg then
 Msg_Message(" string_to_tbl ", "!!! Ошибка в синтаксисе таблицы: " .. err_tbl .. '\n' .. str_tbl) --- err_tbl) 
 MessageDlg(1, 1, 'string_to_tbl', "!!! Ошибка в синтаксисе таблицы: " .. err_tbl .. '\n' .. str_tbl)
 end 
 return nil
 end
 return tbl()
end
------
-----------------------------------------------
---- ! Оформление в виде модуля------
 return {tbl_to_str = tbl_to_str, str_to_tbl = str_to_tbl, creating_link_tables = creating_link_tables
 , dump_tbl = dump_tbl, tbl_to_string = tbl_to_string, string_to_tbl = string_to_tbl} ---
--------------------------------------

 --- Проверка модуля ---
 -- !! Вывод результатов тестирования модуля длинный. Поэтому выполняется в текстовый файл ---
IsRun = true
 
function main()
 ---- Подключение модуля сереализации/десереализации ----
 local table_serialization = require('table_serialization_all') --- Подключение модуля ---
 ---
 local tbl_to_str = table_serialization.tbl_to_str
 local str_to_tbl = table_serialization.str_to_tbl
 local creating_link_tables = table_serialization.creating_link_tables
 local dump_tbl = table_serialization.dump_tbl
 local tbl_to_string = table_serialization.tbl_to_string
 local string_to_tbl = table_serialization.string_to_tbl
 
 -----==============================================================--------------------------------------------------------
 message("Начало теста ----")
 
 local sss, sss_t , tbl_str, err_tbl_str 
 local file_rez, f_str, file_ser 
 
 ---- Файл сохранения лога (обнуляется при запуске текста) ----
 file_rez = io.open('D:\\log_ser.txt', 'w'); file_rez:close() --- Очистка file_rez ---
 ------
 file_rez = io.open('D:\\log_ser.txt', 'a+') --- 'rb' | 'a+' | 'wb'
 
 --------------------------------
 -- Пример функции, используемой в таблице test_tbl в качестве ее элемента ---
 local function f_test()
 return ' !!! Вызов функции из сереализированной таблицы \n' 
 end
 ---
 
 ---- Файл хранения сереализации (если он пустой, то в нем сохраняется строка сереализации глобальной таблицы Lua _G)----
 ---- !! Для повтора записи в этот файл его надо очистить ---
 file_ser = io.open('D:\\Ser_f.txt', 'r+'); 
 
 ------ Добавление записей в таблицу _G (потом можно проверить, что эти переменные участвуют в сереализхации/десереализации _G) ---
 aaaa1 = 5 -- Добавление записи в таблицу _G --- 
 aaaa2 = 'Добавление записи в таблицу _G' -- Добавление записи в таблицу _G --- 
 
 ----------------------------------------------------------------------------
 file_rez:write('--------- Печать таблицы _G: \n' .. dump_tbl(_G, ' ', 0))
 ---
 f_str = file_ser:read ('*a') -- Чтение файла хранения сереализации --
 file_rez:write('\n --- Содержимое file_ser:read: \n' .. dump_tbl(f_str, ' ', 0))
 ------
 if #f_str > 0 then -- Есть не пустая строка в файле хранения сереализованной таблицы _G, то десереализация ---
 tbl_str = str_to_tbl(f_str) 
 file_rez:write('\n --- Результат десереализации таблицы из строки файла file_ser: \n' .. dump_tbl(tbl_str, ' ', 0))
 else -- Сереализация G и запись полученной строки в файл ---
 --- Выполнение сереализации (два результата: строка и если есть ошибки сереализации, то таблица элементов типа function, thread, userdata) ---
 tbl_str, err_tbl_str = tbl_to_str(_G) 
 ---
 file_ser:write(tbl_str) --- Запись сереализованной таблицы _G в файл ---
 file_rez:write('\n --- Запись tbl_to_str(_G) в file_ser \n')
 if err_tbl_str then -- Ошибки сереализации: если они есть --
 file_rez:write('\n --- Ошибки при сереализации _G (<Таблица неразрешенных ссылок>) \n')
 file_rez:write(dump_tbl(err_tbl_str, ' ', 0))
 end 
 end
 
 ----- Таблица test_tbl будет нормально обработана tbl_to_str, но tbl_to_string ее обработать не может
 -- и это правильно (не выполняются ограничения для использования tbl_to_string)
 local t1 = {5,'t1'}
 local test_tbl = {1, 2 -- "Простой пример" таблицы для выполнения сереализации ---
 , {3, 4, ['Таблица'] ={5}, [t1] = '[t1]'}
 , [t1] = 7 
 , ['Тестирование вызова'] = f_test ---- f_test - функция ---
 }
 setmetatable(test_tbl, t1) -- подключение t1 к test_tbl в качастве метатаблицы --
 ------------------------
 sss, sss_t = tbl_to_str(test_tbl) 
 file_rez:write('\n\n--- Результат сереализации таблицы "Простой пример" с помощью tbl_to_str: \n'.. sss)
 sss = str_to_tbl(sss)
 
 file_rez:write('\n\n--- Печать восстановленной таблицы (функцией str_to_tbl) "Простой пример": \n' .. dump_tbl(sss, ' ', 0))
 ---- Вызов функции из сереализированной таблицы ---
 file_rez:write('\n\n--- Печать результата вызова функции таблицы "Простой пример": \n' .. sss['Тестирование вызова']())
 -----------------
 
 sss, sss_t = tbl_to_string(test_tbl) 
 file_rez:write('\n\n--- Результат сереализации таблицы "Простой пример" с помощью tbl_to_string'
 .. '\n ( ! будут ошибки, помеченные ***, т.к. не выполняются ограничения для использования tbl_to_string): \n'.. sss)
 sss = string_to_tbl(sss)
 file_rez:write('\n\n--- Печать результата функции string_to_tbl(<Строка с ошибками сереализации>) (! ожидаемый результат nil): \n' .. dump_tbl(sss, ' ', 0)) 
 -----------------
 
 tbl_str = {1, 2 -- "Совсем простой пример" таблицы для выполнения сереализации ---
 , {3, 4, {5}, [t1] = '[t1]'}
 , [ { {}, '[8]' } ] = {'Совсем простой пример'} 
 }
 sss, sss_t = tbl_to_string(tbl_str) 
 file_rez:write('\n\n--- Результат сереализации таблицы "Совсем простой пример" с помощью tbl_to_string: \n'.. sss)
 sss = string_to_tbl(sss)
 file_rez:write('\n\n--- Печать восстановленной функцией string_to_tbl таблицы "Совсем простой пример": \n' .. dump_tbl(sss, ' ', 0)) 
 ------
 sss, sss_t = tbl_to_str(tbl_str) 
 file_rez:write('\n\n--- Результат сереализации таблицы "Совсем простой пример" с помощью tbl_to_str =================: \n'.. sss)
 sss = str_to_tbl(sss)
 file_rez:write('\n\n--- Печать восстановленной таблицы (функцией str_to_tbl) "Совсем простой пример" =============: \n' .. dump_tbl(sss, ' ', 0))
----------------
----------------
 --- Определение процессорного времени выполнения сереализации/десереализации таблицы _G с помощью tbl_to_str/str_to_tbl---
 local T = os.clock() * 1000
 tbl_str, err_tbl_str = tbl_to_str(_G)
 T = tostring(os.clock() * 1000 - T)
 message('Длительность сереализации таблицы _G функцией tbl_to_str: ' .. T)
 file_rez:write('\n\n--- Длительность сереализации таблицы _G функцией tbl_to_str:' .. T)
 ---
 T = os.clock() * 1000
 tbl_str, err_tbl_str = str_to_tbl (tbl_str)
 T = tostring(os.clock() * 1000 - T)
 message('Длительность десереализации таблицы _G функцией str_to_tbl: ' .. T)
 file_rez:write('\n\n--- Длительность десереализации таблицы _G функцией str_to_tbl: ' .. T)
 -- file_rez:write('Печать десереализованной таблицы G: \n' .. dump_tbl(tbl_str, ' ', 0))
 --------------------------------------------------------------------------------------------
 file_rez:close()
 file_ser:close()
 message("Конец теста ----")
 -------------------------------------------------------------------------------------------------------------
-- while IsRun do 
-- sleep(100) 
-- end
 ------------------
end
 
function OnStop()
 IsRun = false
 return 10000 
end