Call a foreign-language function: Difference between revisions

*   [[Use another language to call a function]]

<br><br>

=={{header|8th}}==

\ tell 8th what the function expects:

"ZZ" "strdup" func: strdup

\ the ".s" will show both strings and you can see they are different items on the stack

free \ let the c library free the string

 

=={{header|Ada}}==

Ada provides standard interfaces to [[C]], [[C++]], [[Fortran]] and [[Cobol]]. Other language interfaces can be provided as well, but are not mandatory. Usually it is possible to communicate to any language that supports calling conventions standard to the [[OS]] ('''cdecl''', '''stdcall''' etc).

with Interfaces.C; use Interfaces.C;

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

Put_Line (Value (S2));

Free (S2);

=={{header|Aikido}}==

There are two ways to call a <em>native</em> function in Aikido. The first is to write a wrapper function in C++ that is invoked from the Aikido interpreter. In a C++ file:

extern "C" { // need C linkage

 

}

 

 

Then in the Aikido program:

 

The second way is to use a <em>raw native</em> function. These functions must adhere to a defined set of rules and can be called directly from the Aikido interpreter. In the case of <code>strdup</code> we need to play a nasty trick because it returns a pointer that we need to print as a string.

 

native function free(p) // also need to free the result

 

p++

}

=={{header|ALGOL 68}}==

The designers of Algol 68 made it extremely hard to incorporate code written in other languages. To be fair, this was a long time ago when such considerations weren't thought important and one should be careful to apply Hanlon's razor.

 

Note that I chose a non-trivial library function because the suggested strdup() doesn't really demonstrate the technique all that well.

BEGIN

MODE PASSWD = STRUCT (STRING name, passwd, INT uid, gid, STRING gecos, dir, shell);

FI

END

{{out}}

<pre>

root:x:0:0:root:/root:/bin/bash

</pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

pop {r0,r1,r2,r7,lr} @ restaur des 2 registres */

bx lr @ return

=={{header|Arturo}}==

 

'''C Library'''

 

// clang -c -w mylib.c

// clang -shared -o libmylib.dylib mylib.o

int doubleNum(int num){

return num * 2;

 

'''Calling from Arturo'''

 

call.external: "mylib" 'sayHello ["John"]

 

loop 1..3 'x [

print ["The double of" x "is" doubleNum x]

 

{{out}}

The double of 2 is 4

The double of 3 is 6 </pre>

=={{header|AutoHotkey}}==

 

WhichButton := DllCall("MessageBox", "int", "0", "str", "Press Yes or No", "str", "Title of box", "int", 4)

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

SYS "GetProcAddress", msvcrt%, "_strdup" TO `strdup`

SYS "GetProcAddress", msvcrt%, "free" TO `free`

PRINT $$address%

SYS `free`, address%

=={{header|C}}==

===Assembly via GCC===

Assembly code can be embedded and compiled via GCC.

#include <stdlib.h>

#include <stdio.h>

return 0 ;

}

Output:

<pre>

===Python===

'''IMPORTANT''' : The following implementation has been tested against Python 2.7, this won't work on a system which does not have the relevant files installed. Also pay attention to the compilation flags.

 

int main()

Py_Finalize();

return 0;

'''Compilation''' : Change 2.7 and relevant paths for a different Python version / different install location

<pre>

First 10 multiples of 3 in reverse order : [30, 27, 24, 21, 18, 15, 12, 9, 6, 3]

</pre>

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

While calling C functions from C++ is generally almost trivial, <code>strdup</code> illustrates some fine point in communicating with C libraries. However, to illustrate how to generally use C functions, a C function <code>strdup1</code> is used, which is assumed to have the same interface and behaviour as strdup, but cannot be found in a standard header.

 

In addition, this code demonstrates a call to a FORTRAN function defined as

Note that the calling convention of FORTRAN depends on the system and the used FORTRAN compiler, and sometimes even on the command line options used for the compiler; here, GNU Fortran with no options is assumed.

#include <string> // for C++ strings

#include <iostream> // for output

// free, not delete, nor delete[], nor operator delete

std::free(msg2);

=={{header|Clojure}}==

{{libheader|clojure-jna}}

