Call a function in a shared library: Difference between revisions

{{task|Programming environment operations}}

Show how to call a function in a shared library (without dynamically linking to it at compile-time). In particular, show how to call the shared library function if the library is available, otherwise use an internal equivalent function.

 

 

 

* [[OpenGL]] -- OpenGL is usually maintained as a shared library.

<br><br>

=={{header|Ada}}==

===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;

-- There are ready to use Win32 bindings. We don't want to use them here.

--

function LoadLibrary (lpFileName : char_array) return HANDLE;

pragma Import (stdcall, LoadLibrary, "LoadLibrary", "_LoadLibraryA"); -- Ada95 does not have the @n suffix.

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|AutoHotkey}}==

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

dllhost.ahk

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

dllclient.ahk

 

PROTO j0

bessel0 = j0(1.0)

PRINT bessel0

 

{{out}}

0.765198</pre>

 

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

<pre>internal openimage opens fake.img...

opened with handle 0</pre>

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

In Windows.

 

class Program {

int r = fakefunction(10);

}

=={{header|COBOL}}==

Tested with GnuCOBOL, GNU/Linux.

 

program-id. callsym.

 

 

goback.

 

{{out}}

<pre>prompt$ cobc -xj callsym.cob

Success</pre>

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

 

{{libheader|CFFI}}

 

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

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

#-sbcl ":0.0"

:pointer)

 

=={{header|D}}==

 

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

void main() {

writeln(GetDoubleClickTime());

 

<pre>500</pre>

=={{header|Dart}}==

 

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|Fortran}}==

===GNU Fortran on Linux===

 

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}}

Same as C entry.

</pre>

=={{header|Haskell}}==

 

{{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}}==

For methods with the <tt>native</tt> keyword, the library must be written to the [[wp:Java Native Interface|Java Native Interface]]; this is not a general [[FFI]]. If the library is missing, <code>System.loadLibrary()</code> throws <code>UnsatisfiedLinkError</code>. We can continue if we catch this error and then don't call the library's native methods.

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}}==

Jsish includes a '''load('library.so');''' function, which calls a specially crafted management function in the library,

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}}

Called again with: 0x00000000013a9260, +0000000002

prompt$</pre>

=={{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]

=={{header|Kotlin}}==

{{trans|C}}

 

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}}

Same as C entry

</pre>

=={{header|Lingo}}==

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

 

crc = crcObj.crc32(str)

 

=={{header|Maple}}==

> cfloor( 2.3 );

 

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

opening baz

102</pre>

=={{header|OCaml}}==

As far as I know there is no solution in OCaml standard library to load a function from a C library dynamically. So I have quickly implemented [[Call a function in a shared library/OCaml|a module named Dlffi that you can find in this sub-page]]. It is basically a wrapper around the GNU/Linux dl* functions and the libffi.

 

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}}==

(import (otus ffi))

 

(define self (load-dynamic-library #f))

 

 

(print (strdup "Hello World!"))

{{Out}}

<pre>

Hello World!

</pre>

=={{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.

=={{header|Pascal}}==

See [[Call_a_function_in_a_shared_library#Delphi | Delphi]]

=={{header|Perl}}==

Examples for simple <code>C</code> library calls, but each module is capable of much more (and can work with other languages). Refer to their documentation for details.

===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}}==

{{out}}

<pre>

97 -- (or {{97}} if func not found)

</pre>

=={{header|PicoLisp}}==

This differs between the 32-bit and 64-bit versions. While the 64-bit version

===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|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)

6.48074069840786</pre>

=={{header|Raku}}==

(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>

=={{header|REXX}}==

{{works with|Regina REXX}}

 

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

 

rca= rxFuncAdd('sysLoadFuncs', "regUtil", 'sysLoadFuncs') /*add a function library. */

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

end

/* [↓] call a function. */

$= sysTextScreenSize() /*$ has 2 words: rows cols */

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>

rows= 62

cols= 96

</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}}==

===Windows===

====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|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.

 

With this many ways to perform the call, the best approach often depends on the size and complexity of the API being mapped. SWIG excels at large APIs, Ffidl is better when you just want to call a particular simple function, and critcl handles complex cases (callbacks, etc.) better than the other two.

=={{header|TXR}}==

 

 

The <code>nil</code> argument in the <code>with-dyn-lib</code> macro causes the underlying implementation to call <code>dlopen(NULL)</code> to get access to the dynamic symbols available in the executable. We can use the name of a shared library instead, or a handle from TXR's <code>dlopen</code> library function.

=={{header|Ursala}}==

When abs(x) is evaluated, a run time check is performed for the

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

function is invoked.

#import flo

 

my_replacement = fleq/0.?/~& negative

 

=={{header|VBA}}==

Here is an example using a Fortran function compiled as a DLL, using Intel Fortran.

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|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.

{{omit from|Batch File|Except for rundll32.exe (which is rather limited) there is no way of calling an external function}}

{{omit from|GUISS}}

{{omit from|M4}}

{{omit from|Maxima}}

{{omit from|ML/I}}

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

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