Come verificare se uno script è incluso tramite dofile() o eseguito direttamente in Lua?

Question

Eventuali duplicati:
“main” function in Lua?

In Python, è possibile controllare se uno script viene chiamata direcly (e chiamare alcune funzioni se lo è, di solito per la prova) piuttosto facilmente:

if __name__ == "__main__": 
    main() 

C'è un modo per fare lo stesso in Lua, per rilevare se viene eseguito direttamente (lua foo.lua) o incluso in un altro s cript (dofile('foo.lua')).

C'è sempre il modo banale (e brutto) di definire alcune variabili globali fittizie nel file di script principale prima dofile('foo.lua') e il check in foo.lua se è definito o meno, ma sarebbe bello se ci fosse un modo migliore per fare questo.

Answer 1

Al livello superiore è possibile verificare se debug.getinfo(2) è nulla

Da http://www.lua.org/manual/5.1/manual.html#pdf-debug.getinfo

si può dare un numero come valore di funzione, che significa che la funzione esecuzione a livello funzionale dello stack di chiamate del thread specificato: il livello 0 è la funzione corrente (getinfo stesso); il livello 1 è la funzione chiamata getinfo; e così via. Se la funzione è un numero maggiore del numero di funzioni attive, quindi getinfo restituisce nil.

Answer 2

No. Lua non ha modo di sapere se uno script viene invocato "direttamente".

Ricorda: Lua e Python esistono per scopi diversi. Python è progettato per lo scripting da riga di comando. Scrivi uno script, che chiama i moduli che possono essere scritti in Python, C++ o altro. Lo script Python è in definitiva ciò che è responsabile di quale codice viene chiamato quando.

Lua è un linguaggio di script incorporato, in primo luogo. Mentre è possibile utilizzare l'interprete standalone lua.exe per creare script da riga di comando, si tratta di qualcosa di un kludge. Lo scopo principale della lingua è quello di essere incorporato in alcune applicazioni scritte in C, C++ o altro.

Per questo motivo, lo non è il concetto di uno script "principale". Come definiresti cosa è "principale" e cosa no? Se il codice C può caricare qualsiasi script in qualsiasi momento, per qualsiasi scopo, quale di essi è "principale"?

Se si desidera definire questo concetto, è abbastanza semplice. Basta attaccare questo nella parte superiore dello script di "principale":

do 
    local old_dofile = dofile 
    function new_dofile(...) 
    if(__is_main) then 
     __is_main = __is_main + 1 
    else 
     __is_main = 1 
    end 
    old_dofile(...) 
    __is_main = __is_main - 1 
    if(__is_main == 0) then __is_main = nil end 
    end 
    dofile = new_dofile 
end 

Certo, questo non funziona per niente caricato con require; avresti bisogno di scrivere una versione di questo per require pure. E certamente non funzionerà se il codice esterno utilizza le funzioni di caricamento di C-API (che è il motivo per cui require probabilmente non funzionerà).