Merge fixes from Freeze back to develop

src/core/datatypes/convert/StringToConvertFunctions.h

@@ -96,6 +96,10 @@ inline const CIEC_LREAL func_STRING_AS_LREAL(const CIEC_STRING &paVal){
   return func_STRING_AS_X_helper<CIEC_LREAL>(paVal);
 }
 
+inline const CIEC_CHAR func_STRING_TO_CHAR(const CIEC_STRING &paVal){
+  return paVal.length() > 0 ? paVal[1] : 0_CHAR;
+}
+
 #ifdef FORTE_USE_WSTRING_DATATYPE
 inline const CIEC_WSTRING func_STRING_TO_WSTRING(const CIEC_STRING &paVal){
   return func_STRING_AS_X_helper<CIEC_WSTRING>(paVal);

src/core/datatypes/forte_any_bit_partial.h

@@ -31,9 +31,13 @@ class CIEC_ANY_BIT_PARTIAL final : public PartialType {
     using PartialType::operator=;
 
     CIEC_ANY_BIT_PARTIAL(SourceType &paValue, const size_t paIndex) : mOriginalValue(paValue), mIndex(paIndex)  {
+      *this = partialValue(paValue, paIndex);
+    }
+
+    static PartialType partialValue(const SourceType &paValue, const size_t paIndex) {
       PartialValueType partialValue = 0;
       if(paIndex <= scmMaxIndex) {
-        const auto shiftIndex = mIndex * scmPartialDigits;
+        const auto shiftIndex = paIndex * scmPartialDigits;
         const SourceValueType sourceValue = static_cast<SourceValueType>(paValue);
         if constexpr(std::is_same_v<CIEC_BOOL, PartialType>) {
           partialValue = static_cast<PartialValueType>((sourceValue >> shiftIndex) & 0x1);
@@ -43,7 +47,7 @@ class CIEC_ANY_BIT_PARTIAL final : public PartialType {
       } else {
         DEVLOG_ERROR("Attempted partial index %d outside the range of allowed indices %d\n", paIndex, scmMaxIndex);
       }
-      *this = PartialType(partialValue);
+      return PartialType(partialValue);
     }
 
     CIEC_ANY_BIT_PARTIAL& operator=(const CIEC_ANY_BIT_PARTIAL &paValue) {
@@ -55,8 +59,9 @@ class CIEC_ANY_BIT_PARTIAL final : public PartialType {
       if(mIndex <= scmMaxIndex) {
         constexpr SourceValueType maskTemplate = std::numeric_limits<PartialValueType>::max();
         const auto shiftIndex = mIndex * scmPartialDigits;
-        const SourceValueType mask = (maskTemplate << shiftIndex);
-        const SourceValueType partialPartValue = static_cast<SourceValueType>(static_cast<PartialValueType>(*this)) << shiftIndex;
+        const SourceValueType mask = static_cast<SourceValueType>(maskTemplate << shiftIndex);
+        const SourceValueType partialPartValue = static_cast<SourceValueType>(
+                static_cast<SourceValueType>(static_cast<PartialValueType>(*this)) << shiftIndex);
         const SourceValueType sourceValue = static_cast<SourceValueType>(mOriginalValue);
         SourceValueType mergedValue = sourceValue ^ ((sourceValue ^ partialPartValue) & mask);
         mOriginalValue = SourceType(mergedValue);

src/core/datatypes/forte_array.cpp

@@ -40,23 +40,6 @@ void CIEC_ARRAY::setValue(const CIEC_ANY &paValue) {
   }
 }
 
-bool CIEC_ARRAY::equals(const CIEC_ANY &paOther) const {
-  if (paOther.getDataTypeID() == CIEC_ANY::e_ARRAY) {
-    auto &otherArray = static_cast<const CIEC_ARRAY &>(paOther);
-    if (getLowerBound() != otherArray.getLowerBound() || getUpperBound() != otherArray.getUpperBound()) {
-      return false;
-    }
-
-    for (intmax_t i = getLowerBound(), end = getUpperBound(); i <= end; ++i) {
-      if (!operator[](i).equals(otherArray[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-
 int CIEC_ARRAY::toString(char *paValue, size_t paBufferSize) const {
   int nBytesUsed = -1;
 

src/core/datatypes/forte_array.h

@@ -27,7 +27,24 @@
 /** \brief A common supertype for all CIEC_ARRAY variants, providing the minimal interface an array must provide
  */
 class CIEC_ARRAY : public CIEC_ANY_DERIVED {
-public:
+    friend bool operator==(const CIEC_ARRAY &paLeft, const CIEC_ARRAY &paRight) {
+      if (paLeft.getLowerBound() != paRight.getLowerBound() || paLeft.getUpperBound() != paRight.getUpperBound()) {
+        return false;
+      }
+
+      for (intmax_t i = paLeft.getLowerBound(), end = paLeft.getUpperBound(); i <= end; ++i) {
+        if (!paLeft[i].equals(paRight[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    friend bool operator!=(const CIEC_ARRAY &paLeft, const CIEC_ARRAY &paRight) {
+      return !(paLeft == paRight);
+    }
+
+  public:
     using value_type = CIEC_ANY;
     using pointer = value_type *;
     using const_pointer = const value_type *;
@@ -93,7 +110,12 @@ class CIEC_ARRAY : public CIEC_ANY_DERIVED {
 
     void setValue(const CIEC_ANY &paValue) override;
 
-    [[nodiscard]] bool equals(const CIEC_ANY &paOther) const override;
+    [[nodiscard]] bool equals(const CIEC_ANY &paOther) const override {
+      if (paOther.getDataTypeID() == CIEC_ANY::e_ARRAY) {
+        return *this == static_cast<const CIEC_ARRAY &>(paOther);
+      }
+      return false;
+    }
 
     [[nodiscard]] int toString(char *paValue, size_t paBufferSize) const override;
 

src/core/datatypes/forte_array_common.h

@@ -29,7 +29,24 @@
  */
 template<typename T>
 class CIEC_ARRAY_COMMON : public CIEC_ARRAY {
-public:
+    friend bool operator==(const CIEC_ARRAY_COMMON &paLeft, const CIEC_ARRAY_COMMON &paRight) {
+      if (paLeft.getLowerBound() != paRight.getLowerBound() || paLeft.getUpperBound() != paRight.getUpperBound()) {
+        return false;
+      }
+
+      for (intmax_t i = paLeft.getLowerBound(), end = paLeft.getUpperBound(); i <= end; ++i) {
+        if (!func_EQ(paLeft[i], paRight[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    friend bool operator!=(const CIEC_ARRAY_COMMON &paLeft, const CIEC_ARRAY_COMMON &paRight) {
+      return !(paLeft == paRight);
+    }
+
+  public:
     using value_type = T;
     using pointer = value_type *;
     using const_pointer = const value_type *;

src/core/datatypes/forte_byte.h

@@ -96,13 +96,34 @@ class CIEC_BYTE : public CIEC_ANY_BIT{
     /*! \brief Partial access within a CIEC_BYTE (e.g. [BYTE].partial<CIEC_BOOL,1>())
      *
      */
-    template <class T> CIEC_ANY_BIT_PARTIAL<T, CIEC_BYTE> partial(size_t paIndex){
+    template<class T>
+    CIEC_ANY_BIT_PARTIAL<T, CIEC_BYTE> partial(size_t paIndex) {
       return CIEC_ANY_BIT_PARTIAL<T, CIEC_BYTE>(*this, paIndex);
     }
 
-    template <class T> CIEC_ANY_BIT_PARTIAL<T, CIEC_BYTE> partial(const CIEC_ANY_INT& paIndex){
-      size_t index = paIndex.getUnsignedValue();
-      return CIEC_ANY_BIT_PARTIAL<T, CIEC_BYTE>(*this, index);
+    template<class T>
+    T partial(size_t paIndex) const {
+      return CIEC_ANY_BIT_PARTIAL<T, CIEC_BYTE>::partialValue(*this, paIndex);
+    }
+
+    template<class T>
+    T cpartial(size_t paIndex) const {
+      return partial<T>(paIndex);
+    }
+
+    template<class T>
+    CIEC_ANY_BIT_PARTIAL<T, CIEC_BYTE> partial(const CIEC_ANY_INT &paIndex) {
+      return partial<T>(paIndex.getUnsignedValue());
+    }
+
+    template<class T>
+    T partial(const CIEC_ANY_INT &paIndex) const {
+      return partial<T>(paIndex.getUnsignedValue());
+    }
+
+    template<class T>
+    T cpartial(const CIEC_ANY_INT &paIndex) const {
+      return partial<T>(paIndex);
     }
 };
 

src/core/datatypes/forte_dword.h

@@ -120,13 +120,34 @@ class CIEC_DWORD : public CIEC_ANY_BIT {
     /*! \brief Partial access within a CIEC_DWORD (e.g. [DWORD].partial<CIEC_BOOL>(1))
      *
      */
-    template <class T> CIEC_ANY_BIT_PARTIAL<T, CIEC_DWORD> partial(size_t paIndex) {
+    template<class T>
+    CIEC_ANY_BIT_PARTIAL<T, CIEC_DWORD> partial(size_t paIndex) {
       return CIEC_ANY_BIT_PARTIAL<T, CIEC_DWORD>(*this, paIndex);
     }
 
-    template <class T> CIEC_ANY_BIT_PARTIAL<T, CIEC_DWORD> partial(const CIEC_ANY_INT& paIndex){
-      size_t index = paIndex.getUnsignedValue();
-      return CIEC_ANY_BIT_PARTIAL<T, CIEC_DWORD>(*this, index);
+    template<class T>
+    T partial(size_t paIndex) const {
+      return CIEC_ANY_BIT_PARTIAL<T, CIEC_DWORD>::partialValue(*this, paIndex);
+    }
+
+    template<class T>
+    T cpartial(size_t paIndex) const {
+      return partial<T>(paIndex);
+    }
+
+    template<class T>
+    CIEC_ANY_BIT_PARTIAL<T, CIEC_DWORD> partial(const CIEC_ANY_INT &paIndex) {
+      return partial<T>(paIndex.getUnsignedValue());
+    }
+
+    template<class T>
+    T partial(const CIEC_ANY_INT &paIndex) const {
+      return partial<T>(paIndex.getUnsignedValue());
+    }
+
+    template<class T>
+    T cpartial(const CIEC_ANY_INT &paIndex) const {
+      return partial<T>(paIndex);
     }
 };
 

src/core/datatypes/forte_lword.h

@@ -131,15 +131,35 @@ class CIEC_LWORD : public CIEC_ANY_BIT{
     /*! \brief Partial access within a CIEC_LWORD (e.g. [LWORD].partial<CIEC_BOOL>(1))
      *
      */
-    template <class T> CIEC_ANY_BIT_PARTIAL<T, CIEC_LWORD> partial(size_t paIndex){
+    template<class T>
+    CIEC_ANY_BIT_PARTIAL<T, CIEC_LWORD> partial(size_t paIndex) {
       return CIEC_ANY_BIT_PARTIAL<T, CIEC_LWORD>(*this, paIndex);
     }
 
-    template <class T> CIEC_ANY_BIT_PARTIAL<T, CIEC_LWORD> partial(const CIEC_ANY_INT& paIndex){
-      size_t index = paIndex.getUnsignedValue();
-      return CIEC_ANY_BIT_PARTIAL<T, CIEC_LWORD>(*this, index);
+    template<class T>
+    T partial(size_t paIndex) const {
+      return CIEC_ANY_BIT_PARTIAL<T, CIEC_LWORD>::partialValue(*this, paIndex);
     }
 
+    template<class T>
+    T cpartial(size_t paIndex) const {
+      return partial<T>(paIndex);
+    }
+
+    template<class T>
+    CIEC_ANY_BIT_PARTIAL<T, CIEC_LWORD> partial(const CIEC_ANY_INT &paIndex) {
+      return partial<T>(paIndex.getUnsignedValue());
+    }
+
+    template<class T>
+    T partial(const CIEC_ANY_INT &paIndex) const {
+      return partial<T>(paIndex.getUnsignedValue());
+    }
+
+    template<class T>
+    T cpartial(const CIEC_ANY_INT &paIndex) const {
+      return partial<T>(paIndex);
+    }
 };
 
 inline CIEC_LWORD operator ""_LWORD(unsigned long long int paValue) {

src/core/datatypes/forte_struct.h

@@ -20,6 +20,16 @@
 #include "forte_any_derived.h"
 
 class CIEC_STRUCT : public CIEC_ANY_DERIVED{
+    template <typename T, std::enable_if_t<std::is_base_of_v<CIEC_STRUCT, T>, int> = 0>
+    friend bool operator==(const T &paLeft, const T &paRight) {
+      return paLeft.equals(paRight);
+    }
+
+    template <typename T, std::enable_if_t<std::is_base_of_v<CIEC_STRUCT, T>, int> = 0>
+    friend bool operator!=(const T &paLeft, const T &paRight) {
+      return !(paLeft == paRight);
+    }
+
   public:
     //! Indicator for invalid array member index positions
     static constexpr size_t csmNIndex = -1;

src/core/datatypes/forte_word.h

@@ -108,13 +108,34 @@ class CIEC_WORD : public CIEC_ANY_BIT{
     /*! \brief Partial access within a CIEC_WORD (e.g. [WORD].partial<CIEC_BOOL>(1))
      *
      */
-    template <class T> CIEC_ANY_BIT_PARTIAL<T, CIEC_WORD> partial(size_t paIndex) {
+    template<class T>
+    CIEC_ANY_BIT_PARTIAL<T, CIEC_WORD> partial(size_t paIndex) {
       return CIEC_ANY_BIT_PARTIAL<T, CIEC_WORD>(*this, paIndex);
     }
 
-    template <class T> CIEC_ANY_BIT_PARTIAL<T, CIEC_WORD> partial(const CIEC_ANY_INT& paIndex){
-      size_t index = paIndex.getUnsignedValue();
-      return CIEC_ANY_BIT_PARTIAL<T, CIEC_WORD>(*this, index);
+    template<class T>
+    T partial(size_t paIndex) const {
+      return CIEC_ANY_BIT_PARTIAL<T, CIEC_WORD>::partialValue(*this, paIndex);
+    }
+
+    template<class T>
+    T cpartial(size_t paIndex) const {
+      return partial<T>(paIndex);
+    }
+
+    template<class T>
+    CIEC_ANY_BIT_PARTIAL<T, CIEC_WORD> partial(const CIEC_ANY_INT &paIndex) {
+      return partial<T>(paIndex.getUnsignedValue());
+    }
+
+    template<class T>
+    T partial(const CIEC_ANY_INT &paIndex) const {
+      return partial<T>(paIndex.getUnsignedValue());
+    }
+
+    template<class T>
+    T cpartial(const CIEC_ANY_INT &paIndex) const {
+      return partial<T>(paIndex);
     }
 };
 

src/core/iec61131_functions.h

@@ -425,7 +425,9 @@ CIEC_BOOL func_EQ(const T &paIn1, const U &paIn2, const Args& ... args) {
 
 template<typename T, typename U>
 CIEC_BOOL func_EQ(const T &paIN1, const U &paIN2) {
-  if constexpr (forte::core::mpl::are_of_subtype_v<CIEC_ANY_BIT, T, U>) { //ANY_BITs can be also partial accesses
+  if constexpr (forte::core::mpl::has_equality_v<T, U>) {
+    return CIEC_BOOL(paIN1 == paIN2);
+  } else if constexpr (forte::core::mpl::are_of_subtype_v<CIEC_ANY_BIT, T, U>) { //ANY_BITs can be also partial accesses
     using tTClass = typename forte::core::mpl::get_equivalent_CIEC_class_t<T>;
     using tUClass = typename forte::core::mpl::get_equivalent_CIEC_class_t<U>;
     using tImplicitCastType = typename forte::core::mpl::get_castable_type_t<tTClass, tUClass>;
@@ -539,7 +541,9 @@ CIEC_BOOL func_LT(const T &paIN1, const T &paIN2) {
 
 template<typename T, typename U>
 CIEC_BOOL func_NE(const T &paIN1, const U &paIN2) {
-  if constexpr (forte::core::mpl::are_of_subtype_v<CIEC_ANY_BIT, T, U>) { //ANY_BITs can be also partial accesses
+  if constexpr (forte::core::mpl::has_equality_v<T, U>) {
+    return CIEC_BOOL(paIN1 != paIN2);
+  } else if constexpr (forte::core::mpl::are_of_subtype_v<CIEC_ANY_BIT, T, U>) { //ANY_BITs can be also partial accesses
     using tTClass = typename forte::core::mpl::get_equivalent_CIEC_class_t<T>;
     using tUClass = typename forte::core::mpl::get_equivalent_CIEC_class_t<U>;
     using tImplicitCastType = typename forte::core::mpl::get_castable_type_t<tTClass, tUClass>;

tests/core/datatypes/CIEC_PARTIAL/CIEC_BYTE_PARTIAL_test.cpp

@@ -35,7 +35,13 @@ BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_INITVALUES) {
 
   test4X_0(nTestByte,4);
   test4X_0(nTestByte,0);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_INITVALUES_CONST) {
+  const CIEC_BYTE nTestByte;
 
+  test4X_0(nTestByte,4);
+  test4X_0(nTestByte,0);
 }
 
 BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_CONST_INIT) {
@@ -66,13 +72,27 @@ BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE1_CHECK_BIT) {
 
 }
 
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE1_CHECK_BIT_CONST) {
+  const CIEC_BYTE nTestByte(0xBE);
+  test4X_B(nTestByte,4);
+  test4X_E(nTestByte,0);
+
+}
+
 BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE2_CHECK_BIT) {
   CIEC_BYTE nTestByte(0xBA);
   test4X_B(nTestByte,4);
   test4X_A(nTestByte,0);
 
 }
 
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE2_CHECK_BIT_CONST) {
+  const CIEC_BYTE nTestByte(0xBA);
+  test4X_B(nTestByte,4);
+  test4X_A(nTestByte,0);
+
+}
+
 BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE_CHANGE_CHECK_BYTE)
 {
   CIEC_BYTE nTestByte(0xBE);
@@ -193,6 +213,12 @@ BOOST_AUTO_TEST_CASE(PARTIAL_ACCESSOUT_OF_INDEX_ACCESS) {
   BOOST_TEST(static_cast<CIEC_BOOL::TValueType>(nByte.partial<CIEC_BOOL>(CIEC_SINT(8))) == false);
 }
 
+BOOST_AUTO_TEST_CASE(PARTIAL_COPY_PARTIAL_TO_SAME_PARTIAL) {
+  CIEC_BYTE nByte(0x02U);
+  nByte.partial<CIEC_BOOL>(CIEC_SINT(0)) = CIEC_BOOL(nByte.cpartial<CIEC_BOOL>(CIEC_SINT(0)) || true);
+  BOOST_TEST(static_cast<CIEC_BYTE::TValueType>(nByte) == 0x03U);
+}
+
 BOOST_AUTO_TEST_CASE(PARTIAL_COPY_PARTIAL_TO_OTHER_PARTIAL) {
   CIEC_BYTE nByte(0x01U);
   nByte.partial<CIEC_BOOL>(CIEC_SINT(1)) = nByte.partial<CIEC_BOOL>(CIEC_SINT(0));