Comment vider fonction lua morceau de ficelle?

Il n'y a pas de réponse simple (après toutes ces années, toujours). Je vais élaborer sur les alternatives.

1 Prof. de l'archéologie de la réponse (et un peu de démontage):

La réponse à cette question très ancienne, se trouve à l'intérieur primodial un. À savoir, luadec. Il est probable qu'à l'époque c'était dans les temps d'arrêt, mais au moins maintenant, il y a un version mise à jour, qui gère lua 5.1-.3.

En outre, la string.dump fournit pas un charabia complet, il donne un code de programme en raw octets d'instructions machine, vous pouvez voir une meilleure représentation des personnes avec luac -l -p <filename>.
Vm codes ne sont pas bien documentés, mais les gens ne mettre quelque chose ensemble ici. Luajit a un peu plus de documentation sur son propre jeu d'instructions.

La reconstruction de code à partir de vm instructions est ce que luadec n'. En théorie, on pourrait aussi épissure vos propres instructions à droite dans la chaîne de sous-évaluées.

Cependant, quelle que soit la tour vous faire pour bytecode, il fera l'expérience d'incompatibilités entre les différents interprètes, y compris les différentes versions de lua lui-même.

2. En train de faire X

Fonction de conversion d'une chaîne de caractères est un peu particulière désir (sauf si vous faites de la génération de code, auquel cas vous avez déjà la chaîne en premier lieu).

Le "journal et injecter du code" est en effet tout à fait général X, ce qui peut justifier l'Y résoudre. Mais d'autres cas peuvent être couverts par un seul des mesures.
Lua est très flexible de la langue, et par exemple, vous pouvez tracer le flux de la valeur x dans l'exemple en en faisant un objet:

local to2number = tonumber
tonumber= function(o)
    local r= to2number(o) 
    if not r then
        local m= getmetatable(o)
        if m and m.__tonumber then
            r=m.__tonumber(o)
        end
    end
    return r
end
local number
number={
    new=function(n)
        return setmetatable({n},number)
    end,
    __add=function(me,other)
        print("I'm "..tostring(me).." and I'm being added to "..tostring(other))
        local o=tonumber(other) 
        return number.new(me[1]+o)
    end,
    __tonumber=function(me) return me[1] end,
    __tostring=function(me) return tostring(me[1]) end,
}
test(number.new(4), number.new(10))

Comme dans l'exemple ci-dessus, vous pouvez injecter le comportement en modifiant l'environnement de la fonction. À savoir, là, j'ai redéfini la fonction globale tonumber. Vous pourriez complètement pack de la fonction dans l'environnement différent:

local test = function() print"hello" end
local newenv={print=function(s) print(s..'world')  end}
setfenv(test,newenv)--this is lua 5.1, luajit, good luck with upvalues
local test = load(string.dump(test),nil,nil,newenv)--this is lua 5.2-5.3, good luck with upvalues
test()

Pour les versions plus anciennes que vous avez à gérer des valeurs amont qui peuvent avoir des références à des fonctions globales vous essayez de redéfinir. Pour les versions plus récentes, vous aurez à gérer les valeurs amont qui serait perdue pendant le vidage du processus de chargement.

3. La lecture de fichiers

Enfin, comme d'autres ont dit, si vous avez accès au code source, vous pouvez essayer de trouver la définition de la fonction de cela. Sauf si c'est une seule définition de la fonction ou retour simple fichier de la tâche pourrait être équivalent à la re-mise en œuvre de la lua analyseur. Il n'y a plus qu'un seul de ceux-ci, mais ils n'ont pas été fait avec une telle fonctionnalité à l'esprit de sorte qu'il pourrait prendre un certain travail de recycler leur code.

Si toutes les fonctions sont définies par vous-même et vous êtes prêt à retenir-vous un peu, vous pouvez utiliser lua metatables de nouveau, de résoudre le problème au cours de l'étape de codage:

local def=function(code,env)
    env=env or _ENV
    local compiled,q=load("return "..code,nil,nil,env)
    if not compiled then error(q) end
    local f=compiled()
    return setmetatable({code=code},{__call=function(me,...) return  f(...)  end})
end

local test=def[[function(a,b)
    return a+b
end]]

print(test(2,3))

La définition des valeurs amont va être difficile, cependant.

Vous n'avez pas. Lua ne stocke pas compilé de script Lua en tant que texte brut n'importe où. Et, puisqu'il est destiné à être un petit langage de script, il ne fournit pas un mécanisme de décompiler son propre bytecode.

Vous pouvez obtenir le code source de votre programme en

local source_code = io.open(arg[0]):read'*a'

et de l'analyser pour trouver votre définition de la fonction.

Il ne fonctionne que lors de l'exécution de lua en ligne de commande et en le passant à la source de fichier en paramètre, pas un fichier bytecode.