Hareng

-- Définitions pour l'extracteur/inséreur --
little_endian = true
big_endian = false

EXT=1
INS=2

modes_ext_ins = {
   ["SANS_POINTEURS"] = { ext = "X", ins = "X", taille = 2, inverser = true },
   ["SNES16"] = { ext = "X", ins = "X", taille = 2, inverser = true },
   ["SNES24-HighRom"] = { ext = "X-$C00000", ins = "X+$C00000", taille = 3, inverser = true },
   ["SNES24-LowRom1"] = { ext = "(X/$10000)*$8000+X%$8000", ins = "((X/$8000)*$10000)+(X%$8000)+$8000", taille = 3, inverser = true },
   ["SNES24-LowRom2"] = { ext = "(X/$10000-$80)*$8000+X%$8000", ins = "(((X/$8000)+$80)*$10000)+(X%$8000)+$8000", taille = 3, inverser = true }
}

function extraire(nom_rom, nom_table, nom_texte, debut_txt, fin_txt, pt_arg1, pt_arg2, pt_arg3, pt_arg4, pt_arg5)
   local rom = Fichier.new()

   local texte = Buffer.new()
   local table = Table_ext_ins.new()
   local sortie = Output.new("Fichier", nom_texte, "w")
   local pointeurs = Table_pointeurs.new()

   local debut_pt, nb_pt, taille_pt, calcul, inverser

   print(string.format("Extraction du script '%s'", nom_texte))

   if (type(pt_arg1) == "number") then
      debut_pt = pt_arg1
      nb_pt = pt_arg2
      taille_pt = pt_arg3
      calcul = pt_arg4
      inverser = pt_arg5
   elseif (type(pt_arg1) == "string") then
      if (pt_arg1 == "SANS_POINTEURS") then
         nb_pt = 0
         debut_pt = 0
         calcul = "X"
      else
         debut_pt = pt_arg2
         nb_pt = pt_arg3
         calcul = modes_ext_ins[pt_arg1].ext .. string.format("+$%X", pt_arg4) .. string.format("-$%X", pt_arg5)
      end

      taille_pt = modes_ext_ins[pt_arg1].taille
      inverser = modes_ext_ins[pt_arg1].inverser
--      calcul = modes_ext_ins[pt_arg1].ext .. string.format("+$%X", pt_arg4) .. string.format("-$%X", pt_arg5)

   else
      error("arg #6 : number or string expected", 2)
      return
   end

   table:ouvrir(nom_table, EXT)
   rom:open(nom_rom, "rb")

   if (nb_pt ~= 0) then
      pointeurs:charger(rom, debut_pt, nb_pt, taille_pt)
   end

   if (inverser) then
      pointeurs:inverser()
   end

   pointeurs:calculer(calcul)

   calcul = string.format("X-$%X", tronquer(debut_txt, taille_pt))
   pointeurs:calculer(calcul)

   rom:seek(debut_txt, 0)
   rom:read(texte, fin_txt - debut_txt + 1)
   rom:close()

   Ext_ins.extraire(texte, table, sortie, pointeurs)

   print("Extraction terminée !\n")
end

