How to check if a script is included via dofile() or run directly in Lua?

Question

Possible Duplicate:
“main” function in Lua?

In Python, you can check if a script is being called direcly (and call some functions if it is, usually for testing) pretty easily:

if __name__ == "__main__":
    main()

Is there a way to do the same in Lua, to detect if it is run directly (lua foo.lua) or included in another script (dofile('foo.lua')).

There is always the trivial (and ugly) way of defining some dummy global variable in the main script file before dofile('foo.lua'), and checking in foo.lua if it is defined or not, but it would be great if there was a better way to do this.

You're right, sorry for the duplicate... – Wookai Jan 31 '12 at 09:18 — Wookai, Jan 31 '12 at 09:18

score 10 · Accepted Answer · answered Jan 31 '12 at 04:54

10

At the top level you can check if debug.getinfo(2) is nil

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

you can give a number as the value of function, which means the function running at level function of the call stack of the given thread: level 0 is the current function (getinfo itself); level 1 is the function that called getinfo; and so on. If function is a number larger than the number of active functions, then getinfo returns nil.

answered Jan 31 '12 at 04:54

daurnimator

4,091
18
34

This would also return `true` for any function run directly from the embedded code. – Nicol Bolas Jan 31 '12 at 05:01
that's what I assumed the OP was effectivly checking: if this script was called directly (or if loaded via require/dofile/loadfile/loadstring/etc) – daurnimator Jan 31 '12 at 08:42
1

I'm using 5.2.3, and it seems I need to check `debug.getinfo(3)` instead of `2`. – dimo414 Sep 27 '17 at 06:10
I've reached the same conclusion @dimo414 - perhaps it's because we both used it inside an `if` which adds another function to the stack. – Doron Behar Jan 14 '19 at 11:21

score 3 · Answer 2 · edited Jan 30 '12 at 21:25

No. Lua has no way to tell if a script is being invoked "directly".

Remember: Lua and Python exist for different purposes. Python is designed for command-line scripting. You write a script, which calls modules that may be written in Python, C++, or whatever. The Python script is ultimately what is in charge of which code gets called when.

Lua is an embedded scripting language, first and foremost. While you can certainly use the standalone lua.exe interpreter to create command-line scripts, that is something of a kludge. The language's primary purpose is to be embedded in some application written in C, C++, or whatever.

Because of this, there is no concept of a "main" script. How would you define what is "main" and what is not? If C code can load any script at any time, for any purpose, which one of them is "main"?

If you want to define this concept, it's fairly simple. Just stick this at the top of your "main" script:

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

Granted, this won't work for anything loaded with require; you'd need to write a version of this for require as well. And it certainly won't work if external code uses the C-API loading functions (which is why require probably won't work).

I did not downvote you, but I guess calling a kludge any usage of Lua but embedding may be the reason. I agree that it really shines when embedded, it is also very useful as a scripting language on its own. — Wookai, Jan 31 '12 at 08:21

How to check if a script is included via dofile() or run directly in Lua?

2 Answers2

Linked