From Bohemia Interactive Community
Jump to: navigation, search
Introduced with Arma 2: Operation Arrowhead version 1.60

Click on the images for descriptions

Introduced in

Arma 2: Operation Arrowhead


Calls custom .dll also known as Extension. The name of the extension is the name of the extension .dll without ".dll" part (or without "_x64.dll" part on 64-bit Arma). For example if the file is 'myExtension.dll' the name of the extension will be "myExtension". For 64-bit extensions, the name of the extension doesn't need to change and is still "myExtension". The game will automatically look for 'myExtension_x64.dll' when you use 64-bit Arma exe.

This command is blocking, meaning that the game will wait for the extension to return before continuing. This may cause FPS drop if extension is not optimised. If extension takes too long, consider making asynchronous extension, where the result of the work of the extension is collected in a separate call.

Currently there is no limit how much data you can send to the extension. However there is a limit on how much data you can return from extension in one call. The limit is known to the extension and is passed in int outputSize. The limit may or may not change in the future and is currently 10240 bytes. It is up to extension designer to handle multipart results if returned data exceeds output limit.

Since Arma 3 v1.67 it is possible to pass array of arguments to extensions. The array of arguments could be anything and all elements will be converted to strings, however you might want to only send simple types like Booleans, Strings, Numbers and Arrays of all of the above. There is currently a limit on how many arguments can be sent and it is 1024. However an argument could be an Array itself, in this case extension maker will have to provide additional methods for parsing such arguments.

Possible error codes:
Each error will have entry in .rpt file with more details.

For more information see Extensions.


extension callExtension function
extension: String - extension name
function: String - data sent to the extension
Return Value:
String - data sent back from extension

Alternative Syntax

extension callExtension [function, arguments]         (Since Arma 3 v1.67)
extension: String - extension name
[function, arguments]: Array - callExtension params
function: String - extension function identifier
arguments: Array - function arguments. Could be array of Anything, each element will be converted to String automatically. Current allowed max length of this array is 1024
Return Value:
Array - in format [result, returnCode, errorCode], where:
  • result: String - data sent back from extension. It is up to extension maker what it is.
  • returnCode: Number - integer return from extension method. It is up to extension maker to define it.
  • errorCode: Number - error code in case of command error (see description). 0 means no errors.


Example 1:
_return = "myExtension" callExtension "stringToBeParsed";
Example 2:
_result = "test_extension" callExtension str weapons player; _result = "test_extension" callExtension ["fnc1", getUnitLoadout player]; _result = "test_extension" callExtension ["fnc2", magazinesAmmoFull player]; _result = "test_extension" callExtension ["fnc1", [weapons player, magazines player]];
Example 3:
_result = "test_extension" callExtension ["fnc1", [1,"two",true,[4,"five",false]]]; parseSimpleArray (_result select 0) params ["_number","_string","_boolean","_array"]; systemChat str [_number,_string,_boolean,_array];
Source Code (Download .dll)

This is an example of an extension compatible with both syntaxes. When using 1st syntax, the data is just copied from input to output. When using alt syntax, the arguments are parsed and then assembled back into string array in 2 ways: fnc1 and fnc2. fnc1 is a fraction faster.
#include <string>
#include <vector>
#include <iterator>
#include <sstream>
extern "C"
	//--- STRING callExtension STRING
	__declspec (dllexport) void __stdcall RVExtension(char *output, int outputSize, const char *function);
	//--- STRING callExtension ARRAY
	__declspec (dllexport) int __stdcall RVExtensionArgs(char *output, int outputSize, const char *function, const char **args, int argsCnt);
//--- name callExtension function
void __stdcall RVExtension(char *output, int outputSize, const char *function)
	std::string str = function;
	strncpy_s(output, outputSize, ("Input Was: " + str).c_str(), _TRUNCATE);
//--- name callExtension [function, args]
int __stdcall RVExtensionArgs(char *output, int outputSize, const char *function, const char **args, int argsCnt)
	if (strcmp(function, "fnc1") == 0)
		//--- Manually assemble output array
		int i = 0;
		std::string str = "[";
		//--- Each argument can be accessed via args[n]
		if (argsCnt > 0)
			str += args[i++];
		while (i < argsCnt)
			str += ",";
			str += args[i++];
		str += "]";
		//--- Extension result
		strncpy_s(output, outputSize, str.c_str(), _TRUNCATE);
		//--- Extension return code
		return 100;
	else if (strcmp(function, "fnc2") == 0)
		//--- Parse args into vector
		std::vector<std::string> vec(args, std::next(args, argsCnt));
		std::ostringstream oss;
		if (!vec.empty())
			//--- Assemble output array
			std::copy(vec.begin(), vec.end() - 1, std::ostream_iterator<std::string>(oss, ","));
			oss << vec.back();
		//--- Extension result
		strncpy_s(output, outputSize, ("[" + oss.str() + "]").c_str(), _TRUNCATE);
		//--- Extension return code
		return 200;
		strncpy_s(output, outputSize, "Avaliable Functions: fnc1, fnc2", outputSize - 1);
		return -1;

Additional Information

See also:


Only post proven facts here. Report bugs on the feedback tracker. Use the talk page or the forums for discussions.
Add New Note | How To


Bottom Section