function inserer(nom_rom, nom_table, nom_texte, debut_txt, fin_txt, pt_arg1, pt_arg2, pt_arg3, pt_arg4, pt_arg5)
   local rom = Fichier.new()

   local texte = Buffer.new()
   local table = Table_ext_ins.new()
   local sortie = Output.new("Buffer")
   local pt_buffer_sortie = sortie:get_buffer()
   local pointeurs = Table_pointeurs.new()

   local debut_pt, nb_pt, taille_pt, calcul, inverser

   print(string.format("Insertion du script '%s'", nom_texte))

   if (type(pt_arg1) == "number") then
      debut_pt = pt_arg1
      nb_pt = pt_arg2
      taille_pt = pt_arg3
      calcul = pt_arg4
      inverser = pt_arg5
   elseif (type(pt_arg1) == "string") then
      debut_pt = pt_arg2
      nb_pt = pt_arg3
      taille_pt = modes_ext_ins[pt_arg1].taille
      inverser = modes_ext_ins[pt_arg1].inverser
      calcul = modes_ext_ins[pt_arg1].ins .. string.format("+$%X", pt_arg4) .. string.format("-$%X", pt_arg5)
   else
      error("arg #6 : number or string expected", 2)
      return
   end

   pointeurs:fixer_taille_pt(taille_pt)
   table:ouvrir(nom_table, INS)

   rom:open(nom_texte, "rb",'utf-8')
   rom:load_text(texte)
   rom:close()

   Ext_ins.inserer(texte, table, sortie, pointeurs)

   calcul = calcul .. string.format("+$%X", debut_txt)
   pointeurs:calculer(calcul)

   if (inverser) then
      pointeurs:inverser()
   end

   rom:open(nom_rom, "rb+")
   rom:seek(debut_txt, 0)

   if (pt_buffer_sortie:size() > fin_txt - debut_txt + 1) then
      taille = fin_txt - debut_txt + 1
      print(string.format("Espace insuffisant, il manque %d octets...", pt_buffer_sortie:size() - (fin_txt - debut_txt + 1)))
   else
      taille = pt_buffer_sortie:size()
      print(string.format("Espace restant : %d octets", (fin_txt - debut_txt + 1) - taille))
   end

   rom:write(pt_buffer_sortie, taille)

   if (pointeurs:nb_pt() == 0) then
      max = 0
   else
      max = pointeurs:nb_pt() - 1
   end

   for i = 0, max do
      if (pointeurs:index(i):numero() <= nb_pt) then
         rom:seek(debut_pt + (pointeurs:index(i):numero() - 1) * taille_pt, 0)
         pointeurs:index(i):ecrire(rom)
      else
         print(string.format("Le pointeur %d ne sera pas inséré (Nb pointeurs : %d)", pointeurs:index(i):numero(), nb_pt))
      end
   end

   rom:close()

   print("Insertion terminée !\n")

   return taille + debut_txt
end

-- Définitions de fonctions diverses --

function insert(f_in, debut, data)
   if (debut > f_in:seek("end")) then
      print("insert : la zone à dumper se situe en dehors du fichier")
      f_in:seek("set", pos_in)
      return
   end

   f_in:seek("set", debut)
   f_in:write(data)
end

function hexdump(f_in, debut, taille)
   local pos_in = f_in:seek()
   local data

   if (f_in:seek("end") < debut + taille) then
      print("hexdump : la zone à dumper se situe en dehors du fichier")
      f_in:seek("set", pos_in)
      return
   end

   f_in:seek("set", debut)
   data = f_in:read(taille)
   f_in:seek("set", pos_in)

   return data
end

function concatener(nom_out, table_noms)
   local i, data_temp, taille_table
   local f_in, out
   local erreur

   taille_table = table.getn(table_noms)
   out, erreur = io.open(nom_out, "wb")

   for i = 1, taille_table do
      if (type(table_noms[i]) ~= "string") then
         print("concatener : Le " .. i .. "ème élément de la table n'est pas une chaine")
      else
         f_in , erreur = io.open(table_noms[i], "rb")

         if (f_in == nil) then
            print("concatener : Erreur lors de l'ouverture d'un fichier d'entrée :")
            print(erreur)
         else
            data_temp = f_in:read("*a")
            out:write(data_temp)
            f_in:close()
         end
      end
   end

   out:close()
end

function creer_table(nom_in, nom_out, debut)
   local f_in, f_out
   local temp
   local n_courant = debut

   f_in = io.open(nom_in, "r")
   f_out = io.open(nom_out, "w")

   temp = 0

   while (temp ~= nil) do
      temp = f_in:read("*l")

      if (temp ~= nil and string.len(temp) ~= 0) then
         f_out:write(string.format("%X=%s\n", n_courant, temp))

         n_courant = n_courant + 1
      end
   end

   f_in:close()
   f_out:close()

end

function tronquer(valeur, taille)
   if (taille == 1) then
      return andB(valeur, 0xFF)
   elseif (taille == 2) then
      return andB(valeur, 0xFFFF)
   elseif (taille == 3) then
      return andB(valeur, 0xFFFFFF)
   end

   return valeur

end