Since Clojure is hosted on the JVM, you can follow the same approach as the [[#Java|Java]] solution and invoke your Java class from Clojure:

 

Alternatively, to avoid having to create a library in native code you could use JNA and the clojure-jna library for convenience. Here's how you can invoke ''strcmp'' from the libc shared library:

 

(jna/invoke Integer c/strcmp "apple" "banana" ) ; returns -1

(jna/invoke Integer c/strcmp "banana" "apple" ) ; returns 1

 

=={{header|CMake}}==

''This code uses a deprecated feature of CMake.'' In 2014, CMake 3.0 deprecated load_command(). CMake 3.0 can run this code but shows a deprecation warning. When a future version of CMake removes load_command(), this code will stop working, and there will be no way to call C functions from CMake.

 

'''CMakeLists.txt'''

project("outer project" C)

 

2012 / 500 = ${quot}

2012 % 500 = ${rem}

 

'''div/CMakeLists.txt'''

project(div C)

 

 

# Compile cmDIV from div-command.c

 

'''div/div-command.c'''

#include <stdio.h>

#include <stdlib.h>

info->InitialPass = initial_pass;

api = info->CAPI;

=={{header|COBOL}}==

Tested with GnuCOBOL

 

program-id. foreign.

 

display "error calling free" upon syserr

end-if

 

{{out}}

Hello, world

</pre>

=={{header|Common Lisp}}==

 

{{libheader|CFFI}}

 

(c-string (cffi:foreign-funcall "strdup" :string string :pointer)))

(unwind-protect (write-line (cffi:foreign-string-to-lisp c-string))

(values))

Hello World!

=={{header|Crystal}}==

Crystal allows to easily interface with C functions, both from object files and shared libraries.

lib LibC

fun free(ptr : Void*) : Void

LibC.free p # pointer can be freed as String.new(Char*) makes a copy of data

 

=={{header|D}}==

import std.string: toStringz;

import std.conv: to;

free(str1);

free(str2);

{{out}}

<pre>str1: Hello World!

str2: Hello World!</pre>

=={{header|Delphi}}==

===Importing the function from a shared library===

The file first has to be bound to your unit:

 

{$O myhello.obj}

 

The next step is to do an external declaration for the function:

procedure Hello(S: PChar); stdcall; external;

 

Afterwards usage of the function is just as with any other function.

 

=={{header|Factor}}==

 

libc is already loaded, it is used by Factor elsewhere.

 

: my-strdup ( str -- str' )

 

( scratchpad ) "abc" my-strdup .

"abc"

=={{header|FBSL}}==

Alongside its interpretative BASIC-style layer, FBSL also hosts built-in Intel-style Dynamic Assembler JIT and ANSI-C Dynamic C JIT compiler layers. BASIC, DynAsm and DynC procedures can be mixed freely to best suit the host script's intended purposes. The procedures follow their own respective syntaxes but are called in the host script in exactly the same way:

 

FBSL features a built-in stack balancing mechanism which eliminates stack corruption regardless of whether the API calls are using STDCALL or CDECL calling conventions. Please note that FBSL's BASIC and DynAsm '''do not''' make use of forward function declarations or header files.

=={{header|Forth}}==

{{works with|GNU Forth|0.7.0}}

Every version of GNU Forth has experimented with a different means to do C foreign function calls. The current implementation resolves various incompatibilities which had plagued earlier mechanisms by parsing C header files and using the host's native toolchain (i.e. gcc and ld) to generate thunks.

 

 

\c #include <string.h>

duped dup strlen type \ testing

 

=={{header|Fortran}}==

Since Fortran 2003, the standard provides the ISO_C_BINDING module to help interface with C programs. Before this, compiler vendors often provided nonstandard extensions to do this. Even with this new facility, some features, such as calling a STDCALL function on Windows, need some nonstandard extension.

Here is an example using the ISO_C_BINDING standard module to link against the C API functions ''strdup'', ''free'' and ''puts''. The program will print two copies of the string ''"Hello, World!"'' using the ''puts'' function. One copy is obtained from ''strdup'', then released with ''free''. The C bindings are placed in an interface module to simplify reuse. The addresses of the two copies are also printed.

 

use iso_c_binding

implicit none

transfer(ptr, 0_c_intptr_t)

call free(ptr)

=={{header|FreeBASIC}}==

Normally it's an easy matter to call a function in the C Standard Library, statically, from FreeBASIC.

As this uses LocalAlloc in kernel32.dll internally to allocate memory for the duplicated string, we need to call

LocalFree to free this memory using the pointer returned by strdup.

 

'Using StrDup function in Shlwapi.dll

DyLibFree(library) '' unload first dll

DyLibFree(library2) '' unload second fll

 

{{out}}

<pre>

duplicate

</pre>

 

=={{header|Go}}==

Using cgo, part of the standard Go command set.

 

// #include <string.h>

// demonstrate we have string contents intact

fmt.Println(go2)

Output:

<pre>

hello C

</pre>

 

=={{header|Haskell}}==

 

 

import Foreign (free)

s2_hs <- peekCString s2 -- marshall the C string called s2 into a Haskell string named s2_hs

putStrLn s2_hs

 

==Icon and {{header|Unicon}}==

The first step is to create a shared library, to wrap the target C functions and do type conversions on the input and returned values. The arguments to the wrapper functions form a list, and this list must be unpacked to retrieve the arguments to send to the target function. To get at <code>strdup</code> and <code>strcat</code> we would have:

 

#include <string.h>

#include "icall.h" // a header routine from the Unicon sources - provides helpful type-conversion macros

RetString (result);

}

 

Then the Unicon program must 'access' the function in the shared library: the important step is 'loadfunc' which accesses the named function in the shared library. After that, the C function can be called from within a program:

 

$define LIB "libstrdup-wrapper.so"

 

write (strcat ("abc", "def"))

end

 

Output:

abcdef

</pre>

=={{header|J}}==

 

Here is a windows specific implementation (for relatively recent versions of windows):

 

strdup=: 'msvcrt.dll _strdup >x *' cd <

free=: 'msvcrt.dll free n x' cd <

 

With these definitions:

 

Portability is possible, but often irrelevant for a task of this sort. To make this work with a different OS, you would need to use the appropriate file name for libc for the os in question. For example, on linux, replace msvcrt.dll with /lib/libc.so.6 (or whichever version of libc you are using).

 

See also: [http://www.jsoftware.com/help/user/call_procedure.htm J's documentation]

=={{header|Java}}==

Java uses JNI to call other languages directly. Because it is a managed language, a "shim" layer needs to be created when dealing with things outside of the managed environment.

 

'''JNIDemo.java'''

{

static

private static native String callStrdup(String s);

 

Two things to note: First, the "native" stub which will be linked with a native library, and second, the call to System.loadLibrary to actually do the linking at runtime. The class must then be compiled without the native library.

 

The generated file, '''JNIDemo.h''':

#include <jni.h>

/* Header for class JNIDemo */

}

#endif

 

Next, the C code which utilizes JNI to bridge between the managed and unmanaged environments. It should include the "h" file, and implement the exported function declared in that file. The specifics of writing JNI code are beyond the scope of this task.

 

'''JNIDemo.c'''

#include "JNIDemo.h"

 

return dupeString;

}

 

In a Windows environment, a dll by the same name should be created ("JNIDemo.dll"). In a Linux environment, a shared object marked executable and with a name preceded by "lib" should be created (in this case, "libJNIDemo.so"). Your compiler will need to know the location of "jni.h", which is in the "include" directory of the JDK. Linux may also need includes that are in the "include/linux" directory. Linux example using gcc:

Hello World!

</pre>

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

Julia has a built-in keyword <code>ccall</code> to call external C-like functions. For example:

@show unsafe_string(p) # "Hello world"

 

'''PyCall''', [https://github.com/JuliaPy/PyCall.jl source]:

@pyimport math

=={{header|Kotlin}}==

{{Works with|Ubuntu|14.04}}

 

import kotlinx.cinterop.*

val hw = strdup ("Hello World!")!!.toKString()

println(hw)

 

{{out}}

Hello World!

</pre>

=={{header|LabVIEW}}==

Use Connectivity >> Libraries & Executables >> Call Library Function Node to call an external .dll file. This example uses the WinAPI's MessageBoxA function.<br/>{{VI snippet}}<br/>

[[File:LabVIEW Call a foreign-language function.png]]

=={{header|Lisaac}}==

Use backtick notation (`...`) for referencing foreign language (C) features.

 

+ name := TEST_C_INTERFACE;

// this will also be inserted in-place, expression type disregarded

`free(@p)`;

 

=={{header|Lua}}==

 

Using the [http://luajit.org/ext_ffi.html FFI library] available in [http://luajit.org/ LuaJIT]:

 

ffi.cdef[[

char * strndup(const char * s, size_t n);

print("Copy: " .. s2)

print("strlen: " .. ffi.C.strlen(s2))

=={{header|Luck}}==

 

Luck supports interfacing with most C libraries out of the box:

 

import "string.h";;

 

let s2:char* = strdup(cstring(s1));;

puts(s2);;

=={{header|M2000 Interpreter}}==

=== Call C Functions from Dll===

There is a difference between Windows and Wine implementation of _strdump and swprintf.

Value of '''a''' has to hold chars to read from sBuf$ as returned from msvcrt.swprintf, but this can't work in Ubuntu using Wine and in Windows as expected, so we can use '''LeftPart$(string, string as delimiter sign not included as result)'''

 

Module CheckCCall {

}

CheckCCall

 

Output:

===Call VbScript===

 

Module Checkit {

Global a()

}

CheckIt

 

===Call Javascript===

Module CheckJavaScript {

Clear

}

CheckJavaScript

 

 

===Call A System Function (Win32)===

Declare MessageBox Lib "user32.MessageBoxW" {long alfa, lptext$, lpcaption$, long type}

Print MessageBox(Hwnd, "HELLO THERE", "GEORGE", 2)

Remove "user32"

 

===Make, use and remove a C Dll at runtime===

H C dll to produce an array of primes. We can

Module checkit {

Static DisplayOnce=0

checkit

 

=={{header|Maple}}==

We can call strdup, as requested, in the following way

> strdup( "foo" );

"foo"

However, this doesn't make a lot of sense in Maple, since there can be only one copy of any Maple string in memory. Moreover, I don't see any easy way to free the memory allocated by strdup. A more sensible example for Maple follows. (It might be sensible if you wanted to compare your system library version of sin with the one built-in to Maple, for instance.)

csin := proc(s::numeric)

option call_external, define_external(sin, s::float[8],

 

> csin( evalf( Pi / 2 ) );

=={{header|Mathematica}}/{{header|Wolfram Language}}==

This works on windows and on linux/mac (through Mono)

externalstrdup = DefineDLLFunction["_strdup", "msvcrt.dll", "string", {"string"}];

output

<pre>Duplicate: Hello world!</pre>

Also there is ExternalEvaluate that can call many other languages.

=={{header|Maxima}}==

Use load("funcs.lisp"), or inside Maxima: */

 

 

f(5, 6);

=={{header|Mercury}}==

 

Mercury is designed to interact sensibly with foreign code, even while keeping itself as pure and as safe as is possible in such circumstances. Here is an example of calling C's strdup() function from within Mercury:

 

 

:- interface.

io.write_string(strdup("Hello, worlds!\n"), !IO).

 

 

Only the lines wrapped in comments matter for this. The rest is an application skeleton so this can be compiled and tested.

After this the Mercury strdup/1 function itself is declared. For purposes of exposition it has been declared fully with types and modes. The modes, however, are redundant since by default functions in Mercury have all input parameters and an output return value. Also, the determinism is declared which is again redundant. By default Mercury functions are deterministic. That line could easily have been written thusly instead:

 

 

The next block of code is the foreign_proc pragma declaration. In this declaration the language ("C") is declared, the footprint of the function is again provided, this time with variable names and modes but without the determinism, a set of properties is declared and the actual C code to be executed is provided. This last piece is trivial, but the properties themselves are worth looking more closely at.

 

Of note is that '''no separate C source file needs to be provided'''. The compiler takes care of putting in all the required boilerplate code necessary to conform to the specifications provided. The resulting code can be treated as much a part of the program as any native Mercury code would be: types, modes, determinism, purity, etc. all managed similarly.

=={{header|Modula-2}}==

The first file (Vga.c) creates the function prototypes.

 

int Initialize (void)

{

*ch = vga_getkey ();

The next file is the definition module, but in this context it is called a '''FOREIGN MODULE'''.

 

TYPE EGAcolour = (black, blue, green, cyan, red, pink, brown, white,

PROCEDURE GetKey (VAR ch : CHAR);

 

The third file is an example program.

 

FROM InOut IMPORT Read, Write, WriteBf, WriteString;

Write (ch);

WriteBf;

=={{header|Modula-3}}==

Modula-3 provides many predefined interfaces to C files. Here we use <tt>Cstring</tt> which uses C string functions. Note we have to convert strings of type <tt>TEXT</tt> into C strings (NULL terminated character arrays). Also note the code requires the <tt>UNSAFE</tt> keyword because it interfaces with C (which is unsafe).

 

IMPORT IO, Ctypes, Cstring, M3toC;

M3toC.FreeCopiedS(string1);

M3toC.FreeCopiedS(string2);

Output:

<pre>

string1 # string2

</pre>

=={{header|Mosaic}}==

 

importdll msvcrt =

str2:=_strdup(&.str)

println str2

=={{header|Never}}==

Never includes libffi for access to foreign functions, but currently only supports very basic types, int, float, string. ''strdup'' will work, but the ''voidness'' of ''free'' is not yet supported. This solution uses some of the Math functions in libm instead.

 

extern "libm.so.6" func coshf(x : float) -> float

extern "libm.so.6" func powf(base : float, exp : float) -> float

 

0

 

 

1.18

</pre>

=={{header|NewLISP}}==

newLISP has two FFI APIs. The simple API needs no type specifiers but is limited to integers and pointers.

The extended API can specify types for return values and parameters and can also be used for floats and structs.

(import "libc.dylib" "strdup")

(println (get-string (strdup "hello world")))

(import "libc.dylib" "strdup" "char*" "char*")

(println (strdup "hello world"))

=={{header|Nim}}==

Since Nim compiles to C by default, this task is easily done:

 

echo strcmp("abc", "def")

echo strcmp("hello", "hello")

 

var x = "foo"

=={{header|OCaml}}==

 

===Outline of what is linked against===

For the hypothetical [[C]] library that contains functions described by a header file with this in:

float myfunc_b(int, float);

 

The header file is named "<tt>mylib.h</tt>", and linked against the library with <tt>-lmylib</tt> and compiled with <tt>-I/usr/include/mylib</tt>.

 

====file "mylib.ml":====

external myfunc_b: int -> float -> float = "caml_myfunc_b"

 

====file "wrap_mylib.c":====

#include <caml/alloc.h>

#include <mylib.h>

free(arr);

return caml_copy_string(s);

 

====the Makefile:====

(replace spaces by tabs)

ocamlc -c -ccopt -I/usr/include/mylib $<

 

 

clean:

 

the file <tt>mylib.cma</tt> is used for the interpreted and bytecode modes, and <tt>mylib.cmxa</tt> is for the native mode.

There is another solution for calling C functions from a C library which is to use '''ocaml-ctypes'''. We can then define bindings by writing only OCaml code without any C stubs. The equivalent for wrapping the previous hypothetical [[C]] library will be:

 

open Foreign

 

let arr = CArray.of_list int lst in

myfunc_c (to_voidp (CArray.start arr)) (CArray.length arr)

=={{header|Ol}}==

(import (otus ffi))

 

 

(print (strdup "Hello World!"))

 

Windows has no a "strdup" function, so windows version should look like this.

(import (otus ffi))

 

 

(print (strdup "Hello World!"))

 

Note: this simplest way is not freeing allocated by "strdup" function string.

 

Ol provides a way to call ol functions directly from native code (means callbacks).

; The sample usage of GTK3+ library

(import (otus ffi)

 

(g_application_run app 0 #false)

 

=={{header|Oz}}==

First we need to create a so-called "native functor" that converts the arguments and describes the C functions:

#include <string.h>

 

};

return table;

 

Save this file as "strdup.cc". To automate compiling and linking, we need a makefile for <code>ozmake</code>, the Oz build tool. Save this file as "makefile.oz":

lib : [

'strdup.o' 'strdup.so'

]

rules:o('strdup.so':ld('strdup.o'))

Call <code>ozmake</code> in the same directory.

 

Now we can write some code that uses the wrapped C function (make sure Emacs' working directory is set to the same directory):

 

[Strdup] = {Module.link ['strdup.so{native}']}

in

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

Of course it is trivial to include C functions in PARI, and not uncommon. C++ functions are similar, as PARI is written in a C++-friendly style. The <code>system</code> and <code>install</code> commands allow foreign-language functions to be called from within gp.

=={{header|Pascal}}==

See [[Call_a_foreign-language_function#Delphi | Delphi]]

=={{header|Perl}}==

Perl code calls a C function <code>c_dup()</code> passing a string <code>'Hello'</code> as an argument, which gets transparently converted to a C string, the <code>c_dup()</code> function makes a copy of that string using <code>strdup()</code> function, stores pointer to the copy in the <code>copy</code> variable and returns it. The returned <code>char</code> pointer gets converted transparently to a Perl string value and gets returned to the calling Perl code which prints it. Then the Perl code calls a C function <code>c_free()</code> to free the allocated memory. Both of the C functions are defined inline in the Perl program and are automatically compiled (only once, unless they change) and linked at runtime. Here is the entire program:

char *copy;

char * c_dup(char *orig) {

};

print c_dup('Hello'), "\n";

 

Another example, instead of returning the copy to Perl code it prints it using C printf:

void c_hello (char *text) {

char *copy = strdup(text);

}

};

=={{header|Phix}}==

The foreign language functions must be compiled to .dll (or .so) form.<br>

a library component which can be re-used in different applications.<br>

See also builtins/cffi.e, a text-based C interface that handles C-style structs, unions, and function declarations directly.

{{out}}

<pre>

"Hello World!"

</pre>

 

=={{header|PicoLisp}}==

The easiest is to inline the C code. Another possibility would be to write it

 

===32-bit version===

 

(gcc "str" NIL # The 'gcc' function passes all text

/**/

 

===64-bit version===

/*

How to create the shared lib/so file:

int main() {

}

 

(prinl "Calling custom so/dll library...")

(set 'A NIL)

(prinl "A=" A)

(when (not (= A NIL)) (prinl "Success!"))

 

<out>

</pre>

</out>

=={{header|PL/I}}==

 

=={{header|Prolog}}==

In SWI-Prolog we need to do two things. First we need to declare a mapping from a Prolog file to a C implementation:

 

 

This declares a module "plffi" that exports the '''predicate''' (''not'' function!) "strdup/2". This predicate has two arguments: the first being the atom being strduped, the second being the duped atom. (You can think of these as an in parameter and an out parameter and be about 2/3 right.)

Then we need to write a C file that gives us the interface to the underlying C function (strdup in this case), mapping the ''predicate''' call to a C '''function''' call:

 

#include <stdio.h>

#include <SWI-Prolog.h>

{

PL_register_foreign("strdup", 2, pl_strdup, 0);

 

This C code provides us with two things. The function install_plffi() is provided to register the name "strdup" and to map it to its C implementation pl_strdup(). Here we're saying that "strdup" has an arity of 2, is implemented by pl_strdup and has no special flags.

We compile this very easily:

 

 

Then, from within the SWI-Prolog interactor:

 

% plffi compiled into plffi 0.04 sec, 1,477 clauses

true.

 

?- X = booger, strdup(booger, X).

=={{header|PureBasic}}==

Here we will use [http://flatassembler.net/ Fasm (flat assembler)] to create an object file and then import the function

the resulting executable. [http://www.purebasic.com/ PureBasic] supports {Windows, Linux, MacOS}.

 

; Call_a_foreign_language_function.fasm -> Call_a_foreign_language_function.obj

; the assembler code...

 

public strucase as "_strucase@4"

 

; the PureBasic code...

 

; cw(peeks(*r))

Debug peeks(*r)

 

 

HELLO WORLD!!

</pre>

=={{header|Python}}==

 

libc = ctypes.CDLL("/lib/libc.so.6")

libc.strcmp("abc", "def") # -1

=={{header|Racket}}==

#lang racket/base

(require ffi/unsafe)

;; Let's try it:

(strdup "Hello World!")

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2016.07}}

 

sub strdup(Str $s --> Pointer) is native {*}

my $p = strdup("Success!");

say 'puts returns ', puts($p);

{{out}}

<pre>Success!

puts returns 9

free returns 0</pre>

=={{header|REALbasic}}==

Declare Function CreateFileW Lib "Kernel32" (FileName As WString, DesiredAccess As Integer, ShareMode As Integer, SecurityAttributes As Integer, _

CreateDisposition As Integer, Flags As Integer, Template As Integer) As Integer

MsgBox("Error Number: " + Str(GetLastError))

End If

=={{header|REXX}}==

The use of the &nbsp; '''address''' &nbsp; statement isn't normally required, but it's shown here as an illustrative example.

 

cmd = "MODE" /*define the command that is to be used*/

address 'SYSTEM' cmd opts /*invoke a cmd via the SYSTEM interface*/

 

{{out|output|text=&nbsp; when executing under a Microsoft Windows system in the USA, &nbsp; code pages vary upon the country:}}

<pre>

Code page: 437

</pre>

=={{header|Ruby}}==

 

 

{{works with|MRI}}

#include <stdlib.h> /* free() */

#include <string.h> /* strdup() */

VALUE mRosettaCode = rb_define_module("RosettaCode");

rb_define_module_function(mRosettaCode, "strdup", rc_strdup, 1);

 

require 'mkmf'

 

require 'rc_strdup'

 

=== FFI ===

A recent effort to make it easier to write libraries, portable across platforms and interpreters, led to the creation of a [http://sourceware.org/libffi/ libffi] binding simply called [http://wiki.github.com/ffi/ffi/ ffi] for completely dynamic calls.

 

require 'ffi'

 

puts duplicate.get_string(0)

LibC.free(duplicate)

 

 

 

{{works with|Ruby|2.0+}}

 

# Find strdup(). It takes a pointer and returns a pointer.

duplicate = strdup.call("This is a string!")

puts duplicate.to_s # Convert the C string to a Ruby string.

 

Fiddle::Importer is also part of Ruby's standard library.

 

{{works with|Ruby|2.0+}}

require 'fiddle/import'

 

duplicate = C.strdup("This is a string!")

puts duplicate.to_s

 

=== RubyInline ===

Using {{libheader|RubyGems}} package [http://www.zenspider.com/ZSS/Products/RubyInline/ RubyInline], which compiles the inlined code on demand during runtime.

 

require 'inline'

 

t = InlineTester.new

11.upto(14) {|n| p [n, t.factorial_ruby(n), t.factorial_c(n)]}

 

outputs (note Ruby's implicit use of Bignum past 12!, while C is stuck with a long int):

[14, 87178291200, 1278945280]

9</pre>

=={{header|Rust}}==

 

 

//c function that returns the sum of two integers

add_input(in1, in2) };

assert!( (output == (in1 + in2) ),"Error in sum calculation") ;

=={{header|Scala}}==

try System.loadLibrary("JNIDemo")

 

 

println(callStrdup("Hello World!"))

=={{header|Smalltalk}}==

The way external functions are declared is different among Smalltalk dialects. However, there are not many situations where you'd need them (and especially not for simple things like strdup).

 

{{works with | Smalltalk/X}}

!CallDemo class methods!

strdup:arg

! !

 

 

=={{header|Stata}}==

As an example let's build a '''[https://en.wikipedia.org/wiki/Hilbert_matrix Hilbert matrix]''' in C.

 

#include "stplugin.h"

 

}

return 0;

 

The DLL can be built from '''Visual Studio''', or in the console with <code>cl /LD hilbertmat.c stplugin.c</code>. With '''MinGW''', compile with <code>gcc -shared stplugin.c hilbertmatrix.c -o hilbertmat.plugin</code>. With '''Pelles C''', compile with <code>cc /Tx64-coff /Ze stplugin.c hilbertmat.c /DLL /OUT:hilbertmat.plugin</code>. The DLL must be renamed with the '''.plugin''' extension, and put in a directory visible in [https://www.stata.com/help.cgi?adopath adopath].

Declare also an ADO file to call the plugin:

 

matrix define `1'=J(`2',`2',0)

plugin call hilbertmat, `1' `2'

end

 

 

Then, you may call

 

 

. matrix list mymat

r2 .5 .33333333

r3 .33333333 .25 .2

 

Notice the program as is has minimal protection against invalid arguments. Production code should be more careful.

As an example let's build a '''[https://en.wikipedia.org/wiki/Hilbert_matrix Hilbert matrix]''' in Java.

 

 

public class HilbertMatrix {

return 0;

}

 

Compile with <code>javac -cp %STATA%\utilities\jar\sfi-api.jar HilbertMatrix.java</code>, assuming %STATA% is the path to the Stata install directory.

In Stata, assuming HilbertMatrix.class resides in K:\java:

 

 

. matrix list mymat

r2 .5 .33333333

r3 .33333333 .25 .2

 

Notice that Mata has the builtin function '''[https://www.stata.com/help.cgi?mf_Hilbert Hilbert]''' to do the same:

 

[symmetric]

1 2 3 4

3 | .3333333333 .25 .2 |

4 | .25 .2 .1666666667 .1428571429 |

=={{header|Swift}}==

Because Swift uses the Objective-C runtime it is trivial to call C/Objective-C functions directly in Swift.

 

let hello = "Hello, World!"

let fromC = strdup(hello)

=={{header|Tcl}}==

{{libheader|critcl}}

In this solution, we wrap up the <code>ilogb</code> function from C's math library with critcl so that it becomes one of Tcl's normal functions (assuming Tcl 8.5):

critcl::code {

#include <math.h>

return ilogb(value);

}

Note that we do not show <code>strdup</code> here because Tcl manages the memory for strings in complex ways and does not guarantee to preserve string pointers from one call into the C API to the next (e.g., if it has to apply an encoding transformation behind the scenes).

<!-- TODO: a basic thunk, and show off using SWIG -->

=={{header|TXR}}==

 

 

There is no way to use the <code>str</code> family of types, yet do manual memory management; FFI manages automatically. Code that wants to manually manage a foreign resource referenced by pointer should use <code>cptr</code> or <code>carray</code>, depending on required semantics.

 

=={{header|Wren}}==

Although RC task solutions are usually written for execution by Wren CLI, the language's main purpose is for embedding and the embedding API is written in C. It is therefore a relative easy matter to call a C function from Wren after first embedding the latter in a suitable C program.

 

 

class C {

 

var s = "Hello World!"

 

which we embed in the following C program and run it.

 

Note that it's safe to free the pointer returned by strdup after passing it to Wren because wrenSetSlotString copies the C string to a new String object managed by Wren’s garbage collector.

#include <stdio.h>

#include <string.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}

===UASM 2.52===

Calling C functions in Assembly is trivial at best. It's not anymore complicated than using them in C itself. Strdup for example..

option casemap:none

 

;main endp

;end

====Lua====

Using the liblua that comes with Lua 5.2(?). Assembling is the same as always, Link with a -llua using clang or gcc.

option casemap:none

 

 

end

Addition.lua

function addition(a, b)

print('---> Lua calc: ' .. a .. ' + ' .. b .. ' = ' .. a+b)

return a + b

end

{{out}}

<pre>

===NASM===

{{trans|Wren}}

extern printf

extern exit

 

extern wrenNewVM

extern wrenInterpret

extern wrenFreeVM

extern wrenGetSlotString

extern wrenInitConfiguration

 

extern C_strdup

 

 

section .bss

 

section .rodata

szmsg db "--> Starting and configuring WrenVM",10,0

 

section .text

global main

push rbp

mov rbp, rsp

cmp rax, WREN_RESULT_SUCCESS

 

 

pop rbp

xor rdi, rdi

 

writefn:

push rbp

mov rbp, rsp

pop rbp

ret

 

errfn:

push rbp

mov rbp, rsp

pop rbp

ret

 

void free( void* ptr );

char * strdup( const char *str1 );

free(t);

}

{{out}}

<pre>

--> Starting and configuring WrenVM

</pre>

 

=={{header|zkl}}==

In my opinion, FFIs are very problematic and it is better, if you really need external functionality, to spend the effort to write a glue library. Certainly a lot more work. And it only works for C or C++.

 

flf.c:

// flf.c, Call a foreign-language function

 

}

return methodCreate(Void,0,zkl_strlen,vm);

In use on Linux:

{{out}}

3

</pre>

{{omit from|Batch File|Can only execute other programs but cannot call arbitrary functions elsewhere.}}

{{omit from|GUISS}}

{{omit from|M4}}

{{omit from|ML/I}}

{{omit from|Order|Doesn't allow to call functions from other languages.}}

{{omit from|TI-89 BASIC|Does not have a standard FFI.}}

{{omit from|Unlambda|Doesn't allow to call functions from other languages.}}