Native function calling (NFC)

V1 can call native functions of dynamic libraries (.dll, .so).

Load dynamic link library

// Load the libZ library and return module number
// Parameter true means, that libz is a native dynamic link library and no V1 module!
module = dl ("libz.so", true);
if (!module) {
  print ("Module not found.");
  exit ();
}

Call a function

// Call the function "zlibVersion" with no parameters and return const char* (string)
version = call (module, "zlibVersion", ":s");

Types and corresponding C datatypes:

src = "String to compress with ZLib native function.";

// Make enough destination buffer 
dst = ""; 
resize (dst, strlen (src));

// The length of the desination buffer as binary string
len = binformat (strlen (src));

// Call the native function which is defined as:
// int compress (void *dstBuf, int *dstLen, const char* srcBuf, int srcLen);
// dst and len are reference parameters and filled with binary data by native function.
ret = call (module, "compress", "rrsi:i", dst, len, src, strlen(src));
if (ret===0) {
  // Parse the binary length and truncate destination string
  len = binparse (len);
  resize (dst, len);

  print ("Compressed string: ", dst);
}

Example 2

// Show a multibyte message box on Windows by calling two native functions
hDLLUser32 = dl ("user32.dll", true);
hDLLKernel32 = dl ("kernel32.dll", true);

function MultiByteToWideChar (src) {
  global hDLLKernel32;
  dst = "";
  resize (dst, strlen(src)*2+2); // Make enough buffer for wide char string
  size = call (hDLLKernel32, "MultiByteToWideChar", "iisiri:i",  65001, 0, src, -1, dst, strlen(src)+1);
  if (size>0)
    resize (dst, size*2);  // Resize to correct length (byte aligned)
  return dst;
}

function MessageBox (text, topic="Info") {
    global hDLLUser32;
    call (hDLLUser32, "MessageBoxW", "pssi:i", null, MultiByteToWideChar(text), MultiByteToWideChar (topic), 0|0x00000030);
}

if (hDLLKernel32) {
    MessageBox ("специальный символ");
}

Working with callbacks

There are 11 callback functions, which can be referenced by dlsym() to get the pointer address for a native function.

/* 
 This function is called from a native function as a callback with one argument.
 The pointer address of the callback function is given to a native function with dl (null, "callbackXX");
 Note:
 All arguments are V1 unsigned numbers which can be interpreted as C types void* or unsigned int with length of _ALIGN. 
 You have to cast the V1 number according different C types in the callback function.
 The return type is always C type int.
*/

function callbackA1 (arg1) {
  // Cast the argument to const char*
  s = memat (arg1);
  print (s);

  // Cast the argument to int (signed)
  i = binparse (binformat (arg1), 7, 0, 1);  
  print (i);

  // Cast the argument to float
  d = binparse (binformat (arg1), 5);  
  print (d);

  return 0;
}

// Give a native function the callback pointer
call (hDLL, "nativeFunction", [["p", "s"], "i"], dlsym (null, "callbackA1"), "Argument");

// Following callback functions are possible to call with __cdecl calling convention
function callbackA1 (arg1) {
}

function callbackA2 (arg1, arg2) {
}

function callbackA3 (arg1, arg2, arg3) {
}

function callbackA4 (arg1, arg2, arg3, arg4) {
}

function callbackB1 (arg1) {
}

function callbackB2 (arg1, arg2) {
}

function callbackB3 (arg1, arg2, arg3) {
}

function callbackB4 (arg1, arg2, arg3, arg4) {
}

// Following callback functions are possible to call with __stdcall calling convention 
// __stdcall will be used only by WIN32 Callback functions, thats why the 
// following callback functions are not available on Linux

function std_callbackA2 (arg1, arg2) {
}

function std_callbackA3 (arg1, arg2, arg3) {
}

function std_callbackA4 (arg1, arg2, arg3, arg4) {
}

See also: Binary functions and example X11 Window.

back to Home