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;

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

end if;

end Shared_Library_Call;</syntaxhighlight>

=={{header|Arturo}}==

try? [

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

<pre>curl version: libcurl/7.64.1 SecureTransport (LibreSSL/2.8.3) zlib/1.2.11 nghttp2/1.41.0 </pre>

=={{header|AutoHotkey}}==

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

dllhost.ahk

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

, "", "str", "parameter1 parameter2", "Cdecl Int")</syntaxhighlight>

dllclient.ahk

=={{header|BaCon}}==

PROTO j0

bessel0 = j0(1.0)

prompt$ ./calllib

0.765198</pre>

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

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

</syntaxhighlight>

=={{header|C}}==

{{works with|POSIX|.1-2001}}

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

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

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

int openimage(const char *s)

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

opened with handle 0</pre>

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

In Windows.

class Program {

}

}</syntaxhighlight>

=={{header|COBOL}}==

Tested with GnuCOBOL, GNU/Linux.

program-id. callsym.

<pre>prompt$ cobc -xj callsym.cob

Success</pre>

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

{{libheader|CFFI}}

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

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

:pointer)

#.(SB-SYS:INT-SAP #X00650FD0)</syntaxhighlight>

=={{header|Crystal}}==

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

puts "the sqrt of 4 is #{sqrtproc.call(4.0)}"</syntaxhighlight>

=={{header|D}}==

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

<pre>500</pre>

=={{header|Dart}}==

add.c

int add(int num1, int num2) {

return num1 + num2;

Dart code

show DynamicLibrary, NativeFunction, Int32;

}

</syntaxhighlight>

=={{header|Delphi}}==

Loads library on startup.

Loads library on first call to DoSomething.

Loads and unloads library on demand.

lLibraryHandle: THandle;

lDoSomething: procedure; stdcall;

end;

end;</syntaxhighlight>

=={{header|Forth}}==

===GNU Forth 0.7.9 on Linux===

Call tgamma() from limbm.so

c-library math

1.01e2 gamma fs. 9.33262154439442E157 ok

</pre>

=={{header|Fortran}}==

===GNU Fortran on Linux===

A simple "C" function add_n in add_n.c

double add_n(double* a, double* b)

{

File add_nf.f90

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

use, intrinsic :: iso_c_binding

File shared_lib_new_test.f90

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

!module dll_module

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

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

First the DLL:

implicit none

!GCC$ ATTRIBUTES DLLEXPORT, STDCALL :: FFUN

Main program:

use kernel32

use iso_c_binding

Interface module:

use iso_c_binding

implicit none

end interface

end module</syntaxhighlight>

=={{header|FreeBASIC}}==

' Attempt to call Beep function in Win32 API

Print "Press any key to quit"

Sleep</syntaxhighlight>

=={{header|Go}}==

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

}</syntaxhighlight>

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:

/*

Same as C entry.

</pre>

=={{header|Haskell}}==

{{libheader|unix}}

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

putStrLn msg

putStrLn $ rev "a man a plan a canal panama"</syntaxhighlight>

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

Example use:

hello

getstr@strdup ::] 'hello'

hello</syntaxhighlight>

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

}</syntaxhighlight>

#include <stdlib.h>

}</syntaxhighlight>

# Edit the next lines to match your JDK.

===JNA===

{{libheader|JNA}}

import com.sun.jna.Native;

}

}</syntaxhighlight>

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

load('byjsi.so');</syntaxhighlight>

For example, a COBOL library generated from

program-id. sample as "Jsi_Initbyjsi".

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,

ccall( (:clock, "libc"), Int32, ())</syntaxhighlight>

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)

}</syntaxhighlight>

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

Same as C entry

</pre>

=={{header|Lingo}}==

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

end if</syntaxhighlight>

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

print(retval) --> 6, 7 or 2</syntaxhighlight>

=={{header|Maple}}==

> cfloor( 2.3 );

2.</syntaxhighlight>

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

-> 4.</syntaxhighlight>

=={{header|Nim}}==

===Interacting with C code===

echo openimage("foo")

echo openimage("baz")</syntaxhighlight>

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

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

int openimage(const char *s)

===Interacting with Nim code===

echo openimage("foo")

echo openimage("baz")</syntaxhighlight>

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

var handle = 100

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"

dlclose xlib;

;;</syntaxhighlight>

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

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

(import (otus ffi))

Hello World!

</pre>

=={{header|OxygenBasic}}==

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

FreeLibrary user32

</syntaxhighlight>

=={{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",

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

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

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)

===64-bit version===

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

-> 6502688

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

-> 0</syntaxhighlight>

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

END IF

END FUNCTION</syntaxhighlight>

=={{header|PureBasic}}==

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

*MessageBox = GetFunction(0, "MessageBoxA")

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

endif</syntaxhighlight>

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

CloseLibrary(0)

EndIf</syntaxhighlight>

=={{header|Python}}==

=== ctypes ===

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

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

print user32_dll.GetDoubleClickTime()</syntaxhighlight>

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

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

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

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

17</syntaxhighlight>

=={{header|QB64}}==

Declare Dynamic Library "Kernel32"

Sub SetLastError (ByVal dwErr As Long)

SetLastError 20

Print GetLastError</syntaxhighlight>

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

.Call("my_lib_fun", arg1, arg2)</syntaxhighlight>

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

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') {*}

{{out}}

<pre>ID = 94722089782960</pre>

=={{header|REXX}}==

{{works with|Regina REXX}}

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

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

cols= 96

</pre>

=={{header|Ruby}}==

This script uses Fiddle from Ruby's standard library to open <code>fakeimglib.so</code> from the [[#C|C example]].

{{works with|Ruby|2.0+}}

module FakeImgLib

{{libheader|RubyGems}}

{{works with|Ruby|1.9+}}

# Example:

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

end

exit status</syntaxhighlight>

=={{header|Rust}}==

The standard library does not provide a way to load dynamic libraries. Without using third-party libraries, we must use the FFI to call the relevant C functions directly.

===Unix===

extern crate libc;

x.cos()

}</syntaxhighlight>

=={{header|Scala}}==

===Windows===

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

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

import com.sun.jna.ptr.IntByReference

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

}}</syntaxhighlight>

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

ExtLib openimage: 'test.png'.</syntaxhighlight>

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

5.

6.40312423743285</pre>

=={{header|Tcl}}==

{{libheader|Ffidl}}

if {[catch {

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

abs = math.|fabs my_replacement</syntaxhighlight>

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

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

Debug.Print ffun(x, y)

End Sub</syntaxhighlight>

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

<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

<br>

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

#include <stdio.h>

Same as C example depending on whether fakeimglib.so is present in the current directory or not.

</pre>

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

===UASM 2.52===

option casemap:none

--> Well this is a internal disappointment..

</pre>

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

BN(1)+2 //--> BN(3)</syntaxhighlight>

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