VxWorks/C++ fixes

Autocoders/Python/schema/default/active_comp_schematron.rng

@@ -3,7 +3,7 @@
         xmlns="http://purl.oclc.org/dsdl/schematron">
     <pattern id="ASYNC_PORT">
         <rule context="component">
-            <assert test="(//component/@kind = 'active' and (count(//component/ports/port/@kind[. = 'async_input']) + count(//component/internal_interfaces/internal_interface) ) >= 1) or not (//component/@kind = 'active')">
+            <assert test="(//component/@kind = 'active' and (count(//component/ports/port/@kind[. = 'async_input']) + count(//component/commands/command/@kind[. = 'async']) + count(//component/internal_interfaces/internal_interface) ) >= 1) or not (//component/@kind = 'active')">
                 Active components should have at least 1 port of kind async_input or internal_interface.
             </assert>
         </rule>

Drv/Ip/IpSocket.cpp

@@ -72,20 +72,22 @@ SocketIpStatus IpSocket::setupTimeouts(NATIVE_INT_TYPE socketFd) {
     if (setsockopt(socketFd, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(timeout)) < 0) {
         return SOCK_FAILED_TO_SET_SOCKET_OPTIONS;
     }
-    return SOCK_SUCCESS;
 #endif
+    return SOCK_SUCCESS;
 }
 
 SocketIpStatus IpSocket::addressToIp4(const char* address, void* ip4) {
     FW_ASSERT(address != NULL);
     FW_ASSERT(ip4 != NULL);
     // Get the IP address from host
 #ifdef TGT_OS_TYPE_VXWORKS
-    U32 ip = inet_addr(address);
+    NATIVE_INT_TYPE ip = inet_addr(address);
     if (ip == ERROR) {
         return SOCK_INVALID_IP_ADDRESS;
     }
-    *ip4 = ip;
+    // from sin_addr, which has one struct
+    // member s_addr, which is unsigned int
+    *reinterpret_cast<unsigned long*>(ip4) = ip;
 #else
     // First IP address to socket sin_addr
     if (not ::inet_pton(AF_INET, address, ip4)) {

Drv/Ip/IpSocket.hpp

@@ -45,6 +45,7 @@ enum SocketIpStatus {
 class IpSocket {
   public:
     IpSocket();
+    virtual ~IpSocket(){};
     /**
      * \brief configure the ip socket with host and transmission timeouts
      *

Fw/Buffer/Buffer.cpp

@@ -22,39 +22,39 @@ namespace Fw {
 
 Buffer::Buffer(): Serializable(),
     m_serialize_repr(),
-    m_data(NULL),
+    m_bufferData(NULL),
     m_size(0),
     m_context(0xFFFFFFFF)
 {}
 
 Buffer::Buffer(const Buffer& src) : Serializable(),
-    m_serialize_repr(src.m_data, src.m_size),
-    m_data(src.m_data),
+    m_serialize_repr(src.m_bufferData, src.m_size),
+    m_bufferData(src.m_bufferData),
     m_size(src.m_size),
     m_context(src.m_context)
 {}
 
 Buffer::Buffer(U8* data, U32 size, U32 context) : Serializable(),
     m_serialize_repr(data, size),
-    m_data(data),
+    m_bufferData(data),
     m_size(size),
     m_context(context)
 {}
 
 Buffer& Buffer::operator=(const Buffer& src) {
     // Ward against self-assignment
     if (this != &src) {
-        this->set(src.m_data, src.m_size, src.m_context);
+        this->set(src.m_bufferData, src.m_size, src.m_context);
     }
     return *this;
 }
 
 bool Buffer::operator==(const Buffer& src) const {
-    return (this->m_data == src.m_data) && (this->m_size == src.m_size) && (this->m_context == src.m_context);
+    return (this->m_bufferData == src.m_bufferData) && (this->m_size == src.m_size) && (this->m_context == src.m_context);
 }
 
 U8* Buffer::getData() const {
-    return this->m_data;
+    return this->m_bufferData;
 }
 
 U32 Buffer::getSize() const {
@@ -66,16 +66,16 @@ U32 Buffer::getContext() const {
 }
 
 void Buffer::setData(U8* const data) {
-    this->m_data = data;
-    if (m_data != NULL) {
-        this->m_serialize_repr.setExtBuffer(m_data, m_size);
+    this->m_bufferData = data;
+    if (m_bufferData != NULL) {
+        this->m_serialize_repr.setExtBuffer(m_bufferData, m_size);
     }
 }
 
 void Buffer::setSize(const U32 size) {
     this->m_size = size;
-    if (m_data != NULL) {
-        this->m_serialize_repr.setExtBuffer(m_data, m_size);
+    if (m_bufferData != NULL) {
+        this->m_serialize_repr.setExtBuffer(m_bufferData, m_size);
     }
 }
 
@@ -84,10 +84,10 @@ void Buffer::setContext(const U32 context) {
 }
 
 void Buffer::set(U8* const data, const U32 size, const U32 context) {
-    this->m_data = data;
+    this->m_bufferData = data;
     this->m_size = size;
-    if (m_data != NULL) {
-        this->m_serialize_repr.setExtBuffer(m_data, m_size);
+    if (m_bufferData != NULL) {
+        this->m_serialize_repr.setExtBuffer(m_bufferData, m_size);
     }
     this->m_context = context;
 }
@@ -104,7 +104,7 @@ Fw::SerializeStatus Buffer::serialize(Fw::SerializeBufferBase& buffer) const {
         return stat;
     }
 #endif
-    stat = buffer.serialize(reinterpret_cast<POINTER_CAST>(this->m_data));
+    stat = buffer.serialize(reinterpret_cast<POINTER_CAST>(this->m_bufferData));
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
@@ -139,7 +139,7 @@ Fw::SerializeStatus Buffer::deserialize(Fw::SerializeBufferBase& buffer) {
     if (stat != Fw::FW_SERIALIZE_OK) {
         return stat;
     }
-    this->m_data = reinterpret_cast<U8*>(pointer);
+    this->m_bufferData = reinterpret_cast<U8*>(pointer);
 
     stat = buffer.deserialize(this->m_size);
     if (stat != Fw::FW_SERIALIZE_OK) {
@@ -157,7 +157,7 @@ void Buffer::toString(Fw::StringBase& text) const {
     static const char * formatString = "(data = %p, size = %u,context = %u)";
     char outputString[FW_SERIALIZABLE_TO_STRING_BUFFER_SIZE];
 
-    (void)snprintf(outputString, FW_SERIALIZABLE_TO_STRING_BUFFER_SIZE, formatString, this->m_data, this->m_size,
+    (void)snprintf(outputString, FW_SERIALIZABLE_TO_STRING_BUFFER_SIZE, formatString, this->m_bufferData, this->m_size,
                    this->m_context);
     // Force NULL termination
     outputString[FW_SERIALIZABLE_TO_STRING_BUFFER_SIZE-1] = 0;

Fw/Buffer/Buffer.hpp

@@ -161,7 +161,7 @@ class Buffer : public Fw::Serializable {
 
 PRIVATE:
     Fw::ExternalSerializeBuffer m_serialize_repr; //<! Representation for serialization and deserialization functions
-    U8* m_data; //<! data - A pointer to the data
+    U8* m_bufferData; //<! data - A pointer to the data
     U32 m_size; //<! size - The data size in bytes
     U32 m_context; //!< Creation context for disposal
 

Fw/Cmd/CmdArgBuffer.cpp

@@ -15,26 +15,26 @@ namespace Fw {
     }
 
     CmdArgBuffer::CmdArgBuffer(const CmdArgBuffer& other) : Fw::SerializeBufferBase() {
-        SerializeStatus stat = this->setBuff(other.m_data,other.getBuffLength());
+        SerializeStatus stat = this->setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
     }
 
     const CmdArgBuffer& CmdArgBuffer::operator=(const CmdArgBuffer& other) {
-        SerializeStatus stat = this->setBuff(other.m_data,other.getBuffLength());
+        SerializeStatus stat = this->setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
         return *this;
     }
 
     NATIVE_UINT_TYPE CmdArgBuffer::getBuffCapacity(void) const {
-        return sizeof(this->m_data);
+        return sizeof(this->m_bufferData);
     }
 
     const U8* CmdArgBuffer::getBuffAddr(void) const {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
     U8* CmdArgBuffer::getBuffAddr(void) {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
 }

Fw/Cmd/CmdArgBuffer.hpp

@@ -38,7 +38,7 @@ namespace Fw {
             const U8* getBuffAddr(void) const;  //!< return address of buffer (const version)
 
         private:
-            U8 m_data[FW_CMD_ARG_BUFFER_MAX_SIZE]; //!< command argument buffer
+            U8 m_bufferData[FW_CMD_ARG_BUFFER_MAX_SIZE]; //!< command argument buffer
     };
 
 }

Fw/Com/ComBuffer.cpp

@@ -15,26 +15,26 @@ namespace Fw {
     }
 
     ComBuffer::ComBuffer(const ComBuffer& other) : Fw::SerializeBufferBase() {
-        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_data,other.getBuffLength());
+        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
     }
 
     const ComBuffer& ComBuffer::operator=(const ComBuffer& other) {
-        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_data,other.getBuffLength());
+        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
         return *this;
     }
 
     NATIVE_UINT_TYPE ComBuffer::getBuffCapacity(void) const {
-        return sizeof(this->m_data);
+        return sizeof(this->m_bufferData);
     }
 
     const U8* ComBuffer::getBuffAddr(void) const {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
     U8* ComBuffer::getBuffAddr(void) {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
 }

Fw/Com/ComBuffer.hpp

@@ -37,7 +37,7 @@ namespace Fw {
             const U8* getBuffAddr(void) const;
 
         private:
-            U8 m_data[FW_COM_BUFFER_MAX_SIZE]; // packet data buffer
+            U8 m_bufferData[FW_COM_BUFFER_MAX_SIZE]; // packet data buffer
     };
 
 }

Fw/Log/LogBuffer.cpp

@@ -15,26 +15,26 @@ namespace Fw {
     }
 
     LogBuffer::LogBuffer(const LogBuffer& other) : Fw::SerializeBufferBase() {
-        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_data,other.getBuffLength());
+        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
     }
 
     const LogBuffer& LogBuffer::operator=(const LogBuffer& other) {
-        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_data,other.getBuffLength());
+        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
         return *this;
     }
 
     NATIVE_UINT_TYPE LogBuffer::getBuffCapacity(void) const {
-        return sizeof(this->m_data);
+        return sizeof(this->m_bufferData);
     }
 
     const U8* LogBuffer::getBuffAddr(void) const {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
     U8* LogBuffer::getBuffAddr(void) {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
 }

Fw/Log/LogBuffer.hpp

@@ -38,7 +38,7 @@ namespace Fw {
             const U8* getBuffAddr(void) const;
 
         private:
-            U8 m_data[FW_LOG_BUFFER_MAX_SIZE]; // command argument buffer
+            U8 m_bufferData[FW_LOG_BUFFER_MAX_SIZE]; // command argument buffer
     };
 
 }

Fw/Prm/PrmBuffer.cpp

@@ -15,26 +15,26 @@ namespace Fw {
     }
 
     ParamBuffer::ParamBuffer(const ParamBuffer& other) : Fw::SerializeBufferBase() {
-        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_data,other.getBuffLength());
+        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
 	}
 
 	const ParamBuffer& ParamBuffer::operator=(const ParamBuffer& other) {
-	    SerializeStatus stat = SerializeBufferBase::setBuff(other.m_data,other.getBuffLength());
+	    SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
         return *this;
 	}
 
     NATIVE_UINT_TYPE ParamBuffer::getBuffCapacity(void) const {
-        return sizeof(this->m_data);
+        return sizeof(this->m_bufferData);
     }
 
     const U8* ParamBuffer::getBuffAddr(void) const {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
     U8* ParamBuffer::getBuffAddr(void) {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
 }

Fw/Prm/PrmBuffer.hpp

@@ -38,7 +38,7 @@ namespace Fw {
             const U8* getBuffAddr(void) const;
 
         private:
-            U8 m_data[FW_PARAM_BUFFER_MAX_SIZE]; // command argument buffer
+            U8 m_bufferData[FW_PARAM_BUFFER_MAX_SIZE]; // command argument buffer
     };
 
 }

Fw/Tlm/TlmBuffer.cpp

@@ -15,26 +15,26 @@ namespace Fw {
     }
 
     TlmBuffer::TlmBuffer(const TlmBuffer& other) : Fw::SerializeBufferBase() {
-        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_data,other.getBuffLength());
+        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
     }
 
     const TlmBuffer& TlmBuffer::operator=(const TlmBuffer& other) {
-        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_data,other.getBuffLength());
+        SerializeStatus stat = SerializeBufferBase::setBuff(other.m_bufferData,other.getBuffLength());
         FW_ASSERT(FW_SERIALIZE_OK == stat,static_cast<NATIVE_INT_TYPE>(stat));
         return *this;
     }
 
     NATIVE_UINT_TYPE TlmBuffer::getBuffCapacity(void) const {
-        return sizeof(this->m_data);
+        return sizeof(this->m_bufferData);
     }
 
     const U8* TlmBuffer::getBuffAddr(void) const {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
     U8* TlmBuffer::getBuffAddr(void) {
-        return this->m_data;
+        return this->m_bufferData;
     }
 
 }

Fw/Tlm/TlmBuffer.hpp

@@ -37,7 +37,7 @@ namespace Fw {
             const U8* getBuffAddr(void) const;
 
         PRIVATE:
-            U8 m_data[FW_TLM_BUFFER_MAX_SIZE]; // command argument buffer
+            U8 m_bufferData[FW_TLM_BUFFER_MAX_SIZE]; // command argument buffer
     };
 
 }

Svc/ActiveTextLogger/ActiveTextLoggerImpl.cpp

@@ -5,6 +5,7 @@
 
 #include <Svc/ActiveTextLogger/ActiveTextLoggerImpl.hpp>
 #include <Fw/Types/Assert.hpp>
+#include <Fw/Logger/Logger.hpp>
 #include <time.h>
 
 namespace Svc {
@@ -130,7 +131,7 @@ namespace Svc {
     {
 
         // Print to console:
-        (void) printf("%s",text.toChar());
+        Fw::Logger::logMsg(text.toChar(),0,0,0,0,0,0,0,0,0);
 
         // Print to file if there is one:
         (void) this->m_log_file.write_to_log(text.toChar(), text.length());  // Ignoring return status