I've created a table and assigned a method with lua_pushcfunction named mytable:myfunction(). In a different (callback) context it's necessarily that myfunction will be overriden inside the Lua script. For some reasons, if i call myfunction from the C host, I need to know, if myfunction is still the c function or was replaced by the script.
Is there a way to test (from C), if the C method is still attached or is replaced by some Lua code ?
Yes, you can use lua_iscfunction.
Another possibility is to use lua_tocfunction. This allows you to also check if the C function you got back is the one you expect.
Related
What are some use cases of do nothing function (in C) like:
dummy() {}
I am reading "The C programming Language" by K&R and in chapter 4 (Functions & Program Structures) , it mentions that
A do-nothing function like this (shown above) sometimes useful as a place holder during program development.
Can anyone explain what author means by that and uses of these types of functions?
A function that does nothing (yet) is an indicator that something should be done, but hasn't been implemented yet.
Have a look at programming idioms like "Skeleton", "dummy code", "mock objects", etc. It is a very common technic that let you test the whole architecture of your program without having implement every details.
Suppose you have an application that is able to save results in a file by calling a function save(), you would like to be able to test the application without the necessity to really save results into a file. So the function save() can be, in a first approximation an empty one! It is very common to write like (pseudo-code here):
save() {
print "save() not yet implemented";
}
to be able to track the calls.
You already have received the answer(s), but just to elaborate on why part, let me add my two cents.
If you try to use a function (call a function) which does not have a definition, linker will throw undefined reference error, because it will not able able to find the actual function definition anywhere in the given object file(s) to link to.
So, sometimes in the development phase, when you need to call an API which is yet to be implemented (or not available till time), a dummy function definition is added, which
either does nothing meaningful
or returns a fixed value
just to compile and check (test) the working of the caller function (module). Without the dummy function definition, the code for the caller function will throw the error.
When you're writing code to explain something, it is better to omit secondary functions, so the reader focuses on the problem and not on the details.
Instead when you write a real program I prefer to create the secondary functions first, test them and alter set all focus on the mainstream.
Let's say I have a function:
int foo (int A, char B){...}
One of the features I want to implement is the capability for the user to call any function on the application through the Linux terminal. So as an input for the software, in the terminal they type something like:
foo 2 'a'
Then my application parses that, and using the symbol tables it is able to find the address for foo(), as well as the type for all its parameters.
However, I'm not sure how I would pass the parameters to the function when calling it, since I can have hundreds of different parameters types combination depending on the function called.
Any hint how that could be achieved without having hundreds of nested if statements to cast the parameters to the correct types before calling the functions?
That functionality is similar to what GDB has, where you can do call foo(2,'a') and GDB calls that function to you.
There are two approaches to this. If what you described is all you want to do, then you can use the dyncall library so that you dont have to worry about platform/compiler-specific calling semantics yourself:
The dyncall library encapsulates architecture-, OS- and compiler-specific function call semantics in a virtual bind argument parameters from left to right and then call interface allowing programmers to call C functions in a completely dynamic manner. In other words, instead of calling a function directly, the dyncall library provides a mechanism to push the function parameters manually and to issue the call afterwards.
The other approach is, if you might want to do more: e.g. what if an argument cannot be created by a literal? What if the argument is the output of another function? Can you write f(123, g("a")) in your console? Can you write x=g("a"); f(x)? And if(cond) x="a" else x="b"; f(x) In this case you need to embed a scripting language like e.g. LUA.
If you compile your binary with debug information, you can extract it using libdwarf (https://www.prevanders.net/dwarf.html), so for every function you can get a list a parameters with types and you would know how to interpret user's input.
I am new to RTOS and I was going through some demo code in freeRTOS, I came across xtaskcreate function.I know that when a function is called it should have its function body some where in the code.When I referred the the task.c file and did not found any xtaskcreate function body. So can some one explain me where the xtaskcreat function body is present else if not then how it is executed.
It's defined in file Source/tasks.c near line 595 (FreeRTOS v9.0.0rc2).
But if SUPPORT_DYNAMIC_ALLOCACTION is not defined, xTaskCreate won't be defined too.
It depends which FreeRTOS version you are using.
The latest V9.0.0rc2 has both xTaskCreate() and xTaskCreateStatic() as separate functions in tasks.c. Some versions will have both calls defined as macros that each calls xTaskGenericCreate() with parameters set appropriately for the required behavior (hiding the complexity from the end user).
In both cases its easy to find out. The 'Task' on the front of the function name tells you the prototype is in tasks.h - so just search that file for xTaskCreate() and see if it is a direct function call or a macro that calls another function - which you can then find in tasks.c.
I'm currently building a lua event system (in lua), however I want to be able to fire events from C too, I was wanting to bind a C function to a lua function, such that the C function could fire events in lua, I was planning to use the:
lua_register
function; however I can't seem to find a way to bind my lua function like this, it would seem I'm in need of a lua function that does the same, but from the lua side, I was thinking about making some hack, by binding a C function into lua, that simply calls 'lua_register', but this seems a bit unsafe to me.
So what should I do instead?
I'm not fully sure I understand what you've asked for. So allow me to explain what I think your question is.
You have some Lua code. In that Lua code, you have a system. This system is, at some point, given one or more events. For each event that it is given, it calls some function or functions that were registered to be called when that particular event was given.
So, this system has two basic functions:
EventSystem:RegisterEventHandler(EventName, Func);
EventSystem:FireEvent(EventName, ...);
The RegisterEventHandler method will associate the given Func with the given EventName, such that when FireEvent is called later, Func will be called if the EventName given to FireEvent is the same one Func was registered with.
Now you want to have C code be able to register C functions as event handlers. So it's time to talk about registering C functions in Lua.
The C API call lua_register is actually a macro. It creates a C function on the Lua stack, then puts it in the global table, using the string index given to lua_register. These are two separate operations; lua_register is just a convenience function that makes them the same.
What you want is to call RegisterEventHandler from C code, passing the C function as the third parameter (remember: the first parameter is self, because I called RegisterEventHandler with : instead of .. If you're using a global event system rather than an object oriented one, you only have two parameters). This requires two things:
You have to know how to call Lua functions from C code.
You have to know how to pass a C function to Lua code.
Step 1: It's all done via the Lua stack (I'll assume you know how that works. If not, I have a pretty substantial answer that explains most everything you might want to know about it).
The first thing you need to do is get the function you want to call onto the stack. To do that, you need to get an event system object (again, if your event system is global, just get the global table) and push it onto the stack. How you do that depends on where your event system objects are stored. Presumably you can get them through the global table.
Once you have the event system on the stack, you just index it with the "RegisterEventHandler" string, which will return to you the Lua function we need.
Next, we push our parameters onto the stack, from first to last. The first parameter is the event system object; it's probably still on the stack, so we can copy it. The second is the event name, and that's easy to push. The third is the C function. Which leads us to:
Step 2: lua_register is not going to get the job done. It's too heavy handed; it puts the C function in the global table. We need it on the stack. So we must use a lower level function: lua_pushcclosure. Or lua_pushcfunction, if you don't need upvalues.
These functions take a C function, wrap it up in Lua, and push it onto the Lua stack.
Now that the 3 parameters are on the stack, we can call the event registration function with a call to lua_pcall. Or your favorite Lua function calling function; however you wish to do it. Lua will consume the 3 parameters and the function itself, so that they are no longer on the stack.
And since the event registration function probably doesn't return values, the stack will be where it was right before we got the function onto the stack (but not before we started, depending on how much cleanup was done while getting the function).
After this, your C function will be registered with the event handler for that event name.
If I have some lua code like this:
doSomething(function()
print("Hello!")
end)
How can I make it that, using the C API, I create C Lua function for doSomething that can then save the function passed to it to be executed a later date?
It's just a normal entry on the stack. Check it with lua_isfunction() then use luaL_ref() to generate a reference (so that the garbage collector doesn't steal it), and then maybe lua_topointer() to store a pointer to this object, depends what you want to do with it.
When you're finished it's just a luaL_unref().