Use another language to call a function: Difference between revisions

{{clarified-review}}

This task is inverse to the task [[Call foreign language function]]. Consider the following [[C]] program:

 

extern int Query (char * Data, size_t * Length);

putchar ('\n');

}

 

Implement the missing <code>Query</code> function in your language, and let this C program call it. The function should place the string ''<tt style="margin:0 0.5em">Here am I</tt>'' into the buffer which is passed to it as the parameter <code>Data</code>. The buffer size in bytes is passed as the parameter <code>Length</code>. When there is no room in the buffer, <code>Query</code> shall return 0. Otherwise it overwrites the beginning of <code>Buffer</code>, sets the number of overwritten bytes into <code>Length</code> and returns 1.

=={{header|Ada}}==

The interface package Exported specification:

with Interfaces.C.Strings; use Interfaces.C.Strings;

 

return int;

pragma Export (C, Query, "Query");

The package implementation:

function Query (Data : chars_ptr; Size : access size_t)

return int is

end if;

end Query;

With [[GNAT]] it can be built as follows:

gnatmake -c exported.adb

gnatbind -n exported.ali

Sample output:

<pre>

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 [http://www.autohotkey.net/~HotKeyIt/AutoHotkey/ahkFunction.htm ahkFunction] in [http://www.autohotkey.net/~tinku99/ahkdll/ AutoHotkey.dll]

From the documentation on registercallback:

 

; For performance and memory conservation, call RegisterCallback() only once for a given callback:

Output .= "HWND: " . hwnd . "`tTitle: " . title . "`tClass: " . class . "`n"

return true ; Tell EnumWindows() to continue until all windows have been enumerated.

 

=={{header|C}}==

I rewrote the driver as

I rewrote the driver according to good sense, my style,

and discussion.

return EXIT_SUCCESS;

}

With solution

#if 0

This is file query.c

return 0;

}

And finally, excitement!

Here am I

$

 

=={{header|C++}}==

using std::string;

 

Message.copy(Data, *Length);

return true;

 

We must compile main() with a C compiler and Query() with a C++ compiler. One can use gcc and g++ (or clang and clang++).

 

$ g++ -c query.cpp

$ g++ -o main main.o query.o

$ ./main

 

=={{header|COBOL}}==

Instead of C being the master builder, cobc is used to combine the .c source and .cob source into the executable simplifying the tectonic for this example (cobc can generate and use .o object code, but that is all hidden here). GnuCOBOL also requires a COBOL runtime system, implicitly initialized with the -fimplicit-init compiler switch here. This emits code to ensure libcob is properly setup for calling from foreign languages (that would otherwise have to call cob_init() before invoking COBOL modules). The source code in the task description was saved to disk as <code>call-query.c</code>, and the listing below was saved as <code>query.cob</code> (with the internal subprogram named <code>Query</code>). A special <code>call-convention</code> is also used so the GnuCOBOL module does not make any assumptions about how the Query module is invoked (normal COBOL programs set some control fields in the libcob runtime space when calling modules, which won't be set when called from a foreign C ABI program). GnuCOBOL also sets <code>RETURN-CODE</code> to zero unless told otherwise (or some error occurs).

 

program-id. Query.

 

 

goback.

 

{{out}}

First write a D module like this, named "query_func.d":

 

 

extern(C) bool query(char *data, size_t *length) pure nothrow {

return true;

}

 

Generate a library file with:

Then create a C file named "mainc.c", given in the task description and here improved a little:

 

#include <stdbool.h>

 

 

return 0;

 

Then you can compile and link all with the [http://www.digitalmars.com/download/freecompiler.html DMC C compiler](on Linux you can use GCC):

 

=={{header|Delphi}}==

function Query(Buffer: PChar; var Size: Int64): LongBool;

const

Result := True;

end;

 

To use this function from C you have to export this as a DLL and bind your C program to this function.

 

Simple task because interoperability with C is in Fortran language since F2003 standard.

!-----------------------------------------------------------------------

!Function

answer = 1

end function fortran_query

compile it: gfortran main.c query.f90 -o main.x

 

 

Thus, I changed the specified C code to begin as follows,

#include "_cgo_export.h"

 

 

if (0 == Query (Buffer, &Size))

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.

 

// #include <stdlib.h>

*csiz = C.size_t(len(msg) + 1)

return 1

Output:

<pre>

 

The Go code for this task is as follows:

// This buildmode requires the package to be main

package main

return 1

}

 

Assuming this is saved to query.go (and that the C code is saved as main.c) it can be compiled with:

=={{header|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:

#include "Called_stub.h"

extern void __stginit_Called(void);

hs_exit();

return 0;

 

The Haskell code then is:

 

 

module Called where

return 1)

 

 

Compile the Haskell code with:

 

Then compile the C code together with the generated Haskell files (using GHC):

 

Output:

=={{header|Haxe}}==

=== PHP ===

 

=={{header|J}}==

The J verb evaluates to the string unless there is no space.

File <tt>rc_embed.ijs</tt>

query=:3 :'0&#^:(y < #)''Here am I'''

 

main.c

#include<stdio.h>

#include<stdlib.h>

return EXIT_SUCCESS;

}

 

Query.c

 

// J Front End Example

return 1;

}

 

