Arrays & Structures Comparison Compilation Issue

[PBaswat]

Hi,
We are doing array and structure comparison in our project.
While compiling statements such as array and struct comparison, rusty gives compilation error.

Sample code is as below:

Array_type.ST:

TYPE Array_type :
	array [0..5] of dint;
END_TYPE

Structure_type.ST:

TYPE Structure_type :
	struct
	      dint_data  : dint; 
	      bool_data : bool;
	      dword_data : dword;
	      Array_Data : Array_type;
       end_struct
END_TYPE

main.cpp:

#include <iostream>
using namespace std;
 
extern "C" {
	typedef struct {
		int temp;
	} myprogram_struct;
 
	// Declare the instance of the program as external
	extern myprogram_struct myprogram_instance;
	// Declare the external "public" method by using the program call signature
	void myprogram(myprogram_struct*);
 
}
 
 
int main(int argc, char * argv[]){
	myprogram(&myprogram_instance);
	return 0;
}

myprogram.st:

program myprogram 
	var
		Array1 : Array_type;
		Array2 : Array_type;
		bArrayCompResult : bool := false ;
		Struct1 : Structure_type;
		Struct2 : Structure_type;
		bStructCompResult : bool := false ;
		bOutput : bool := true;
	end_var
   (* Filling Struct1 with some data *)
	Struct1.dint_data := 1;
	Struct1.bool_data  := false;
	Struct1.dword_data := 34;
	Struct1.Array_Data[0] := 0;
	Struct1.Array_Data[1] := 1;
	Struct1.Array_Data[2] := 2;
	Struct1.Array_Data[3] := 3;
	Struct1.Array_Data[4] := 4;
	(* Filling Struct2 with same data as Struct1 *)
	Struct2.dint_data := 1;
	Struct2.bool_data  := false;
	Struct2.dword_data := 34;
	Struct2.Array_Data[0] := 0;
	Struct2.Array_Data[1] := 1;
	Struct2.Array_Data[2] := 2;
	Struct2.Array_Data[3] := 3;
	Struct2.Array_Data[4] := 4;
	(*Comparing Struct1 and Struct2 and both should be equal*)
	bStructCompResult := (Struct1 = Struct2);
	if  bStructCompResult <> true then 
		bOutput := false;
	end_if;
	(*Changing data of Struct2*)
	Struct2.Array_Data[2] := 0;
	(*Comparing Struct1 and Struct2 and both should not be equal*)
	bStructCompResult := (Struct1 = Struct2);
	if  bStructCompResult <> false then 
		bOutput := false;
	end_if;
	(* Filling Array1 with some data *)
	Array1[0] := 10 ;
	Array1[1] := 11 ;
	Array1[2] := 12 ;
	Array1[3] := 13 ;
	Array1[4] := 14 ;
    (* Filling Array2 with same data as Array1 *)
	Array2[0] := 10 ;
	Array2[1] := 11 ;
	Array2[2] := 12 ;
	Array2[3] := 13 ;
	Array2[4] := 14 ;
	(*Comparing Array1 and Array2 and both should be equal*)
	bArrayCompResult := (Array1 = Array2);
	if  bArrayCompResult <> true then 
		bOutput := false;
	end_if;
	(*Changing data of Array2*)
	Array2[2] := 45 ;	
	(*Comparing Array1 and Array2 and both should not be equal*)
	bArrayCompResult := (Array1 = Array2);
    if  bArrayCompResult <> false then 
		bOutput := false;
    end_if;
end_program

Compilation command:

plc Structure_type.ST myprogram.st Array_type.ST --linker=clang -o Test

Compilation Error:

error: Missing compare function 'FUNCTION Structure_type_EQUAL : BOOL VAR_INPUT                   a,b : Structure_type; END_VAR ...'.
   ┌─ myprogram.st:33:24
   │
33 │   bStructCompResult := (Struct1 = Struct2);
   │                         ^^^^^^^^^^^^^^^^^ Missing compare function 'FUNCTIO                  N Structure_type_EQUAL : BOOL VAR_INPUT a,b : Structure_type; END_VAR ...'.
 
error: Missing compare function 'FUNCTION Structure_type_EQUAL : BOOL VAR_INPUT                   a,b : Structure_type; END_VAR ...'.
   ┌─ myprogram.st:42:24
   │
