TGB (Все сообщения пользователя)

--  Модуль сериализации таблиц. Автор TGB ---
---------------------------
--- Быстрая сборка строки из массива строк ----
--  Не обязательный параметр pr = false - строка собирается в прямом порядке (от начала массива к концу); true - строка собирается в обратном порядке --
local function m_str_to_str_fast ( m_str , pr)
  if type (m_str) ~= 'table' then  return  nil,  ' ! Ошибка. Первый параметр m_str_to_str_fast не таблица ***' end
  local const_mod = 10,   m_str_tm
  local mod,  N , NN
  local N_mod, i_mod 
  ----
  if pr then
     m_str_tm = {}
    NN = #m_str
    for i =  NN, 1, -1   do   m_str_tm [NN - i +1] = m_str [i]   end
    m_str = m_str_tm;        m_str_tm = {}
  end
  while 1 do
       m_str_tm = {}      
       mod,  N,  NN  =  #m_str % const_mod,   math.floor (#m_str / const_mod),    #m_str
            N_mod = N * const_mod
            for i = 1, N do
              i_mod = (i -1)*const_mod
                 m_str_tm [i] = m_str [ i_mod + 1] .. m_str[ i_mod + 2] .. m_str [ i_mod + 3] .. m_str [ i_mod + 4] .. m_str [ i_mod + 5] 
                              .. m_str [ i_mod + 6]  .. m_str [ i_mod + 7] .. m_str [ i_mod + 8] .. m_str [ i_mod + 9] .. m_str [ i_mod + const_mod]
           end
            if mod > 0 then
               N = N + 1;    m_str_tm [N]  = ''
               for i = 1, mod   do  m_str_tm [N] =  m_str_tm [N] .. m_str [N_mod + i]  end
            end
      ----
       if  #m_str_tm  > 1 then  
            m_str = m_str_tm
        else return m_str_tm [1]
        end
  end
end
----------------------------------

