Use another language to call a function
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
This task is inverse to the task Call foreign language function. Consider the following C program: <lang c>#include <stdio.h>
extern int Query (char * Data, size_t * Length);
int main (int argc, char * argv []) {
char Buffer [1024]; size_t Size = sizeof (Buffer); if (0 == Query (Buffer, &Size)) { printf ("failed to call Query\n"); } else { char * Ptr = Buffer; while (Size-- > 0) putchar (*Ptr++); putchar ('\n'); }
}</lang> Write an implementation of Query in your language and make main calling it. The function Query takes the buffer a places the string Here am I into it. The buffer size in bytes is specified by the parameter Length. When there is no room in the buffer, Query shall return 0. Otherwise it overwrites the beginning of Buffer, sets the number of overwritten bytes into Length and returns 1.
Ada
The interface package Exported specification: <lang Ada>with Interfaces.C; use Interfaces.C; with Interfaces.C.Strings; use Interfaces.C.Strings;
package Exported is
function Query (Data : chars_ptr; Size : access size_t) return int; pragma Export (C, Query, "Query");
end Exported;</lang> The package implementation: <lang Ada>package body Exported is
function Query (Data : chars_ptr; Size : access size_t) return int is Result : char_array := "Here am I"; begin if Size.all < Result'Length then return 0; else Update (Data, 0, Result); Size.all := Result'Length; return 1; end if; end Query;
end Exported;</lang> With GNAT it can be built as follows: <lang ada>gcc -c main.c gnatmake -c exported.adb gnatbind -n exported.ali gnatlink exported.ali main.o -o main</lang> Sample output:
Here am I
AutoHotkey
It is possible to register an autohotkey function as a callback and get a pointer to it using the builtin registercallback function. Care should be taken that the external language code is running in the same thread as autohotkey. This is not a problem when using dllcall to use the external language. To run an autohotkey function from an external program running in a different thread, you can use ahkFunction in AutoHotkey.dll From the documentation on registercallback: <lang AutoHotkey>; Example: The following is a working script that displays a summary of all top-level windows.
- For performance and memory conservation, call RegisterCallback() only once for a given callback
if not EnumAddress ; Fast-mode is okay because it will be called only from this thread:
EnumAddress := RegisterCallback("EnumWindowsProc", "Fast")
DetectHiddenWindows On ; Due to fast-mode, this setting will go into effect for the callback too.
- Pass control to EnumWindows(), which calls the callback repeatedly
DllCall("EnumWindows", UInt, EnumAddress, UInt, 0) MsgBox %Output% ; Display the information accumulated by the callback.
EnumWindowsProc(hwnd, lParam) {
global Output WinGetTitle, title, ahk_id %hwnd% WinGetClass, class, ahk_id %hwnd% if title Output .= "HWND: " . hwnd . "`tTitle: " . title . "`tClass: " . class . "`n" return true ; Tell EnumWindows() to continue until all windows have been enumerated.
}</lang>
C
I rewrote the driver as <lang c>#if 0 I rewrote the driver according to good sense, my style, and discussion.
This is file main.c on Autumn 2012 ubuntu linux release. The emacs compile command output:
-*- mode: compilation; default-directory: "/tmp/" -*- Compilation started at Mon Mar 12 20:25:27
make -k CFLAGS=-Wall main.o cc -Wall -c -o main.o main.c
Compilation finished at Mon Mar 12 20:25:27
- endif
- include <stdio.h>
- include <stdlib.h>
extern int Query(char*Data,unsigned*Length);
int main(int argc,char*argv[]) {
char Buffer[1024], *pc; unsigned Size = sizeof(Buffer); if (!Query(Buffer,&Size)) fputs("failed to call Query",stdout); else for (pc = Buffer; Size--; ++pc) putchar(*pc); putchar('\n'); return EXIT_SUCCESS;
} </lang> With solution <lang c>
- if 0
This is file query.c
-*- mode: compilation; default-directory: "/tmp/" -*- Compilation started at Mon Mar 12 20:36:25
make -k CFLAGS=-Wall query.o cc -Wall -c -o query.o query.c
Compilation finished at Mon Mar 12 20:36:26
- endif
- include<string.h>
int Query(char*Data,unsigned*Length) {
char*message = "Here am I"; unsigned n = strlen(message); if (n <= *Length) return strncpy(Data,message,(size_t)n), *Length = n, 1; return 0;
} </lang> And finally, excitement! <lang bash>$ gcc main.c query.o -o main && ./main Here am I $ </lang>
Delphi
<lang delphi> function Query(Buffer: PChar; var Size: Int64): LongBool; const
Text = 'Hello World!';
begin
If not Assigned(Buffer) Then begin Size := 0; Result := False; Exit; end; If Size < Length(Text) Then begin Size := 0; Result := False; Exit; end;
Size := Length(Text); Move(Text[1], Buffer^, Size); Result := True;
end; </lang>
To use this function from C you have to export this as a DLL and bind your C program to this function.
Go
Possible—if you allow a small stretch of the task specification.
Cgo, Go's interface to C, allows calls from C to Go, but only if it gets to start Go first. That is, it doesn't work with a program started with C startup code and C main(), but only with a program started with Go startup code and Go main().
Thus, I changed the specified C code to begin as follows, <lang c>#include <stdio.h>
- include "_cgo_export.h"
void Run() {
char Buffer [1024]; size_t Size = sizeof (Buffer);
if (0 == Query (Buffer, &Size)) ...</lang>
The biggest change is that I renamed main, since it is no longer a C main function. Another small change is that the extern declaration is replaced by an include. The included file is generated by cgo and contains an equivalent extern declaration.
In the Go code, below, you see that all main does is call C.Run. The C code is then in the driver's seat. <lang go>package main
// #include <stdlib.h> // extern void Run(); import "C" import "unsafe"
func main() {
C.Run()
}
const msg = "Here am I"
//export Query func Query(cbuf *C.char, csiz *C.size_t) C.int {
if int(*csiz) <= len(msg) { return 0 } pbuf := uintptr(unsafe.Pointer(cbuf)) for i := 0; i < len(msg); i++ { *((*byte)(unsafe.Pointer(pbuf))) = msg[i] pbuf++ } *((*byte)(unsafe.Pointer(pbuf))) = 0 *csiz = C.size_t(len(msg) + 1) return 1
}</lang> Output:
Here am I
Haskell
I modified the C source to include Haskell-specific headers and to init the Haskell environment. I also changed "Query" to "query_hs" due to capitalization issues: <lang c>
- ifdef __GLASGOW_HASKELL__
- include "Called_stub.h"
extern void __stginit_Called(void);
- endif
- include <stdio.h>
- include <HsFFI.h>
int main (int argc, char * argv []) {
char Buffer [1024]; size_t Size = sizeof (Buffer);
hs_init(&argc, &argv);
- ifdef __GLASGOW_HASKELL__
hs_add_root(__stginit_Called);
- endif
if (0 == query_hs (Buffer, &Size)) { printf ("failed to call Query\n"); } else { char * Ptr = Buffer; while (Size-- > 0) putchar (*Ptr++); putchar ('\n'); }
hs_exit(); return 0;
} </lang>
The Haskell code then is:
<lang haskell> {-# LANGUAGE ForeignFunctionInterface #-}
module Called where
import Foreign import Foreign.C.String (CString, withCStringLen) import Foreign.C.Types
-- place a string into the buffer pointed to by ptrBuff (with size -- pointed to by ptrSize). If successful, sets number of overwritten -- bytes in ptrSize and returns 1, otherwise, it does nothing and -- returns 0 query_hs :: CString -> Ptr CSize -> IO CInt query_hs ptrBuff ptrSize = withCStringLen "Here I am"
(\(str, len) -> do buffSize <- peek ptrSize if sizeOf str > (fromIntegral buffSize) then do poke ptrSize 0 return 0 else do poke ptrSize (fromIntegral len) copyArray ptrBuff str len return 1)
foreign export ccall query_hs :: CString -> Ptr CSize -> IO CInt </lang>
Compile the Haskell code with: <lang bash> ghc -c -O Called.hs </lang>
Then compile the C code together with the generated Haskell files (using GHC): <lang bash> ghc -optc-O calling.c Called.o Called_stub.o -o calling </lang>
Output:
Here I am
HaXe
PHP
<lang haxe>untyped __call__("functionName", args);</lang>
Lisaac
query.li <lang Lisaac>Section Header
+ name := QUERY; - external := `#define main _query_main`; - external := `#define query Query`;
Section External
- query(buffer : NATIVE_ARRAY[CHARACTER], size : NATIVE_ARRAY[INTEGER]) : INTEGER <- (
+ s : STRING_CONSTANT; + len, result : INTEGER; s := "Here am I"; len := s.count; (len > size.item(0)).if { result := 0; } else { 1.to len do { i : INTEGER; buffer.put (s @ i) to (i - 1); }; size.put len to 0; result := 1; }; result
);
Section Public
- main <- (
+ buffer : NATIVE_ARRAY[CHARACTER]; + size : NATIVE_ARRAY[INTEGER]; query(buffer, size); // need this to pull the query() method
);</lang> Makefile <lang lisaac>TARGET=test_query
all: $(TARGET)
$(TARGET): main.o query.o gcc -o $@ main.o query.o
.c.o: gcc -c $<
query.c: query.li -lisaac $<
clean: rm -f $(TARGET) *.o query.c</lang>
OCaml
<lang c>#include <stdio.h>
- include <string.h>
- include <caml/mlvalues.h>
- include <caml/callback.h>
extern int Query (char * Data, size_t * Length) {
static value * closure_f = NULL; if (closure_f == NULL) { closure_f = caml_named_value("Query function cb"); } value ret = caml_callback(*closure_f, Val_unit); *Length = Int_val(Field(ret, 1)); strncpy(Data, String_val(Field(ret, 0)), *Length); return 1;
}
int main (int argc, char * argv []) {
char Buffer [1024]; unsigned Size = 0;
caml_main(argv); /* added from the original main */
if (0 == Query (Buffer, &Size)) { printf ("failed to call Query\n"); } else { char * Ptr = Buffer; printf("size: %d\n", Size); while (Size-- > 0) putchar (*Ptr++); putchar ('\n'); }
}</lang>
<lang ocaml>let caml_query () =
let s = "Here am I" in (s, String.length s)
let () =
Callback.register "Query function cb" caml_query;
- </lang>
compile with:
ocamlopt -output-obj caml_part.ml -o caml_part_obj.o gcc -c main.c -I"`ocamlc -where`" gcc -o prog.opt main.o caml_part_obj.o \ -L"`ocamlc -where`" \ -lm -ldl -lasmrun
Pascal
See Delphi
PicoLisp
Calling a PicoLisp function from another program requires a running interpreter. There are several possibilities, like IPC via fifo's or sockets using the PLIO (PicoLisp-I/O) protocol, but the easiest is calling the interpreter in a pipe. This is relatively efficient, as the interpreter's startup time is quite short.
If there is a file "query.l" <lang PicoLisp>(let (Str "Here am I" Len (format (opt))) # Get length from command line
(unless (>= (size Str) Len) # Check buffer size (prinl Str) ) ) # Return string if OK</lang>
then the C function 'Query' could be <lang C>int Query(char *Data, size_t *Length) {
FILE *fp; char buf[64];
sprintf(buf, "/usr/bin/picolisp query.l %d -bye", *Length); if (!(fp = popen(buf, "r"))) return 0; fgets(Data, *Length, fp); *Length = strlen(Data); return pclose(fp) >= 0 && *Length != 0;
}</lang>
Python
Our embedded python function a) uses information from the main routine in c, and b) determines the information to populate the result returned to the main routine. This, I believe, fulfills the task requirement. The modifications and compilation are shown for Ubuntu linux Autumn 2011 version, with python3. It's easier to call a dynamic library from python using the ctypes module. Consider using PyRun_SimpleString to have main.c call python calling back to c. <lang python>
- store this in file rc_embed.py
def query(buffer_length):
message = b'Here am I' L = len(message) n = min(L,buffer_length) #print(message[:n]) return bytes(message[:n])
</lang>
main.c <lang c>
- if 0
//I rewrote the driver according to good sense, my style, //and discussion --Kernigh 15:45, 12 February 2011 (UTC).
- endif
- include<stdio.h>
- include<stdlib.h>
- include<string.h>
int main(int argc,char*argv[]) {
char Buffer[1024], *pc; unsigned Size = sizeof(Buffer); if (!Query(Buffer,&Size)) fputs("Failed to call Query",stdout); else for (pc = Buffer; Size--; ++pc) putchar(*pc); putchar('\n'); return EXIT_SUCCESS;
} </lang>
In Query.c I don't promise to have tested every case with missing module, missing function, or to have used Py_DECREF correctly. <lang c>
- include<stdio.h>
- include<stdlib.h>
- include<string.h>
- include<Python.h>
int Query(char*Data,unsigned*Length) {
char *module = "rc_embed", *function = "query"; PyObject *pName, *pModule, *pFunc, *pResult, *pArgs, *pLength; long result = 0; if (!Py_IsInitialized()) Py_Initialize(); pName = PyUnicode_FromString(module); pModule = PyImport_Import(pName); Py_DECREF(pName); if (NULL == pModule) { PyErr_Print(); fprintf(stderr,"Failed to load \"%s\"\n",module); return 0; } pFunc = PyObject_GetAttrString(pModule,function); if ((NULL == pFunc) || (!PyCallable_Check(pFunc))) { if (PyErr_Occurred()) PyErr_Print(); fprintf(stderr,"Cannot find function \"%s\"\n",function); if (NULL != pFunc) Py_DECREF(pFunc); Py_DECREF(pModule); return 0; } pArgs = PyTuple_New(1); pLength = PyLong_FromUnsignedLong((unsigned long)(*Length)); if (NULL == pLength) { Py_DECREF(pArgs); Py_DECREF(pFunc); Py_DECREF(pModule); return 0; } PyTuple_SetItem(pArgs,0,pLength); pResult = PyObject_CallObject(pFunc, pArgs); if (NULL == pResult) result = 0; else if (!PyBytes_Check(pResult)) { result = 0; Py_DECREF(pResult); } else { *Length = (unsigned)PyBytes_Size(pResult); strncpy(Data,PyBytes_AsString(pResult),*Length); Py_DECREF(pResult); result = 1; } Py_DECREF(pArgs); Py_DECREF(pFunc); Py_DECREF(pModule); Py_Finalize(); return result;
} </lang>
Compilation, linkage, execution. Note the python tools used to extract the correct flags. <lang bash> $ make main.o cc -c -o main.o main.c $ D=$( dirname $( which python3 ) ) $ gcc $( $D/python3.2-config --cflags ) -c Query.c In file included from /usr/include/python3.2mu/Python.h:8:0,
from Q.c:18:
/usr/include/python3.2mu/pyconfig.h:1173:0: warning: "_POSIX_C_SOURCE" redefined [enabled by default] /usr/include/features.h:214:0: note: this is the location of the previous definition $ gcc -o main main.o Query.o $( $D/python3.2-config --ldflags ) $ ./main Here am I $ </lang>
Tcl
The way you would tackle this problem depends on whether you are working with ‘In’ or ‘Out’ parameters. (It is normal model ‘inout’ parameters as Tcl variables; omitted for brevity.)
‘In’ Parameters
To connect a function to Tcl that passes an arbitrary C string as input, you'd use a short C thunk, like this: <lang c>int Query (char * Data, size_t * Length) {
Tcl_Obj *arguments[2]; int code;
arguments[0] = Tcl_NewStringObj("Query", -1); /* -1 for "use up to zero byte" */ arguments[1] = Tcl_NewStringObj(Data, Length); Tcl_IncrRefCount(arguments[0]); Tcl_IncrRefCount(arguments[1]); if (Tcl_EvalObjv(interp, 2, arguments, 0) != TCL_OK) { /* Was an error or other exception; report here... */ Tcl_DecrRefCount(arguments[0]); Tcl_DecrRefCount(arguments[1]); return 0; } Tcl_DecrRefCount(arguments[0]); Tcl_DecrRefCount(arguments[1]); if (Tcl_GetObjResult(NULL, Tcl_GetObjResult(interp), &code) != TCL_OK) { /* Not an integer result */ return 0; } return code;
}</lang>
Which would lead to a Query
implementation like this:
<lang tcl>proc Query data {
puts "Query was $data" return 1;
}</lang>
‘Out’ Parameters
However, in the specific case of writing to a user-specified buffer (an “out” parameter) the thunk code would instead manage copying the result from the interpreter back to the buffer: <lang tcl>int Query (char * Data, size_t * Length) {
const char *str; int len;
if (Tcl_Eval(interp, "Query") != TCL_OK) { return 0; } str = Tcl_GetStringFromObj(Tcl_GetObjResult(interp), &len); if (len+1 > Length) { return 0; } memcpy(Data, str, len+1); return 1;
}</lang>
And the implementation of Query
would be just:
<lang tcl>proc Query {} {
return "Here am I"
}</lang> (Since this is working with a literal, this would actually be efficient and just result in references being passed.)
Connecting up the pieces
You would also need a short piece of code in main()
to initialize the Tcl library and create an interpreter instance, and you would need to build and link against libtcl.
<lang c>#include <tcl.h>
Tcl_Interp *interp;
int main(int argc, char **argv) {
Tcl_FindExecutable(argv[0]); /* Initializes library */ interp = Tcl_CreateInterp(); /* Make an interpreter */
/* Rest of contents of main() from task header... */
}</lang>