42 │   bStructCompResult := (Struct1 = Struct2);
   │                         ^^^^^^^^^^^^^^^^^ Missing compare function 'FUNCTIO                  N Structure_type_EQUAL : BOOL VAR_INPUT a,b : Structure_type; END_VAR ...'.
 
error: Missing compare function 'FUNCTION Array_type_EQUAL : BOOL VAR_INPUT a,b                   : Array_type; END_VAR ...'.
   ┌─ myprogram.st:62:23
   │
62 │   bArrayCompResult := (Array1 = Array2);
   │                        ^^^^^^^^^^^^^^^ Missing compare function 'FUNCTION A                  rray_type_EQUAL : BOOL VAR_INPUT a,b : Array_type; END_VAR ...'.
 
error: Missing compare function 'FUNCTION Array_type_EQUAL : BOOL VAR_INPUT a,b                   : Array_type; END_VAR ...'.
   ┌─ myprogram.st:71:23
   │
71 │   bArrayCompResult := (Array1 = Array2);
   │                        ^^^^^^^^^^^^^^^ Missing compare function 'FUNCTION A                  rray_type_EQUAL : BOOL VAR_INPUT a,b : Array_type; END_VAR ...'.
 
error: cannot generate call statement for "ReferenceExpr { kind: Member(Identifi                  er { name: \"Structure_type_EQUAL\" }), base: None }"
   ┌─ myprogram.st:33:24
   │
33 │   bStructCompResult := (Struct1 = Struct2);
   │                         ^^^^^^^^^^^^^^^^^ cannot generate call statement fo                  r "ReferenceExpr { kind: Member(Identifier { name: \"Structure_type_EQUAL\" }),                   base: None }"
 
Codegen Error: Compilation aborted due to previous errors

First we need to know, whether array or structure comparison can be achieved, using rusty compiler?
how to do array or structure comparision.
Note : All our array and structure types are statically compiled.

[mhasel]

@ghaith maybe you can chime in on this/correct me if I'm wrong, but afaik equality operators are only implemented for ANY_ELEMENTARY datatypes according to the standard. Structs and arrays are derived data types, so they do not have an implementation for direct comparison. You can, however, implement your own with the provided name. Alternatively, you can compare each field/value individually as you would in a language like C.

[ghaith]

