SEGFAULT For External Function Block

[PBaswat]

Hi,
I am trying to call functional block (which is declared as external) (exterFBTest.ST) from ST program(inProgram.ST), and external function block implemented in c++.
but when trying to run the executable, I am getting segmentation fault.
inProgram.ST

{external}
FUNCTION printf : DINT
VAR_INPUT {ref}
    format : STRING;
END_VAR
VAR_INPUT
    args: ...;
END_VAR
END_FUNCTION

program inProgram
   var
      inputvar1 : DINT := 100;
      inputvar2 : DINT := 200;
      outputVAR : DINT := 0;
   end_var
   var
      testFB : exterFBTest;
   end_var
   printf('Inside ST inProgram : -------------------Start Test------------------- $N');	
   testFB(inputVAR1 := inputvar1);
   outputVAR := testFB.outputVAR;
   printf('Inside ST inProgram : outputVAR: %d$N', outputVAR);
   printf('Inside ST inProgram : -------------------End Test------------------- $N');
end_program

exterFBTest.ST

{external}
FUNCTION_BLOCK exterFBTest
VAR_INPUT
      inputVAR1 : DINT;
      inputVAR2 : DINT;
END_VAR

VAR_OUTPUT
      outputVAR : DINT;
END_VAR
END_FUNCTION_BLOCK

exterFBTest.cpp

#include <iostream>

typedef int dint;

extern "C" void exterFBTest(dint inputvar1, dint inputvar2, dint &outputvar)
{
	printf("In C++ : inputvar1 : %d, inputvar2 : %d \n", inputvar1, inputvar2);
	outputvar = (inputvar1 * inputvar2);
}

main.cpp

#include <iostream>
#include <string> 

using namespace std;

extern "C" {
	// Declare a struct for the function block
	typedef struct {
		bool ci;
		int printer;
		char in[50];
	} PRINT_STRING;
	// Declare a struct for the program
	typedef struct {
		PRINT_STRING printstr;
	} inProgram_struct; 

	// Declare the instance of the program as external
	extern inProgram_struct inProgram_instance;


	// Declare the external "public" method by using the program call signature
	void inProgram(inProgram_struct*);

}

int main(int argc, char * argv[]){
	inProgram(&inProgram_instance);	
	return 0;
}

build.sh

#!/usr/bin/env bash
rm -rf *.o Test libst.so
#export PATH=/build/target/debug/:$PATH
#/bin/cp -afr /build/target/debug/libiec61131std.* /usr/lib/

plc -c exterFBTest.ST\
	   inProgram.ST \
	   -o libst.so --pic

clang++-14 -c -g exterFBTest.cpp -o exterFBTest.o
clang++-14 -c -g main.cpp -o main.o
clang++-14 main.o exterFBTest.o -o Test -L. -lst

Output

Inside ST inProgram : -------------------Start Test-------------------
In C++ : inputvar1 : 2003408396, inputvar2 : -1271775568
Segmentation fault

Is rusty supports external function block??
if yes, then how we can implement such external function block functionality in rusty? (as rusty supports external functions implementation, shown in below url).
https://github.com/PLC-lang/rusty/blob/master/examples/ExternalFunctions.st

Thank You

[ghaith]

Hello,
this has to do with the representation of function block in memory.
Function blocks are not traditional functions, they are defined as a struct with all the INPUT/OUTPUT and IN_OUT parameters as members.
INPUT {ref} and IN_OUT parameters are pointers in the struct.
The implementation of the function block then has a single parameter, the pointer to the type defined.
In your example :

{external}
FUNCTION_BLOCK exterFBTest
VAR_INPUT
      inputVAR1 : DINT;
      inputVAR2 : DINT;
END_VAR

VAR_OUTPUT
      outputVAR : DINT;
END_VAR
END_FUNCTION_BLOCK

I would define the function block on the C++ side as follows:

#include <iostream>

typedef int dint;

typedef struct externFBTest_type {
  dint inputvar1;
  dint inputvar2;
  dint outputvar;
}

extern "C" void exterFBTest(externFBTest_type* self)
{
	printf("In C++ : inputvar1 : %d, inputvar2 : %d \n", self->inputvar1, self->inputvar2);
	self->outputvar = (inputvar1 * inputvar2);
}