makefile, adjust for your j installation.

# jfe makefile info

# customize to create makefile suitable for your platform

 

main: main.o Query.o

 

Finally, build and execution. Again, adjust LD_LIBRARY_PATH to the directory of libj.so .

$ make main && LD_LIBRARY_PATH=~/Downloads/jgplsrc/j/bin ./main

Here am I

$

 

=={{header|Java}}==

We write a Java method, then write a C function <code>Query()</code> to use the Java Native Interface (JNI) to call our Java method. The C compiler must find ''jni.h'' and ''jni_md.h'' and link with ''libjvm''.

 

public class Query {

public static boolean call(byte[] data, int[] length)

return true;

}

 

#include <stdio.h>

#include <stdlib.h>

 

return (int)result;

 

 

# Edit these lines to match your JDK.

 

clean:

 

=={{header|Kotlin}}==

 

First we compile the following Kotlin source file (Query.kt) using the '-platform dynamic' flag:

 

import kotlinx.cinterop.*

length.pointed.value = strLen.signExtend<size_t>()

return 1

 

This produces the dynamic library, libQuery.so, and the C header file libQuery_api.h:

#define KONAN_LIBQUERY_H

#ifdef __cplusplus

} /* extern "C" */

#endif

 

We now compile a slightly modified version of the C program required for this task, linking to the above library, and 'including' the header file:

#include <stdlib.h>

#include "libQuery_api.h"

putchar ('\n');

}

 

which when executed produces the expected output:

=={{header|Lisaac}}==

query.li

 

+ name := QUERY;

+ size : NATIVE_ARRAY[INTEGER];

query(buffer, size); // need this to pull the query() method

Makefile

 

all: $(TARGET)

 

clean:

 

=={{header|Nim}}==

const text = "Here am I"

if length < text.len:

return 0

 

data[i] = text[i]

length = text.len

Compile the above with <code>nim c --app:staticlib --no_main query.nim</code>.

 

extern int Query (char * Data, size_t * Length);

putchar ('\n');

}

<pre>./main

Here am I

 

=={{header|OCaml}}==

#include <string.h>

#include <caml/mlvalues.h>

putchar ('\n');

}

 

let s = "Here am I" in

(s, String.length s)

let () =

Callback.register "Query function cb" caml_query;

 

compile with:

-L"`ocamlc -where`" \

-lm -ldl -lasmrun

 

=={{header|PARI/GP}}==

This is a Linux solution. Message "Here I am" is encrypted with ROT13: "Urer V nz".

 

PARI's interface for Query()... query.c:

 

#define PARI_SECRET "s=\"Urer V nz\";Strchr(Vecsmall(apply(k->if(k>96&&k<123,(k-84)%26+97,if(k>64&&k<91,(k-52)%26+65,k)),Vec(Vecsmall(s)))))"

 

return rc;

 

Compile interface to a library: ''gcc -O2 -Wall -fPIC -shared query.c -o libquery.so -lpari''