I tried to look for the part in the standard today and I saw that the = operator is actually not limited to elementary types.
In which case we would need to provide a default implementation.
We could offer one for types where we do a byte comparison, would not be efficient but it would work.
(https://cplusplus.com/reference/cstring/memcmp/)
I suggest we do it as a fallback if the user does not have an own equality function for the datatype.

[mhasel]

Table 33 in the standard outlines the comparison operators and functions, and there it states the data-types to be of ANY_ELEMENTARY. Maybe there is another section in the standard that contradicts this.

Direct byte-comparison (like C's memcmp function) might be problematic when there are floating point values involved, as they can be NaN, which are pretty much always going to fail a byte-comparison, even if both sides are NaN.

We could also try to lend from Go's deepEqual check, see here:
deepEqual

[ghaith]

I was looking at table 71 which specifies it for ST and there they don't mention the ANY_ELEMENTARY. Also section 7.3.3.2.2 Comparison which says variables can be single and multiple elements.
7.3.3.2.2 also mentions that for multi-value variables the inner values should be compared. So this is the deep equal from go.
We could maybe generate this per function for structs.

Comparing arrays this way will always be inefficient since you now need to loop on each element and and compare individually. I think defaulting to memcmp on primitive arrays or when we know we can (type does not have floats anywhere) would be better. But I say we should at least offer a method.

For the record I just tried this with our older compiler (A Codesys 2.x based compiler) and it does not allow it:

Implementation of POU 'PLC_PRG'
line: 30 /ArrComp/PLC_PRG.st (30) : Type mismatch in parameter 1 of ''='': Cannot convert 'Structure_type' to 'ANY_NUM'.
line: 30 /ArrComp/PLC_PRG.st (30) : Type mismatch in parameter 2 of ''='': Cannot convert 'Structure_type' to 'ANY_NUM'.
line: 37 /ArrComp/PLC_PRG.st (37) : Type mismatch in parameter 1 of ''='': Cannot convert 'Structure_type' to 'ANY_NUM'.
line: 37 /ArrComp/PLC_PRG.st (37) : Type mismatch in parameter 2 of ''='': Cannot convert 'Structure_type' to 'ANY_NUM'.
line: 54 /ArrComp/PLC_PRG.st (54) : Type mismatch in parameter 1 of ''='': Cannot convert 'ARRAY [0..5] OF DINT' to 'ANY_NUM'.
line: 54 /ArrComp/PLC_PRG.st (54) : Type mismatch in parameter 2 of ''='': Cannot convert 'ARRAY [0..5] OF DINT' to 'ANY_NUM'.
line: 61 /ArrComp/PLC_PRG.st (61) : Type mismatch in parameter 1 of ''='': Cannot convert 'ARRAY [0..5] OF DINT' to 'ANY_NUM'.
line: 61 /ArrComp/PLC_PRG.st (61) : Type mismatch in parameter 2 of ''='': Cannot convert 'ARRAY [0..5] OF DINT' to 'ANY_NUM'.
Implementation of task 'DefaultTas'
Initialisation code for POU 'Structure_type'
Check of the parameter configuration
Hardware-Configuration
8 Error(s), 0 Warning(s).
52370: send done: finished; 8 00-00-08
*************************************************************************
16:54:43.782819 - ArrComp - Build finished in 0 seconds
*************************************************************************

[mhasel]

Thank you for clarifying, good find! After looking at the sections you mentioned I agree, we should support this, even if our old compiler didn't

[PBaswat]

Hi,
wishing you all happy new year, it's been very active supports I received from your side in 2023 year.
Hoping similar kind of support this current year also.
Need to know whether fix against derived data type comparison is merged to latest release?, can I download latest release and check whether array and structures comparison supported?

[ghaith]

Hello @PBaswat
Thank you and wish you a happy new year as well.
We unfortunately did not get into looking at those kind of comparisons. I will open a feature request to track it better.
For context, making a default struct comparison function is not a trivial task, and often also not something the user wants of a language. The difficulty is to decide what fields in a struct are relevant for a comparison, this is why in other languages you see the struct comparison always implemented by the user and not offered by the language. So for structs there is already a solution in place that we can't make better imho which is that the user implements a comparision function for the struct. If we provide a default one based on memcmp in the standard functions we will bind it with a warning. But I think at least for structs and array types that are declared in Datatypes the solution is implement the function yourself, this is what the error suggests
:

error: Missing compare function 'FUNCTION Structure_type_EQUAL : BOOL VAR_INPUT a,b : Structure_type; END_VAR ...'.
   ┌─ myprogram.st:42:24
   │
42 │   bStructCompResult := (Struct1 = Struct2);
   │                         ^^^^^^^^^^^^^^^^^ Missing compare function 'FUNCTION Structure_type_EQUAL : BOOL VAR_INPUT a,b : Structure_type; END_VAR ...'.
 
error: Missing compare function 'FUNCTION Array_type_EQUAL : BOOL VAR_INPUT a,b : Array_type; END_VAR ...'.
   ┌─ myprogram.st:62:23
   │
62 │   bArrayCompResult := (Array1 = Array2);
   │                        ^^^^^^^^^^^^^^^ Missing compare function 'FUNCTION Array_type_EQUAL : BOOL VAR_INPUT a,b : Array_type; END_VAR ...'.
 

For arrays that are not declared in types we would have to provide a method that either calls memcmp which is problematic, or a deep equals method which is slow. Maybe we could also just give that to the user as int ARRAY_EQUALS function to implement and they can decide if they want deep equals or not depending on the datatype they have.

[ghaith]

I opened an issue but the case you discribed might be solvable without the issue if you create the functions in question:

FUNCTION Structure_type_EQUAL : BOOL 
VAR_INPUT a,b : Structure_type; END_VAR
  Structure_type_EQUAL := a.dint_data  = b.dint_data;
  Structure_type_EQUAL := Structure_type_EQUAL AND a.bool_data  = b.bool_data;
  Structure_type_EQUAL := Structure_type_EQUAL AND a.dword_data  = b.dword_data;
  Structure_type_EQUAL := Structure_type_EQUAL AND a.Array_Data  = b.Array_Data;
END_FUNCTION

FUNCTION Array_type_EQUAL : BOOL 
VAR_INPUT a,b : Array_type; END_VAR 
VAR i : DINT;
ARRAY_type_EQUAL := TRUE;
FOR i in 0 to 5 DO
  ARRAY_type_EQUAL := ARRAY_type_EQUAL AND a[i] = b[i];
  IF NOT ARRAY_type_EQUAL THEN RETURN; END_IF
END_FOR
END_FUNCTION