Does 4.5 & 64 allow you to call a function from it's address or from a variable?

[QB64Curious]

Hi,

One more question, for at least a few days.

Does 64 or 4.5 have some kind of AddressOf( FunctionName$ ), or Eval( FunctionName$ ) that allows us to call a subroutine or function from a variable containing that function name?

So if we have two functions

Code: QB64: [Select]

1. Function FirstFunction
2. '...
3. '...
4. End Function
5.  
6. Function SecondFunction
7. '...
8. '...
9. End Function
10.  

, and we put

Code: QB64: [Select]

1. FunctionName$ = "FirstFunction"

, is there a way of using the variable FunctionName$, to call the function that it references?

[luke]

No.

Edit: no, unless someone writes some extremely hacky C++.

[QB64Curious]

Huh.  That's a disappointment.

Ok, thanks Luke.

No.

Edit: no, unless someone writes some extremely hacky C++.

[_vince]

May I request _MEMSUB and _MEMFUNC from Steve and the rest of the qb64 dev team?  A _MEM* variant for function pointers within QB64.  This will allows us to powerfully interface with all kinds of APIs, callback functions, etc.

[RhoSigma]

Here's the hacky method mentioned by luke:
https://qb64forum.alephc.xyz/index.php?topic=4602.msg140102#msg140102

[RhoSigma]

May I request _MEMSUB and _MEMFUNC from Steve and the rest of the qb64 dev team?  A _MEM* variant for function pointers within QB64.  This will allows us to powerfully interface with all kinds of APIs, callback functions, etc.

Would be possible, the C++ part of my example, obtaining the address of a function could be generated automatically during compiling, just as QB64 generates all the other C++ stuff. However it needs to be investigated how to deal best with different return data types (maybe function overloading) and how to savely pass arguments to the (callback) functions.

[luke]

Here's the hacky method mentioned by luke:
https://qb64forum.alephc.xyz/index.php?topic=4602.msg140102#msg140102

Not quite, that requires the function name to be known as compile time. OP wants to call a function based on a string name known at runtime, which I would imagine looking up symbols in the executable in a fashion similar to loading a dynamically linked library.

[RhoSigma]

Not quite, that requires the function name to be known as compile time. OP wants to call a function based on a string name known at runtime, which I would imagine looking up symbols in the executable in a fashion similar to loading a dynamically linked library.

Yes one method shall be a name in a variable, but in alternative an address would be ok too, see topic title and OP: AddressOF(Functionname).
However, to look up a functions address by a name given at runtime needs to be some kind of lookup table set up during compiling and some init code (C++ side) at the start of each program which takes the addresses of all user defined SUBs/FUNCs and fill the table respectively to its names.

[RhoSigma]

Regarding some init code, don't know if this method is known to gcc or clang. In my past, when still coding a lot on my old Commodore Amiga, I used MaxonC++ and StormC++. In both a programmer could define init/exit functions in the form _INIT_X_MyFunction and _EXIT_X_MyFunction, where the X ia a number 1 to 9 designating the priority level for linking.

The linker did automatically link those functions into the init/cleanup sections of the final program, hence directly prior branching into main() or when returning/exiting from main(). The linking order is determined by the given level. At init the order is 1 to 9er _INIT functions, at exit respectively the opposite 9er to 1 _EXIT functions.

[SMcNeill]

Isn't this more or less something like what you're wanting? 

Code: QB64: [Select]

1. Do
2.     Input "Enter the function name to call =>"; func$
3.     Print Eval(func$)
4. Loop Until func$ = ""
5. System
6.  
7.  
8. Function Eval (what$)
9.     Select Case LCase$(what$)
10.         Case "foo": Eval = Foo
11.         Case "foo2": Eval = Foo2
12.         Case "foo3": Eval = Foo3
13.         Case "foo4": Eval = Foo4
14.         Case Else: Print "Invalid function name.  You can only call FOO, FOO2, FOO3, or FOO4."
15.     End Select
16. End Function
17.  
18. Function Foo
19.     Foo = 1
20. End Function
21.  
22. Function Foo2
23.     Foo2 = 2
24. End Function
25.  
26. Function Foo3
27.     Foo3 = 3
28. End Function
29.  
30. Function Foo4
31.     Foo4 = 4
32. End Function
33.  

A variable is storing the name of the function, and then we're calling the proper function when that variable is set.  Or am I missing something here and the original poster is asking for more than what I'm interpreting from this question?

is there a way of using the variable FunctionName$, to call the function that it references?

[QB64Curious]

Hi Steve,

Yes, something like.  But it doesn't have room for function names not on the list.

FreeBasic appears to have Procedure Pointers, in both the Dos and Windows and Linux versions.  Maybe QB64 can extend to something like this, but we're still stuck with QB 4.5 being what it is.

Thanks everyone for the clarifications, and the C examples.

Isn't this more or less something like what you're wanting? 

Code: QB64: [Select]

1. Do
2.     Input "Enter the function name to call =>"; func$
3.     Print Eval(func$)
4. Loop Until func$ = ""
5. System
6.  
7.  
8. Function Eval (what$)
9.     Select Case LCase$(what$)
10.         Case "foo": Eval = Foo
11.         Case "foo2": Eval = Foo2
12.         Case "foo3": Eval = Foo3
13.         Case "foo4": Eval = Foo4
14.         Case Else: Print "Invalid function name.  You can only call FOO, FOO2, FOO3, or FOO4."
15.     End Select
16. End Function
17.  
18. Function Foo
19.     Foo = 1
20. End Function
21.  
22. Function Foo2
23.     Foo2 = 2
24. End Function
25.  
26. Function Foo3
27.     Foo3 = 3
28. End Function
29.  
30. Function Foo4
31.     Foo4 = 4
32. End Function
33.  

A variable is storing the name of the function, and then we're calling the proper function when that variable is set.  Or am I missing something here and the original poster is asking for more than what I'm interpreting from this question?