The following code declares a callback for the C code (which I'd expect to be in a .dll or .so) to invoke.<br>

A 32-bit-only or a 64-bit-only version would of course be slightly shorter.

 

=={{header|PicoLisp}}==

 

If there is a file "query.l"

(unless (>= (size Str) Len) # Check buffer size

then the C function 'Query' could be

FILE *fp;

char buf[64];

*Length = strlen(Data);

return pclose(fp) >= 0 && *Length != 0;

 

=={{header|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 <tt>PyRun_SimpleString</tt> to have main.c call python calling back to c.

# store this in file rc_embed.py

# store this in file rc_embed.py

L = len(message)

return message[0:L*(L <= buffer_length)]

 

main.c

#if 0

//I rewrote the driver according to good sense, my style,

return EXIT_SUCCESS;

}

 

In Query.c I don't promise to have tested every case with missing module, missing function, or to have used <tt>Py_DECREF</tt> correctly.

#include<stdio.h>

#include<stdlib.h>

return result;

}

 

Compilation, linkage, execution. Note the python tools used to extract the correct flags.

$ make main.o

cc -c -o main.o main.c

Here am I

$

 

=={{header|Racket}}==

Starting with the given C code, modify it so that <tt>Query</tt> is a variable instead of an external:

 

typedef int strfun (char * Data, size_t * Length);

strfun *Query = NULL;

 

The rest of the C code is left as-is. Compile it into a dynamic library, then run the following Racket code:

 

#lang racket

 

((get-ffi-obj "main" xlib (_fun _int (_list i _bytes) -> _void))

0 '())

 

Note that this code is intentionally in a simple low-level form, for example, it sets the pointer directly instead of using a C function.

 

The output is the expected “<tt>Here I am</tt>” line.

 

=={{header|Ruby}}==

{{works with|MRI|2.3+}}

 

require 'fiddle'

 

 

# Set the C variable to our Query.

 

#include <stdlib.h>

#include <ruby.h>

bad_exit(state);

return a.result;

 

 

# To build and run:

task 'clean' do

rm_f %w[callruby main.o query-rb.o]

 

=={{header|Scala}}==

We write a Scala function, then write a C function <code>Query()</code> to use the Java Native Interface (JNI) to call our Scala method. The C compiler must find ''jni.h'' and ''jni_md.h'' and link with ''libjvm''.

 

object Query {

def call(data: Array[Byte], length: Array[Int]): Boolean = {

} else false

}

 

#include <stdio.h>

#include <stdlib.h>

 

return (int)result;

 

 

# Edit these lines to match your JDK.

 

clean:

=={{header|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:

Tcl_Obj *arguments[2];

int code;

}

return code;

Which would lead to a <code>Query</code> implementation like this:

puts "Query was $data"

return 1;

 

===‘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:

const char *str;

int len;

memcpy(Data, str, len+1);

return 1;

And the implementation of <code>Query</code> would be just:

return "Here am I"

(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 <code>main()</code> to initialize the Tcl library and create an interpreter instance, and you would need to build and link against [[libtcl]].

Tcl_Interp *interp;

 

 

/* Rest of contents of main() from task header... */

 

=={{header|TXR}}==

The TXR run-time is not available as a library that can be linked to a C program. Instead, we can put the C driver into a small library and call out to it from TXR, then accept its callback. Here is that library:

 

 

int query(int (*callback)(char *, size_t *))

putchar('\n');

}

 

Here are the build steps to produce a `query.so` object from it on GNU/Linux:

 

 

===Using <code>carray</code>===

Callbacks are modeled as "FFI closures". The macro <code>deffi-cb</code> defines a function which itself isn't a callback, but is rather a combinator which converts a Lisp function into a FFI callback.

 

(deffi query "query" void (closure)))

 

(t (carray-set-length buf size)

(carray-put buf s)

 

{{out}}

An alternative approach is possible if we avail ourselves of the <code>memcpy</code> function via FFI. We can receive the data as an opaque foreign pointer represented by the <code>cptr</code> type. We can set up <code>memcpy</code> so that its destination argument and return value is a <code>cptr</code>, but the source argument is a string:

 

(deffi query "query" void (closure)))

((> l size) 0) ; { return 0; } else

(t (memcpy buf s l) ; { memcpy(buf, s, l);

 

Here, the use of the <code>str</code> type in the <code>memcpy</code> interface means that FFI automatically produces a UTF-8 encoding of the string in a temporary buffer. The pointer to that temporary buffer is what is passed into <code>memcpy</code>. The temporary buffer is released after <code>memcpy</code> returns.

If a return value other than zero indicates that the callback failed, that can be arranged with an additional argument in <code>deffi-cb</code>:

 

 

Now the <code>query-cb</code> function generates callbacks that return -1 to the caller, rather than zero, if aborted by a non-local control transfer such as an exception.

 

=={{header|zkl}}==

 

Modified main.c:

// export zklRoot=/home/ZKL

// clang query.c -I $zklRoot/VM -L $zklRoot/Lib -lzkl -pthread -lncurses -o query

 

return 0;

Our query program:

On Linux:

{{out}}