----------------------------------
---             Вывод  произвольной таблицы  в виде таблицы-массива строк (либо в виде строки)         ------
------  Параметры: 
--      1) t  -  таблица (выводятся все вложения до limit);  
--      2) i  -  строка формирования отступа при выводе вложений (например, '  ')  
----    3) limit - уровень вложенности до которого просматривается таблица (если = 0, то все уровни)-----
----    4) (не обязательный) <Вид выдачи резкльтата: false – таблица (по умол-чанию); true - строка>
----    5) (не обязательный) <Таблица имен элементов (задаваемых в ключах) , не разворачиваемых далее >
--- ! Результат: таблица строк:   структура со значениями таблицы t  (текстовая сортировка по возрастанию индексов таблиц) либо строка, 
---                                                   в зависимости от параметра pr-----
---  !!  Элемент таблицы [1] - заголовок таблицы. Остальные элементы - строковые представления  структуры таблицы t 
---       с дополнительными служебными описаниями вложенных в t таблиц.   
local function dump_tbl (t, i, limit, pr, list)
   if type(t) ~= 'table' then
       if pr   then    return  ' Первый параметр t не таблица.  Результат: ' .. tostring(t) end
       return nil,  '! Ошибка. Первый параметр t не таблица'
   end  
   list = list or {} 
   if type(list) ~= 'table' then
         return nil,  '! Ошибка. Параметр list не таблица'
   end 

   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
      Level = Level +1  --- Уровень вложенности таблицы ----
      
      ---  Обработка метатаблицы   ----
      local  mt   =  debug.getmetatable ( t ) 
      if  mt  then                       
          nm_tm = seen[mt] 
            if  nm_tm  then 
               tbl[#tbl +1]  =  i .. 'Для таблицы ' ..  nm .. '   cсылка на существующую метатаблицу   ->  ' .. 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   --- 
          t_k = ss [v]   -- ключ записи в t
          t_v=t [t_k]   -- значение записи в t
        
         if Level < limit or limit == 0 then
                if type(t_k) ==  'table' then                                 --- Обработка ключа-таблицы ---
                   nm_tm = seen[t_k]
                       if  nm_tm  then 
                           tbl[#tbl +1]  =  i .. '[ ' ..  tostring(t_k) .. ' -  cсылка на существующую таблицу-ключ  ->  ' .. nm_tm .. ']' .. '\n'
                       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 list [v] then
              if type(t_v) == 'table' then
                   tbl[#tbl +1]  =  i .. '[' .. v .. ']   (' .. type(t_v) .. ') = ' .. tostring(t_v) .. '  |  Терминальная таблица (в печати задано далее не разворачивать) ### \n'
             else   
                  tbl[#tbl +1]  =  i .. '[' .. v .. ']   (' .. type(t_v) .. ') = ' .. tostring(t_v) .. '\n'
             end   
           else          
                  tbl[#tbl +1]  =  i .. '[' .. v .. ']   (' .. type(t_v) .. ') = ' .. tostring(t_v) .. '\n'
                  if type(t_v) == 'table' then   ---  Обработка таблицы   ----                                          
                 nm_tm = seen [ t_v]  
                      if  nm_tm  then 
                          tbl[#tbl +1]  =  i .. '[' .. v .. ']     ссылка на существующую таблицу  ->  ' .. nm_tm .. '\n'
                      else                                                   
                        tbl[#tbl +1]  =  i .. 'Вложенность: ' .. Level .. '  === Содержимое таблицы :  '  .. v .. '\n'
                   dump(t_v, i..'\t', tostring(t_k))
                       tbl[#tbl +1]  =  i .. 'Вложенность: ' .. Level .. '  === Конец таблицы   ' .. v .. '\n'
                      end                  
                  end 
              end   
          end
        end
      Level = Level - 1
      return ''
    end
   --------------
    dump(t,i, tostring(t))  
    if pr then               --- Выдача результата в виде строки
        return  m_str_to_str_fast ( tbl)  
    else   return  tbl     --- Выдача результата в виде массива строк
    end    
end

-------------------------------- Общие данные модуля -----------------------------------------
---  1. Для выделения строк используется скобки [[     ]] и поэтому внутри них не надо никаких преобразований (типа замены \ на \\ и т.д).
--   2. В выдаваемых стоках для удобства анализа, места, на которые надо обращать внимание в первую очередь выделены символом ###.
----
local aliases_cont = { }      ---   [ <Внутреннее имя ссылочного значения> ] = <Внешнее имя ссылочного значения в контексте>
local aliases_v_cont = { }   ---   [ <Внешнее имя ссылочного значения в контексте> ] = <Ссылочное значение в контексте>
local wo_creator      -- Призак где сформирована таблицы 
local tbl_cont = _G  --- Контекст по умолчанию ---
local context_tbl = 'CONT'  -- Имя, присвоенное контексту
-----
----- Формирование внутренних имен --
local function internal_name ( s )   
    return  tostring ( s ):gsub ( ': ', '' )
end

----------------------------------------------
--  Параметры 
--   1) 1-й параметр либо таблица, либо пользовательская функция соз-дания таблиц контекста (по образцу аналогично тому, 
--   как это делается в creating_link_tables). В случае функции, при создании, изменении контек-стэтом вместо  creating_link_tables 
--    запускается пользовательская функ-ция.
--   2)  необязательный, если 1, то принудительное обновление таблиц формируемых в ней
--  Результаты : две таблицы формируемые в ней.
---
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 cont  then   aliases_cont, aliases_v_cont = cont, v_cont  end
     return aliases_cont, aliases_v_cont 
  end
  ------
  if pr  then   aliases_cont, aliases_v_cont = {},  {}   end   -- Обновление общих данных ---
  if  next (aliases_cont) ~= nil  and  not pr    then   return    end    ----  
  if type(context) ~= 'table' then context = tbl_cont  end
  ----
  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 = internal_name (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 = internal_name (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
 
  cr_link_tables (context, path)
--  MessageDb ( 1, 1, 'Скрипт', ' Финальные проверки. creating_link_tables - aliases_v_cont :  \n' .. dump_str (  aliases_v_cont , ' ', 0))
---[[
    -- Обработка внешних локальных ссылочных данных контекста ---
   local level = 2, 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 = internal_name ( value)
                 path_tm = '###: LOC.' ..  tostring (level) .. '.' ..  tostring (ii) .. '.' .. name
                     if not aliases_cont [k_tm]   then   aliases_cont [k_tm] = path_tm    end      --- ### ?? возможна перезапись   ---
 --                   aliases_cont [k_tm] = path_tm
                      aliases_v_cont [ path_tm ] = value
              end
                else
                 break               
            end
            ii =  ii  + 1
         end
       else
          break
       end
       level = level + 1
   end
   
   ---------------------------- 
---]]
  return aliases_cont, aliases_v_cont 
end
------------------------------------------------------------
--  Функция создает байт-код либо строку-скрипт Lua, при запуске которого восстанавливается таблица t. 
--  В эту же строку в конец добавляется две таблицы ссылочных значений 
----  Параметры:
--    1.  t  - сереализуемая таблица 
--    2. ph_f - (не обязательный)  путь файл сброса строки-скрипта либо признак (0 | 1) выдачи образа в виде (байт-кода | строки - скрипта)
--    3. context  - - (не обязательный) контекст
--   Результат в зависимости от входных параметров: <Функция Lua > (один тараметр)  | <Строка-скрипт> (второй параметр = 1) 
--                                                                                  | <Запись строки-скрипта в файл> (второй параметр строка путь к файлу)
local function tbl_to_str ( t, ph_f, context) 
  ----Контроль параметров ---
  if type ( t ) ~= 'table' then  
      return nil,  '!! Ошибка. Второй параметр не таблица.'  
  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

  creating_link_tables (context) 
  ------
  local  name_alias = 'alias'  --- для формирования команд с учетом alias ---- 
  local env_t  =  context_tbl
  local env =  env_t .. '.'
  local path =  '###: TBL'
  local t_str = {}   --- для сбора строк   
  ---
  local name_t, context_t = {}, {}
  
  -----------------------------------------
  local function tbl_str ( t, path, seen )
    seen = seen or { }
    if seen [ t ]  then  
      return   false,   env .. internal_name ( t ) 
   else   seen [ t ] = 0 end         
   -------
    local  n_t,  mt   =   env .. internal_name ( t ),   debug.getmetatable ( t ) 
   t_str [ #t_str + 1 ] = n_t .. ' =  {}                                    --- создание таблицы: ' .. n_t .. ' -- \n'  
   local n_tt,  n_kt,  n_vt , st, nm_t, path_t

    for k, v in pairs ( t ) do    
       if  (type(v) == 'number' or type(v) == 'boolean' or type(v) == 'string') then  -- Простое значение --
          if  type(v) == 'string'  then
               n_vt = '[[' ..  v  .. ']]' 
          else    n_vt = tostring (v)
          end 
      elseif type ( v ) == 'table' then  ---  Таблица-значение  --
         n_vt = internal_name (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 .. ' - [' .. internal_name (v)  .. '] значение-таблица (конец) @  \n' 
      else   --- Ссылочное значение ---
          nm_t = internal_name (v)
         path_t = path .. '.' .. internal_name (k) 
         context_t [nm_t]  = aliases_cont [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  (type(k) == 'number' or type(k) == 'boolean' or type(k) == 'string') then  -- Простое значение --
          if  type(k) == 'string'  then
               n_kt = '[[' ..  k  .. ']]' 
          else    n_kt = tostring (k)
          end 
      elseif type ( k ) == 'table' then  ---  Таблица-ключ  ---
         n_kt = internal_name (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 ] = ' --  Таблица ' ..  internal_name ( k ) .. ' была создана ранее ----\n ' end
         t_str[ #t_str + 1 ] =  ' --- ' ..  n_kt .. ' - [' .. internal_name (k) .. '] ключ таблица (конец) @  \n'      --- 
      else   --- Ссылочное значение  ключа ---
          nm_t = internal_name (k)
         path_t = path .. '.' .. nm_t 
          context_t [nm_t]  = aliases_cont [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
      
      n_tt =  env .. internal_name ( t )
      t_str[ #t_str + 1 ] =  n_tt .. ' [ ' ..  n_kt  .. ' ]  = ' .. n_vt  ..  ' \n'           
    end
   if  mt  then    --  создание  и подключение метатаблицы в конце прохода по таблице с тем, чтобы она не мешала заполнять таблицу. Иначе пришлось бы  использовать rawset  ---
       t_str[ #t_str + 1 ] =  '               ---   Создание метатаблицы   --- \n'
      st,  mt = tbl_str ( mt, path .. '.' .. internal_name (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) 
  ---  Формирование фрагментов скрипта  -----
  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 ' .. t_str[1]: match ( '(%S*)') ..  '\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    
  else   ----------------------
     local s_a = {}  --- для сбора строк  ----
    ----
     local s = scr1 .. m_str_to_str_fast ( 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 = m_str_to_str_fast ( s_a)  --  массив строк -> строка
     -----
     s =  s .. s_a  
    if ph_f == 1 then 
       return s   --- Строка-скрипт ---
    else        
       return load ( s )  -- !!!  байт-код скрипта (два результата) ---
    end 
  end
  ------
end
----------------------------------------------------------------------
---              str_to_tbl (<Байт-код скрипта для восстановления <T>, либо строка-скрипт)>[, <Контекст>] )
---  Результаты. Их может быть один или три (если есть висячие ссылочные значения):
--  1-й - восстановленная таблица с gjvtnrjq висячих ссылок,  если такие существуют в виде составных имен в контексте сереализации.
--  Второй и третий – 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,  '! Ошибка во 2-м параметре ф-ции str_to_tb  (он должен быть типа string или function )'
   end
   
    local err 
   if type (str_fun) == 'string' then   
       str_fun , err = load ( str_fun );   if  err ~= nil  then   return  nil, err  end 
   end  
    ---------   
    local cont_t,  tbl_t    =   str_fun ()   
   creating_link_tables ( context ) 
   
   ---  Проверка  существования ссылочных значений таблицы -----
    local cont_err,  t_err  =   {}, {}   
    local N_err = 0 
   local v_tm
   --- Первый этап разрешения ссылок ---
   for k, v in pairs ( cont_t ) do
        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
         t_err [ k] =  tbl_t [k]
       end
   end 
   --- Второй этап разрешения ссылок ---
   if N_err > 0 then
       local cont_err_tm = cont_err 
       for k, v in pairs ( cont_err_tm) do
           local  i_mt = # v
         local  v_tm,  yes 
         for i =  i_mt , 1 do  if  v: sub(i, i) == ','   then  i_mt = i;   break   end   end
              if    i_mt <=  # v   then  
                  for i =  i_mt  - 1 , 1 do  if  v: sub(i, i) == ','   then  i_mt = i;   break   end   end   
            i_mt = i_mt + 1
               v_tm =  v: sub(i_mt)
            yes = nil
            for k_k, v_v in pairs ( aliases_v_cont ) do   --- 
                    if    k_k: find( v_tm, i_mt)    then 
                    cont_t [k] =  v_v; yes = 1 break 
               end
            end
                if    yes then 
                    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
-----
 return { tbl_to_str = tbl_to_str, str_to_tbl = str_to_tbl,  creating_link_tables = creating_link_tables,   dump_tbl = dump_tbl ,   m_str_to_str_fast = m_str_to_str_fast }  ---

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 }