Call a function in a shared library: Difference between revisions

===Windows===

The following solution calls ''MessageBox'' from [[Windows]]' dynamic library ''user32.dll''. It does not use Win32 bindings, which would be meaningless, because ''MessageBox'' is already there. Instead of that it links statically to ''kernel32.dll'', which required to load anything under [[Windows]]. From there it uses ''LoadLibrary'' to load ''user32.dll'' and then ''GetProcAddress'' to get the ''MessageBox'' entry point there. Note how [[Windows]] mangles names of functions in the import libraries. So "LoadLibrary" becomes "_LoadLibraryA@4", which is its real name. "A" means ASCII. Once address of ''MessageBox'' is obtained it is converted to a pointer to a function that has an interface corresponding to it. Note [[Windows]]' call convention, which is '''stdcall'''.

with Interfaces; use Interfaces;

with Interfaces.C; use Interfaces.C;

Put_Line ("Unable to load the library " & HANDLE'Image (Library));

end if;

===Linux===

Here we are using the ''dl'' library statically (-ldl switch upon linking) and ''Xlib'' dynamically (''libX11.so''). The function ''dlopen'' loads a library. The function ''dlsym'' looks up for an entry point there. From ''libX11.so'', first ''XOpenDisplay'' is called to open an X11 display, which name is in the DISPLAY environment variable. Then XDisplayWidth of the display is obtained an printed into the standard output.

with Ada.Text_IO; use Ada.Text_IO;

with Interfaces; use Interfaces;

Put_Line ("Unable to load the library");

end if;

=={{header|Arturo}}==

try? [

call.external:'curl "curl_version" .expect: :string []

]

{{out}}

{{works with|http://www.autohotkey.net/~tinku99/ahkdll/ AutoHotkey.dll}}<br>

dllhost.ahk

clientHandle := DllCall("AutoHotkey\ahkdll", "str", "dllclient.ahk", "str"

dllclient.ahk

=={{header|BaCon}}==

PROTO j0

bessel0 = j0(1.0)

PRINT bessel0

{{out}}

{{works with|BBC BASIC for Windows}}

The following shared libraries are automatically available: ADVAPI32.DLL, COMCTL32.DLL, COMDLG32.DLL, GDI32.DLL, KERNEL32.DLL, SHELL32.DLL, USER32.DLL and WINMM.DLL.

=={{header|C}}==

'''Tested with''' gcc on a GNU/Linux system (on GNU/Linux <code>dl*</code> functions are available linking to <tt>libdl</tt>, i.e. with <tt>-ldl</tt> option)

#include <stdlib.h>

#include <dlfcn.h>

if (imglib != NULL ) dlclose(imglib);

return EXIT_SUCCESS;

The fake <tt>fakeimglib.so</tt> code is

/* gcc -shared -nostartfiles fakeimglib.c -o fakeimglib.so */

int openimage(const char *s)

fprintf(stderr, "opening %s\n", s);

return handle++;

When the library <tt>fakeimglib.so</tt> exists in the current directory (this choice is senseful only for testing purposes), the output is:

=={{header|C sharp|C#}}==

In Windows.

class Program {

int r = fakefunction(10);

}

=={{header|COBOL}}==

Tested with GnuCOBOL, GNU/Linux.

program-id. callsym.

goback.

{{out}}

{{libheader|CFFI}}

#<CFFI::FOREIGN-LIBRARY {1004F4ECC1}>

CL-USER> (cffi:foreign-funcall "XOpenDisplay"

#-sbcl ":0.0"

:pointer)

=={{header|Crystal}}==

sqrtptr = LibC.dlsym(libm, "sqrt") unless libm.null?

end

=={{header|D}}==

import std.stdio, std.c.windows.windows;

void main() {

writeln(GetDoubleClickTime());

<pre>500</pre>

add.c

int add(int num1, int num2) {

return num1 + num2;

}

Dart code

show DynamicLibrary, NativeFunction, Int32;

print( add( 1, 2 ) );

}

=={{header|Delphi}}==

Loads library on startup.

Loads library on first call to DoSomething.

Loads and unloads library on demand.

lLibraryHandle: THandle;

lDoSomething: procedure; stdcall;

FreeLibrary(lLibraryHandle);

end;

=={{header|Forth}}==

===GNU Forth 0.7.9 on Linux===

Call tgamma() from limbm.so

c-library math

end-c-library

{{Out}}

<pre>

A simple "C" function add_n in add_n.c

double add_n(double* a, double* b)

{

return *a + *b;

}

compile it

File add_nf.f90

function add_nf(a,b) bind(c, name='add_nf')

use, intrinsic :: iso_c_binding

add_nf = a + b

end function add_nf

Compile it

File shared_lib_new_test.f90

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

!module dll_module

end program test_load_dll

Compile test program

===Intel Fortran on Windows===

First, the DLL. Compile with '''ifort /dll dllfun.f90'''. The function is compiled with the STDCALL calling convention: it's not necessary here but it shows how to do it.

implicit none

!DEC$ ATTRIBUTES DLLEXPORT, STDCALL, REFERENCE :: FFUN

double precision :: x, y, ffun

ffun = x + y * y

Now, the main program. It will wait for two numbers and compute the result with the DLL function. Compile with '''ifort dynload.f90'''. Three functions of the Kernel32 library are necessary, see '''[https://msdn.microsoft.com/en-us/library/ms684175.aspx LoadLibrary]''', '''[https://msdn.microsoft.com/en-us/library/ms683212.aspx GetProcAddress]''' and '''[https://msdn.microsoft.com/en-us/library/ms683152.aspx FreeLibrary]''' in the MSDN. The kernel32 module is provided with the Intel Fortran compiler. The DLL has to be in a directory in the PATH environment variable.

use kernel32

use iso_c_binding

if (FreeLibrary(h) == 0) error stop "Error: FreeLibrary"

=== GNU Fortran on Windows ===

First the DLL:

implicit none

!GCC$ ATTRIBUTES DLLEXPORT, STDCALL :: FFUN

double precision :: x, y, ffun

ffun = x + y * y

Main program:

use kernel32

use iso_c_binding

if (FreeLibrary(h) == 0) error stop "Error: FreeLibrary"

Interface module:

use iso_c_binding

implicit none

end function

end interface

=={{header|FreeBASIC}}==

' Attempt to call Beep function in Win32 API

Print

Print "Press any key to quit"

=={{header|Go}}==

This is the C code to produce fakeimglib.so:

/* gcc -shared -fPIC -nostartfiles fakeimglib.c -o fakeimglib.so */

int openimage(const char *s)

fprintf(stderr, "opening %s\n", s);

return handle++;

And this is the Go code to dynamically load the .so file and call the 'openimage' function - or if the .so file (or the function itself) is not available, to call the internal version of the function:

/*

}

fmt.Printf("opened with handle %d\n", imghandle)

{{output}}

{{libheader|unix}}

-- stack --resolver lts-6.33 --install-ghc runghc --package unix

Right f -> ("Using BUF_reverse from OpenSSL", f)

putStrLn msg

=={{header|J}}==

Most of this was borrowed from [[Call a foreign-language function#J]]

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

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

y

end.

You get a domain error when the required library is not present at run time. A try/catch will let you handle this (as would the <code>::</code> adverse operator).

Example use:

hello

getstr@strdup ::] 'hello'

=={{header|Java}}==

If you have Unix [[make]], then edit the ''Makefile'', run <code>make</code>, run <code>java -Djava.library.path=. RSort</code>. If you don't set java.library.path, or don't build the library, then the Java code falls back from using C to using Java. For more info about building a JNI library, see [[Call a foreign-language function#Java]].

import java.util.Collections;

System.out.println("ok");

}

#include <stdlib.h>

qsort(elem, length, sizeof(jint), reverse_abs_cmp);

(*jenv)->ReleasePrimitiveArrayCritical(jenv, ary, elem, 0);

# Edit the next lines to match your JDK.

clean:

rm -f TrySort.class TrySort?IntList.class \

===JNA===

{{libheader|JNA}}

import com.sun.jna.Native;

lib.sharedLibraryFunction();

}

=={{header|Jsish}}==

Normally, this function would register commands to the shell, but this is just a DISPLAY statement on load, and then again on unload as jsish runs down. Note the name used, "Jsi_Initbyjsi", from "byjsi.so".

For example, a COBOL library generated from

program-id. sample as "Jsi_Initbyjsi".

display "Called again with: " jsi-interp ", " rel upon syserr

goback.

{{out}}

=={{header|Julia}}==

Julia has the `ccall` function which follows the form: ccall((symbol, library), RetType, (ArgType1, ...), ArgVar1, ...)

#this example works on Windows

ccall( (:GetDoubleClickTime, "User32"), stdcall,

Uint, (), )

For more information, see here [http://docs.julialang.org/en/latest/manual/calling-c-and-fortran-code.html]

This is the C code to produce fakeimglib.so:

/* gcc -shared -fPIC -nostartfiles fakeimglib.c -o fakeimglib.so */

int openimage(const char *s)

fprintf(stderr, "opening %s\n", s);

return handle++;

And this is the Kotlin code to dynamically load the .so file and call the 'openimage' function - or if the .so file (or the function itself) is not available, to call the internal version of the function:

import kotlinx.cinterop.*

}

println("opened with handle $imgHandle")

{{out}}

=={{header|Lingo}}==

str = "The quick brown fox jumps over the lazy dog"

crc = crcObj.crc32(str)

=={{header|Lua}}==

There is no built-in mechanism, but several external library options exist. Here, the alien library is used to display a message box via the Win32 API.

msgbox = alien.User32.MessageBoxA

msgbox:types({ ret='long', abi='stdcall', 'long', 'string', 'string', 'long' })

retval = msgbox(0, 'Please press Yes, No or Cancel', 'The Title', 3)

=={{header|Maple}}==

> cfloor( 2.3 );

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

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

externalFloor = DefineDLLFunction["floor", "msvcrt.dll", "double", { "double" }];

externalFloor[4.2]

=={{header|Nim}}==

===Interacting with C code===

echo openimage("foo")

echo openimage("bar")

The fake <code>fakeimglib.so</code> code is

/* gcc -shared -nostartfiles fakeimglib.c -o fakeimglib.so */

int openimage(const char *s)

fprintf(stderr, "opening %s\n", s);

return handle++;

Output:

<pre>opening foo

===Interacting with Nim code===

echo openimage("foo")

echo openimage("bar")

The fake <code>libfakeimg.so</code> code is

var handle = 100

stderr.writeln "opening ", s

result = handle

Output:

<pre>opening foo

Here is an example of use of this [[Call a function in a shared library/OCaml|Dlffi module]]:

let get_int = function Int v -> v | _ -> failwith "get_int"

Printf.printf "# Screen dimensions are: %d x %d pixels\n" width height;

dlclose xlib;

=={{header|Ol}}==

Simplest case. Will produce memory leak, because no C "free" function called for dupped string. Useful when no "free" function call required.

(import (otus ffi))

(print (strdup "Hello World!"))

A bit complex case. No memory leaks, because "free" function called for dupped string.

(import (otus ffi))

(print (strdup "Hello World!"))

{{Out}}

=={{header|OxygenBasic}}==

'Loading a shared library at run time and calling a function.

FreeLibrary user32

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

where "G" is the parser code; see section 5.7.3 in the [http://pari.math.u-bordeaux.fr/pub/pari/manuals/2.4.4/libpari.pdf User's Guide to the PARI library] for more information.

===Inline===

This modules auto-builds a wrapper to the library on the first call, and subsequently uses that interface with no delay.

C => "DATA",

ENABLE => "AUTOWRAP",

__DATA__

__C__

{{out}}

<pre>3.14159265358979</pre>

===FFI===

This module is smart about finding libraries, here getting <code>atan</code> (from 'lm') and <code>puts</code> (from 'libc').

my $ffi = FFI::Platypus->new;

$ffi->lib(undef);

$ffi->attach(atan => ['double'] => 'double');

{{out}}

<pre>3.14159265358979</pre>

=={{header|Phix}}==

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- not from a browser, mate!</span>

<span style="color: #004080;">string</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">libname</span><span style="color: #0000FF;">,</span><span style="color: #000000;">funcname</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #004600;">WINDOWS</span><span style="color: #0000FF;">?{</span><span style="color: #008000;">"user32"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"CharLowerA"</span><span style="color: #0000FF;">}:{</span><span style="color: #008000;">"libc"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"tolower"</span><span style="color: #0000FF;">})</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">c_func</span><span style="color: #0000FF;">(</span><span style="color: #000000;">func</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">'A'</span><span style="color: #0000FF;">})</span> <span style="color: #000080;font-style:italic;">-- ('A'==65)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

{{out}}

<pre>

===32-bit version===

For the 32-bit version, we need some glue code:

(gcc "x11" '("-lX11") 'xOpenDisplay 'xCloseDisplay)

-> 158094320

: (xCloseDisplay Display)

===64-bit version===

In the 64-bit version, we can call the library directly:

-> 6502688

: (native "/usr/lib/libX11.so.6" "XCloseDisplay" 'I Display)

=={{header|PowerBASIC}}==

{{Works with|PowerBASIC for Windows}}

In this example, if the library can't be found (user32), or the desired function in the library (MessageBoxA), the equivalent built-in function (MSGBOX) is at the "epicFail" label... but really, if you can't find user32.dll, you've got bigger things to worry about.

FUNCTION PBMAIN () AS LONG

IF ISFALSE(tmp&) THEN MSGBOX "Error freeing library... [shrug]"

END IF

=={{header|PureBasic}}==

Older PureBasic versions normally relied on CallFunction() and CallFunctionFast()

*MessageBox = GetFunction(0, "MessageBoxA")

CallFunctionFast(*MessageBox, 0, "Body", "Title", 0)

CloseLibrary(0)

Since versions 4 the recommended way is via the usage of Prototypes even if the old system still is supported.

If OpenLibrary(0, "User32.dll")

MsgBox(0, "Hello", "World")

CloseLibrary(0)

=={{header|Python}}==

=== ctypes ===

Example that call User32.dll::GetDoubleClickTime() in windows.

user32_dll = ctypes.cdll.LoadLibrary('User32.dll')

Or, to call printf out of the C standard library:

>>> # libc = ctypes.cdll.msvcrt # Windows

>>> # libc = ctypes.CDLL('libc.dylib') # Mac

>>> libc.printf(b'hi there, %s\n', b'world')

hi there, world.

=== CFFI ===

[https://cffi.readthedocs.io/ CFFI] isn't built into the stdlib, but, on the other hand, it works with other Python implementations like PyPy. It also has a variety of advantages and disadvantages over ctypes, even for simple cases like this:

>>> from cffi import FFI

>>> ffi = FFI()

>>> C.printf(b"hi there, %s.\n", arg) # call printf

hi there, world.

=={{header|QB64}}==

Declare Dynamic Library "Kernel32"

Sub SetLastError (ByVal dwErr As Long)

SetLastError 20

=={{header|R}}==

This is possible in R in only a few limited ways. If the library function one wishes to call is a (C-level) R function (of type SEXP), then one may call

It is also possible to use <code>.C()</code> and <code>.Fortran()</code> to call voids and subroutines respectively; here the return value(s) should be in the argument list (rather than merely modifying state). An example of this might look like

The return of the <code>.C()</code> function is an R list.

=={{header|Racket}}==

(require ffi/unsafe)

(define libm (ffi-lib "libm")) ; get a handle for the C math library

; look up sqrt in the math library. if we can't find it, return the builtin sqrt

(define extern-sqrt (get-ffi-obj 'sqrt libm (_fun _double -> _double)

Output: <pre>> (extern-sqrt 42.0)

(formerly Perl 6)

{{works with|Rakudo|2018.11}}

sub XOpenDisplay(Str $s --> int64) is native('X11') {*}

say "No X11 library!";

say "Use this window instead --> ⬜";

{{out}}

<pre>ID = 94722089782960</pre>

The dropping of functions isn't really necessary for most REXX programs.

/*Note: the REGUTIL.DLL (REGina UTILity Dynamic Link Library */

exit rcd /*exit this program with RC. */

end

{{out|output|text=&nbsp; (which happens to reflect the program's author's particular screen size for the "DOS" window):}}

<pre>

{{works with|Ruby|2.0+}}

module FakeImgLib

handle = FakeImgLib.openimage("path/to/image")

The next script tries to use ImageMagick. First, it tries [https://rmagick.github.io/ rmagick] from RubyGems. If that library is missing, it tries to use [http://wiki.github.com/ffi/ffi ffi] from RubyGems to call C functions in ImageMagick. (FFI is an alternative to Fiddle). If that doesn't work, it falls back to code that only handles PNG images.

{{libheader|RubyGems}}

{{works with|Ruby|1.9+}}

# Example:

# $ ruby imsize.rb dwarf-vs-elf.png swedish-chef.jpg

end

end

=={{header|Rust}}==

===Unix===

extern crate libc;

fn builtin_cos(x: c_double) -> c_double {

x.cos()

=={{header|Scala}}==

====Get free disk space====

{{libheader|net.java.dev.sna.SNA}}

import com.sun.jna.ptr.IntByReference

println(f"'$disk%s' ($ok%s): sectors/cluster: ${spc.getValue}%d, bytes/sector: ${bps.getValue}%d, " +

f" free-clusters: ${fc.getValue}%d, total/clusters: ${tc.getValue}%d%n")

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

The code tries to load the <tt>fakeimglib</tt> (cfr [[Call function in shared library#C|C example]]); if it succeed, the symbol <tt>openimage</tt> will exist, and will be called; otherwise, it is executed an "internal" code for <tt>openimage</tt>. In this example return code of the function of the library is ignored (<tt>ValueHolder null</tt>)

Object subclass: ExtLib [

].

=={{header|SNOBOL4}}==

{{works with|CSNOBOL4}}

This code loads the <tt>libm</tt> library into the variable <tt>ffi_m</tt> and binds the <tt>hypot()</tt> function to the variable <tt>ffi_m_hypot</tt>. (The variable names are arbitrary.) It then declares a SNOBOL4 function called <tt>hypot()</tt> which takes two <tt>double</tt>s as arguments and returns a <tt>double</tt>, binding this name to the <tt>ffi_m_hypot</tt> object returned earlier. It then outputs four hypotenuse calculations using those values.

ffi_m = FFI_DLOPEN('/usr/lib/x86_64-linux-gnu/libm.so')

OUTPUT = hypot(4,5)

Execution looks like this:

=={{header|Tcl}}==

{{libheader|Ffidl}}

if {[catch {

# Create the OpenImage command by other means here...

}

Note that if the library is appropriately set up with the correct entry function, it can be accessed directly with <code>load</code> which will cause it to register a Tcl command for the functionality it exports. [http://www.swig.org SWIG] can be used to automatically generate the interface code. Alternatively, [[:Category:Critcl|critcl]] can be used to allow writing glue [[C]] code directly embedded within a Tcl script.

and if found, it is used. If not, the user defined replacement

function is invoked.

#import flo

my_replacement = fleq/0.?/~& negative

=={{header|VBA}}==

First the DLL. Compile with '''ifort /dll vbafun.f90'''. The DLL must be in a directory in the PATH environment variable. Notice that for 32 bits VBA, DLL functions must be STDCALL, and not CDECL (the default with Intel Fortran). In 64 bits, there is only one calling convention, so it's not a problem anymore.

implicit none

!DEC$ ATTRIBUTES DLLEXPORT, STDCALL, REFERENCE :: ffun

double precision :: x, y, ffun

ffun = x + y * y

Here is a VBA subroutine using the DLL

Declare Function ffun Lib "vbafun" (ByRef x As Double, ByRef y As Double) As Double

Sub Test()

y = 10#

Debug.Print ffun(x, y)

=={{header|Wren}}==

{{trans|C}}

An embedded program so we can ask the C host to call the shared library function for us.

var RTLD_LAZY = 1

var imghandle = (imglib != null) ? imglib.call("openimage", file) : My.openimage(file)

System.print("opened with handle %(imghandle)")

<br>

We also need to create the shared library, fakeimglib.so, and place it in the current directory.

gcc -c -fpic fakeimglib.c

gcc -shared fakeimglib.o -o fakeimglib.so

fprintf(stderr, "opening %s\n", s);

return handle++;

<br>

Finally, we embed the Wren script in the following C program, compile and run it:

#include <stdio.h>

free(script);

return 0;

{{out}}

=={{header|X86-64 Assembly}}==

===UASM 2.52===

option casemap:none

ret

end

It's worth pointing out that under linux, dlopen CAN return NULL WITHOUT it being an error. One SHOULD call dlerror() to check for actual errors.

{{out}}

=={{header|zkl}}==

In zkl, extensions/new objects are written in C as shared libraries. For example, big nums are implemented as a small glue library in front of GMP:

and it "just works" as all objects are "the same" whether statically or dynamically linked.