nasa/fprime
1
0
Fork 0
mirror of https://github.com/nasa/fprime.git synced 2025-12-10 17:47:10 -06:00
Code Issues Packages Projects Releases 34 Wiki Activity

Update/types refactor as constants (#1623)

Browse Source 
* lestarch: adding logical types implementation into Linux/StandardTypes.hpp

* lestarch: removing VxWorks StandardTypes from repository

* updated fprime types for correct compilation with vxworks and baremetal

* lestarch: refactoring types and configuration header w.r.t type design

* lestarch: replacing usages of AssertArg with FwAssertArgType

* lestarch: missspelled configuration

* lestarch: minor compilation fixes

* lestarch: renaming StandardTypes.hpp -> PlatformTypes.hpp

* lestarch: updating PRI tokens

* lestarch: replacing BasicTypes.hpp includes with FpConfig.hpp

* lestarch: UT and compilation fixes for types refactor

* lestarch: sp

* lestarch: fixing RPI issues in PassiveConsoleTextLogger

* lestarch: converting RPI build to debug

* lestarch: removing duplicate config imports

* lestarch: fixing documentation

* lestarch: fixing up multiple definitions and RPI compilation problems

* lestarch: reverting debug build

* lestarch: reverting platform types to class-based constants

* lestarch: reworking basic types

* lestarch: configured types refactor into classes

* lestarch: fixing bugs with static constants in classes

* lestarch: fixing platform types spelling and documentation

* lestarch: adding include guards to types headers

Co-authored-by: Kevin F Ortega <kevin.f.ortega@jpl.nasa.gov>
This commit is contained in:
M Starch 2022-08-18 13:25:56 -07:00 committed by GitHub
parent 892df7f5ff
commit b76d8c9a0c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
230 changed files with 846 additions and 645 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.github/actions/spelling/expect.txt vendored
View File

@ -644,6 +644,7 @@ instrlen
integertypename integertypename
intlimits intlimits
ints ints
Inttype
inttype inttype
invisi invisi
ioc ioc

2
Autocoders/Python/bin/tlm_packet_gen.py
View File

@ -63,7 +63,7 @@ impl_file_template = """
\#include <${output_header}> \#include <${output_header}>
\#include <FpConfig.hpp> \#include <FpConfig.hpp>
\#include <Fw/Types/BasicTypes.hpp> \#include <FpConfig.hpp>
\#include <Fw/Time/Time.hpp> \#include <Fw/Time/Time.hpp>
// Verify packets not too large for ComBuffer // Verify packets not too large for ComBuffer

2
Autocoders/Python/src/fprime_ac/generators/templates/arrays/array_hpp.tmpl
View File

@ -15,7 +15,7 @@
\#define ${namespace}_${name}_HPP \#define ${namespace}_${name}_HPP
\#include "Fw/Types/String.hpp" \#include "Fw/Types/String.hpp"
\#include "Fw/Types/BasicTypes.hpp" \#include <FpConfig.hpp>
\#include "Fw/Types/Serializable.hpp" \#include "Fw/Types/Serializable.hpp"
#for $t in $include_headers: #for $t in $include_headers:
\#include <${t}> \#include <${t}>

92
Autocoders/Python/src/fprime_ac/generators/templates/component/cpp.tmpl
View File

@ -131,7 +131,7 @@ namespace ${namespace} {
#end if #end if
get_${instance}_InputPort(NATIVE_INT_TYPE portNum) get_${instance}_InputPort(NATIVE_INT_TYPE portNum)
{ {
FW_ASSERT(portNum < this->getNum_${instance}_InputPorts(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_${instance}_InputPorts(),static_cast<FwAssertArgType>(portNum));
return &this->m_${instance}_InputPort[portNum]; return &this->m_${instance}_InputPort[portNum];
} }
@ -157,7 +157,7 @@ namespace ${namespace} {
#end if #end if
) )
{ {
FW_ASSERT(portNum < this->getNum_${instance}_OutputPorts(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_${instance}_OutputPorts(),static_cast<FwAssertArgType>(portNum));
#if $type == "Serial": #if $type == "Serial":
this->m_${instance}_OutputPort[portNum].registerSerialPort(port); this->m_${instance}_OutputPort[portNum].registerSerialPort(port);
#else: #else:
@ -189,7 +189,7 @@ namespace ${namespace} {
#end if #end if
) )
{ {
FW_ASSERT(portNum < this->getNum_${instance}_OutputPorts(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_${instance}_OutputPorts(),static_cast<FwAssertArgType>(portNum));
return this->m_${instance}_OutputPort[portNum].registerSerialPort(port); return this->m_${instance}_OutputPort[portNum].registerSerialPort(port);
} }
#if $role == "LogTextEvent": #if $role == "LogTextEvent":
@ -507,7 +507,7 @@ namespace ${namespace} {
#end if #end if
FW_ASSERT( FW_ASSERT(
Os::Queue::QUEUE_OK == qStat, Os::Queue::QUEUE_OK == qStat,
static_cast<AssertArg>(qStat) static_cast<FwAssertArgType>(qStat)
); );
#end if #end if
@ -538,7 +538,7 @@ namespace ${namespace} {
Fw::SerializeBufferBase &Buffer Fw::SerializeBufferBase &Buffer
) )
{ {
FW_ASSERT(portNum < this->getNum_${instance}_OutputPorts(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_${instance}_OutputPorts(),static_cast<FwAssertArgType>(portNum));
return this->m_${instance}_OutputPort[portNum].invokeSerial(Buffer); return this->m_${instance}_OutputPort[portNum].invokeSerial(Buffer);
} }
#else #else
@ -552,7 +552,7 @@ namespace ${namespace} {
) )
{ {
#end if #end if
FW_ASSERT(portNum < this->getNum_${instance}_OutputPorts(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_${instance}_OutputPorts(),static_cast<FwAssertArgType>(portNum));
#if $void_return: #if $void_return:
this->m_${instance}_OutputPort[portNum].invoke($args); this->m_${instance}_OutputPort[portNum].invoke($args);
#else: #else:
@ -596,7 +596,7 @@ namespace ${namespace} {
{ {
FW_ASSERT( FW_ASSERT(
portNum < this->getNum_${instance}_OutputPorts(), portNum < this->getNum_${instance}_OutputPorts(),
static_cast<AssertArg>(portNum) static_cast<FwAssertArgType>(portNum)
); );
return this->m_${instance}_OutputPort[portNum].isConnected(); return this->m_${instance}_OutputPort[portNum].isConnected();
} }
@ -813,7 +813,7 @@ namespace ${namespace} {
#end if #end if
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
// Fake port number to make message dequeue work // Fake port number to make message dequeue work
@ -821,25 +821,25 @@ namespace ${namespace} {
_status = msg.serialize(port); _status = msg.serialize(port);
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
_status = msg.serialize(opCode); _status = msg.serialize(opCode);
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
_status = msg.serialize(cmdSeq); _status = msg.serialize(cmdSeq);
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
_status = msg.serialize(args); _status = msg.serialize(args);
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
// send message // send message
@ -859,7 +859,7 @@ namespace ${namespace} {
#end if #end if
FW_ASSERT( FW_ASSERT(
qStatus == Os::Queue::QUEUE_OK, qStatus == Os::Queue::QUEUE_OK,
static_cast<AssertArg>(qStatus) static_cast<FwAssertArgType>(qStatus)
); );
#end if #end if
@ -925,7 +925,7 @@ namespace ${namespace} {
#end if #end if
FW_ASSERT( FW_ASSERT(
_stat == Fw::FW_SERIALIZE_OK, _stat == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_stat) static_cast<FwAssertArgType>(_stat)
); );
FwChanIdType _id; FwChanIdType _id;
@ -1206,25 +1206,25 @@ namespace ${namespace} {
_status = _logBuff.serialize(static_cast<U8>($len($args)+1)); _status = _logBuff.serialize(static_cast<U8>($len($args)+1));
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
// For FATAL, add stack size of 4 and a dummy entry. No support for stacks yet. // For FATAL, add stack size of 4 and a dummy entry. No support for stacks yet.
_status = _logBuff.serialize(static_cast<U8>(4)); _status = _logBuff.serialize(static_cast<U8>(4));
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
_status = _logBuff.serialize(static_cast<U32>(0)); _status = _logBuff.serialize(static_cast<U32>(0));
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
#else #else
// Serialize the number of arguments // Serialize the number of arguments
_status = _logBuff.serialize(static_cast<U8>($len($args))); _status = _logBuff.serialize(static_cast<U8>($len($args)));
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
#end if #end if
\#endif \#endif
@ -1235,7 +1235,7 @@ namespace ${namespace} {
_zero_status = _logBuff.serialize(static_cast<U8>(0)); _zero_status = _logBuff.serialize(static_cast<U8>(0));
FW_ASSERT( FW_ASSERT(
_zero_status == Fw::FW_SERIALIZE_OK, _zero_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_zero_status) static_cast<FwAssertArgType>(_zero_status)
); );
\#endif \#endif
#end if #end if
@ -1247,7 +1247,7 @@ namespace ${namespace} {
_status = _logBuff.serialize(static_cast<U8>(sizeof(FwEnumStoreType))); _status = _logBuff.serialize(static_cast<U8>(sizeof(FwEnumStoreType)));
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
\#endif \#endif
@ -1264,14 +1264,14 @@ namespace ${namespace} {
); );
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
\#endif \#endif
_status = _logBuff.serialize($arg_name); _status = _logBuff.serialize($arg_name);
#end if #end if
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
#end for #end for
@ -1369,14 +1369,14 @@ namespace ${namespace} {
_status = msg.serialize(static_cast<NATIVE_INT_TYPE>(INT_IF_${ifname.upper})); _status = msg.serialize(static_cast<NATIVE_INT_TYPE>(INT_IF_${ifname.upper}));
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
// Fake port number to make message dequeue work // Fake port number to make message dequeue work
_status = msg.serialize(static_cast<NATIVE_INT_TYPE>(0)); _status = msg.serialize(static_cast<NATIVE_INT_TYPE>(0));
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
#for $argname, $argtype, $comment, $typeinfo in $internal_interface_args[$ifname]: #for $argname, $argtype, $comment, $typeinfo in $internal_interface_args[$ifname]:
@ -1385,7 +1385,7 @@ namespace ${namespace} {
#else #else
_status = msg.serialize($argname); _status = msg.serialize($argname);
#end if #end if
FW_ASSERT(_status == Fw::FW_SERIALIZE_OK, static_cast<AssertArg>(_status)); FW_ASSERT(_status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(_status));
#end for #end for
// send message // send message
@ -1405,7 +1405,7 @@ namespace ${namespace} {
#end if #end if
FW_ASSERT( FW_ASSERT(
qStatus == Os::Queue::QUEUE_OK, qStatus == Os::Queue::QUEUE_OK,
static_cast<AssertArg>(qStatus) static_cast<FwAssertArgType>(qStatus)
); );
} }
@ -1481,21 +1481,21 @@ namespace ${namespace} {
); );
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
// serialize port number // serialize port number
_status = msgSerBuff.serialize(portNum); _status = msgSerBuff.serialize(portNum);
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
// serialize buffer // serialize buffer
_status = msgSerBuff.serialize(buffer); _status = msgSerBuff.serialize(buffer);
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
// send message // send message
@ -1515,7 +1515,7 @@ namespace ${namespace} {
#end if #end if
FW_ASSERT( FW_ASSERT(
qStatus == Os::Queue::QUEUE_OK, qStatus == Os::Queue::QUEUE_OK,
static_cast<AssertArg>(qStatus) static_cast<FwAssertArgType>(qStatus)
); );
#end if #end if
@ -1583,7 +1583,7 @@ namespace ${namespace} {
{ {
// Make sure port number is valid // Make sure port number is valid
FW_ASSERT(portNum < this->getNum_${instance}_InputPorts(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_${instance}_InputPorts(),static_cast<FwAssertArgType>(portNum));
#if not $void_return_type: #if not $void_return_type:
${return_type} retVal; ${return_type} retVal;
#end if #end if
@ -1607,13 +1607,13 @@ namespace ${namespace} {
); );
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
_status = msg.serialize(portNum); _status = msg.serialize(portNum);
FW_ASSERT ( FW_ASSERT (
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
#set $args = $port_args[$instance] #set $args = $port_args[$instance]
@ -1628,7 +1628,7 @@ namespace ${namespace} {
#end if #end if
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
#end for #end for
@ -1650,7 +1650,7 @@ namespace ${namespace} {
#end if #end if
FW_ASSERT( FW_ASSERT(
qStatus == Os::Queue::QUEUE_OK, qStatus == Os::Queue::QUEUE_OK,
static_cast<AssertArg>(qStatus) static_cast<FwAssertArgType>(qStatus)
); );
#else: #else:
@ -1732,7 +1732,7 @@ namespace ${namespace} {
Os::Queue::QueueStatus msgStatus = this->m_queue.receive(msg,priority,Os::Queue::QUEUE_BLOCKING); Os::Queue::QueueStatus msgStatus = this->m_queue.receive(msg,priority,Os::Queue::QUEUE_BLOCKING);
FW_ASSERT( FW_ASSERT(
msgStatus == Os::Queue::QUEUE_OK, msgStatus == Os::Queue::QUEUE_OK,
static_cast<AssertArg>(msgStatus) static_cast<FwAssertArgType>(msgStatus)
); );
#else #else
Os::Queue::QueueStatus msgStatus = this->m_queue.receive(msg,priority,Os::Queue::QUEUE_NONBLOCKING); Os::Queue::QueueStatus msgStatus = this->m_queue.receive(msg,priority,Os::Queue::QUEUE_NONBLOCKING);
@ -1741,7 +1741,7 @@ namespace ${namespace} {
} else { } else {
FW_ASSERT( FW_ASSERT(
msgStatus == Os::Queue::QUEUE_OK, msgStatus == Os::Queue::QUEUE_OK,
static_cast<AssertArg>(msgStatus) static_cast<FwAssertArgType>(msgStatus)
); );
} }
#end if #end if
@ -1753,7 +1753,7 @@ namespace ${namespace} {
Fw::SerializeStatus deserStatus = msg.deserialize(desMsg); Fw::SerializeStatus deserStatus = msg.deserialize(desMsg);
FW_ASSERT( FW_ASSERT(
deserStatus == Fw::FW_SERIALIZE_OK, deserStatus == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(deserStatus) static_cast<FwAssertArgType>(deserStatus)
); );
MsgTypeEnum msgType = static_cast<MsgTypeEnum>(desMsg); MsgTypeEnum msgType = static_cast<MsgTypeEnum>(desMsg);
@ -1766,7 +1766,7 @@ namespace ${namespace} {
deserStatus = msg.deserialize(portNum); deserStatus = msg.deserialize(portNum);
FW_ASSERT( FW_ASSERT(
deserStatus == Fw::FW_SERIALIZE_OK, deserStatus == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(deserStatus) static_cast<FwAssertArgType>(deserStatus)
); );
switch (msgType) { switch (msgType) {
@ -1795,7 +1795,7 @@ namespace ${namespace} {
#end if #end if
FW_ASSERT( FW_ASSERT(
deserStatus == Fw::FW_SERIALIZE_OK, deserStatus == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(deserStatus) static_cast<FwAssertArgType>(deserStatus)
); );
#end for #end for
@ -1806,7 +1806,7 @@ namespace ${namespace} {
deserStatus = msg.deserialize(serHandBuff); deserStatus = msg.deserialize(serHandBuff);
FW_ASSERT( FW_ASSERT(
deserStatus == Fw::FW_SERIALIZE_OK, deserStatus == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(deserStatus) static_cast<FwAssertArgType>(deserStatus)
); );
this->${instance}_handler(portNum, serHandBuff); this->${instance}_handler(portNum, serHandBuff);
#else: #else:
@ -1846,7 +1846,7 @@ namespace ${namespace} {
deserStatus = msg.deserialize(opCode); deserStatus = msg.deserialize(opCode);
FW_ASSERT ( FW_ASSERT (
deserStatus == Fw::FW_SERIALIZE_OK, deserStatus == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(deserStatus) static_cast<FwAssertArgType>(deserStatus)
); );
// Deserialize command sequence // Deserialize command sequence
@ -1854,7 +1854,7 @@ namespace ${namespace} {
deserStatus = msg.deserialize(cmdSeq); deserStatus = msg.deserialize(cmdSeq);
FW_ASSERT ( FW_ASSERT (
deserStatus == Fw::FW_SERIALIZE_OK, deserStatus == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(deserStatus) static_cast<FwAssertArgType>(deserStatus)
); );
// Deserialize command argument buffer // Deserialize command argument buffer
@ -1862,7 +1862,7 @@ namespace ${namespace} {
deserStatus = msg.deserialize(args); deserStatus = msg.deserialize(args);
FW_ASSERT ( FW_ASSERT (
deserStatus == Fw::FW_SERIALIZE_OK, deserStatus == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(deserStatus) static_cast<FwAssertArgType>(deserStatus)
); );
// Reset buffer // Reset buffer
@ -1939,7 +1939,7 @@ namespace ${namespace} {
// Internal interfaces should always deserialize // Internal interfaces should always deserialize
FW_ASSERT( FW_ASSERT(
Fw::FW_SERIALIZE_OK == deserStatus, Fw::FW_SERIALIZE_OK == deserStatus,
static_cast<AssertArg>(deserStatus) static_cast<FwAssertArgType>(deserStatus)
); );
#end for #end for
@ -1947,7 +1947,7 @@ namespace ${namespace} {
// That means the buffer size was incorrect. // That means the buffer size was incorrect.
FW_ASSERT( FW_ASSERT(
msg.getBuffLeft() == 0, msg.getBuffLeft() == 0,
static_cast<AssertArg>(msg.getBuffLeft()) static_cast<FwAssertArgType>(msg.getBuffLeft())
); );
// Call handler function // Call handler function

2
Autocoders/Python/src/fprime_ac/generators/templates/enums/enum_hpp.tmpl
View File

@ -15,7 +15,7 @@
\#define ${namespace}_${name}_HPP \#define ${namespace}_${name}_HPP
\#include "Fw/Types/String.hpp" \#include "Fw/Types/String.hpp"
\#include "Fw/Types/BasicTypes.hpp" \#include <FpConfig.hpp>
\#include "Fw/Types/Serializable.hpp" \#include "Fw/Types/Serializable.hpp"
#if $namespace #if $namespace

2
Autocoders/Python/src/fprime_ac/generators/templates/impl/cpp.tmpl
View File

@ -6,7 +6,7 @@
\#include <${include_path}/${name}.hpp> \#include <${include_path}/${name}.hpp>
\#include "Fw/Types/BasicTypes.hpp" \#include <FpConfig.hpp>
#if $namespace_list != None #if $namespace_list != None
#for $namespace in $namespace_list #for $namespace in $namespace_list

4
Autocoders/Python/src/fprime_ac/generators/templates/port/finishPortCpp.tmpl
View File

@ -50,11 +50,11 @@ ${return_type}Output${name}Port::invoke(${args_proto_string}) {
_status = _buffer.serialize($arg[0]); _status = _buffer.serialize($arg[0]);
#end if #end if
#set $num = $num + 1 #set $num = $num + 1
FW_ASSERT(Fw::FW_SERIALIZE_OK == _status,static_cast<AssertArg>(_status)); FW_ASSERT(Fw::FW_SERIALIZE_OK == _status,static_cast<FwAssertArgType>(_status));
#end for #end for
_status = this->m_serPort->invokeSerial(_buffer); _status = this->m_serPort->invokeSerial(_buffer);
FW_ASSERT(Fw::FW_SERIALIZE_OK == _status,static_cast<AssertArg>(_status)); FW_ASSERT(Fw::FW_SERIALIZE_OK == _status,static_cast<FwAssertArgType>(_status));
} }
\#else \#else
} }

2
Autocoders/Python/src/fprime_ac/generators/templates/port/includes1PortH.tmpl
View File

@ -4,6 +4,6 @@
\#include <Fw/Port/InputPortBase.hpp> \#include <Fw/Port/InputPortBase.hpp>
\#include <Fw/Port/OutputPortBase.hpp> \#include <Fw/Port/OutputPortBase.hpp>
\#include <Fw/Comp/PassiveComponentBase.hpp> \#include <Fw/Comp/PassiveComponentBase.hpp>
\#include <Fw/Types/BasicTypes.hpp> \#include <FpConfig.hpp>
\#include <Fw/Types/Serializable.hpp> \#include <Fw/Types/Serializable.hpp>
\#include <Fw/Types/StringType.hpp> \#include <Fw/Types/StringType.hpp>

2
Autocoders/Python/src/fprime_ac/generators/templates/serialize/includes1SerialCpp.tmpl
View File

@ -1,6 +1,6 @@
\#include <${include_path}/${namespace}${name}SerializableAc.hpp> \#include <${include_path}/${namespace}${name}SerializableAc.hpp>
\#include <Fw/Types/Assert.hpp> \#include <Fw/Types/Assert.hpp>
\#include <Fw/Types/BasicTypes.hpp> \#include <FpConfig.hpp>
\#include <Fw/Types/StringUtils.hpp> \#include <Fw/Types/StringUtils.hpp>
\#if FW_SERIALIZABLE_TO_STRING \#if FW_SERIALIZABLE_TO_STRING
\#include <Fw/Types/String.hpp> \#include <Fw/Types/String.hpp>

2
Autocoders/Python/src/fprime_ac/generators/templates/serialize/includes1SerialH.tmpl
View File

@ -1,4 +1,4 @@
\#include <Fw/Types/BasicTypes.hpp> \#include <FpConfig.hpp>
\#include <Fw/Types/Serializable.hpp> \#include <Fw/Types/Serializable.hpp>
\#if FW_SERIALIZABLE_TO_STRING \#if FW_SERIALIZABLE_TO_STRING
\#include <Fw/Types/StringType.hpp> \#include <Fw/Types/StringType.hpp>

38
Autocoders/Python/src/fprime_ac/generators/templates/test/cpp.tmpl
View File

@ -222,7 +222,7 @@ $emit_cpp_params([ $param_instance ])
$emit_cpp_params([ $param_portNum, $param_port ]) $emit_cpp_params([ $param_portNum, $param_port ])
) )
{ {
FW_ASSERT(portNum < this->getNum_to_${instance}(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_to_${instance}(),static_cast<FwAssertArgType>(portNum));
#if $type == "Serial": #if $type == "Serial":
this->m_to_${instance}[portNum].registerSerialPort($instance); this->m_to_${instance}[portNum].registerSerialPort($instance);
#else: #else:
@ -259,11 +259,11 @@ $emit_cpp_port_params([ $param_portNum ] + $port_params[$instance])
) )
#end if #end if
{ {
FW_ASSERT(portNum < this->getNum_to_${instance}(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_to_${instance}(),static_cast<FwAssertArgType>(portNum));
#if $serial_type: #if $serial_type:
this->m_to_${instance}[portNum].invokeSerial(Buffer); this->m_to_${instance}[portNum].invokeSerial(Buffer);
#else #else
FW_ASSERT(portNum < this->getNum_to_${instance}(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_to_${instance}(),static_cast<FwAssertArgType>(portNum));
#if $void_return_type #if $void_return_type
this->m_to_${instance}[portNum].invoke( this->m_to_${instance}[portNum].invoke(
#else: #else:
@ -285,7 +285,7 @@ $emit_cpp_port_params([ $param_portNum ] + $port_params[$instance])
bool ${tester_base} :: bool ${tester_base} ::
isConnected_to_${instance}(const NATIVE_INT_TYPE portNum) isConnected_to_${instance}(const NATIVE_INT_TYPE portNum)
{ {
FW_ASSERT(portNum < this->getNum_to_${instance}(), static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_to_${instance}(), static_cast<FwAssertArgType>(portNum));
return this->m_to_${instance}[portNum].isConnected(); return this->m_to_${instance}[portNum].isConnected();
} }
@ -308,7 +308,7 @@ $emit_cpp_port_params([ $param_portNum ] + $port_params[$instance])
#end if #end if
get_from_${instance}(const NATIVE_INT_TYPE portNum) get_from_${instance}(const NATIVE_INT_TYPE portNum)
{ {
FW_ASSERT(portNum < this->getNum_from_${instance}(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_from_${instance}(),static_cast<FwAssertArgType>(portNum));
return &this->m_from_${instance}[portNum]; return &this->m_from_${instance}[portNum];
} }
#if $role == "LogTextEvent": #if $role == "LogTextEvent":
@ -378,7 +378,7 @@ $emit_cpp_port_params([ $param_callComp, $param_portNum] + $params)
Fw::SerializeBufferBase &Buffer $doxygen_post_comment("The serialization buffer") Fw::SerializeBufferBase &Buffer $doxygen_post_comment("The serialization buffer")
) )
{ {
FW_ASSERT(portNum < this->getNum_from_${instance}(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_from_${instance}(),static_cast<FwAssertArgType>(portNum));
this->from_${instance}_handler( this->from_${instance}_handler(
portNum, portNum,
Buffer Buffer
@ -514,7 +514,7 @@ $emit_cpp_port_params([ $param_callComp, $param_portNum] + $params)
_ret = _testerBase->m_param_${prm_name}_valid; _ret = _testerBase->m_param_${prm_name}_valid;
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
} }
break; break;
@ -559,7 +559,7 @@ $emit_cpp_port_params([ $param_callComp, $param_portNum] + $params)
_status = val.deserialize(${prmname}Val); _status = val.deserialize(${prmname}Val);
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
FW_ASSERT( FW_ASSERT(
${prmname}Val == ${prmname}Val ==
@ -569,7 +569,7 @@ $emit_cpp_port_params([ $param_callComp, $param_portNum] + $params)
Fw::ParamString ${prmname}Val; Fw::ParamString ${prmname}Val;
_status = val.deserialize(${prmname}Val); _status = val.deserialize(${prmname}Val);
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,static_cast<AssertArg>(_status) _status == Fw::FW_SERIALIZE_OK,static_cast<FwAssertArgType>(_status)
); );
FW_ASSERT( FW_ASSERT(
${prmname}Val == ${prmname}Val ==
@ -580,7 +580,7 @@ $emit_cpp_port_params([ $param_callComp, $param_portNum] + $params)
_status = val.deserialize(${prmname}Val); _status = val.deserialize(${prmname}Val);
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
FW_ASSERT( FW_ASSERT(
${prmname}Val == ${prmname}Val ==
@ -664,7 +664,7 @@ $emit_cpp_port_params([ $param_portNum ] + $port_params[$instance])
#end if #end if
) )
{ {
FW_ASSERT(portNum < this->getNum_from_${instance}(),static_cast<AssertArg>(portNum)); FW_ASSERT(portNum < this->getNum_from_${instance}(),static_cast<FwAssertArgType>(portNum));
#if $void_params and $void_return_type: #if $void_params and $void_return_type:
this->from_${instance}_handler(portNum); this->from_${instance}_handler(portNum);
#else if $void_params #else if $void_params
@ -725,7 +725,7 @@ $emit_cpp_params([ $param_instance, $param_cmdSeq ] + $get_command_params($mnemo
#else #else
_status = buff.serialize($arg_name); _status = buff.serialize($arg_name);
#end if #end if
FW_ASSERT(_status == Fw::FW_SERIALIZE_OK,static_cast<AssertArg>(_status)); FW_ASSERT(_status == Fw::FW_SERIALIZE_OK,static_cast<FwAssertArgType>(_status));
#end for #end for
// Call output command port // Call output command port
@ -950,7 +950,7 @@ $emit_cpp_params([ $param_const_timeTag, $param_val ])
_status = args.deserialize(_numArgs); _status = args.deserialize(_numArgs);
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
// verify they match expected. // verify they match expected.
#if $severity == "FATAL" #if $severity == "FATAL"
@ -960,14 +960,14 @@ $emit_cpp_params([ $param_const_timeTag, $param_val ])
_status = args.deserialize(stackArgLen); _status = args.deserialize(stackArgLen);
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
FW_ASSERT(4 == stackArgLen,stackArgLen); FW_ASSERT(4 == stackArgLen,stackArgLen);
U32 dummyStackArg; U32 dummyStackArg;
_status = args.deserialize(dummyStackArg); _status = args.deserialize(dummyStackArg);
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
FW_ASSERT(0 == dummyStackArg,dummyStackArg); FW_ASSERT(0 == dummyStackArg,dummyStackArg);
#else #else
@ -983,7 +983,7 @@ $emit_cpp_params([ $param_const_timeTag, $param_val ])
_zero_status = args.deserialize(_noArgs); _zero_status = args.deserialize(_noArgs);
FW_ASSERT( FW_ASSERT(
_zero_status == Fw::FW_SERIALIZE_OK, _zero_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_zero_status) static_cast<FwAssertArgType>(_zero_status)
); );
\#endif \#endif
#end if #end if
@ -996,7 +996,7 @@ $emit_cpp_params([ $param_const_timeTag, $param_val ])
_status = args.deserialize(_argSize); _status = args.deserialize(_argSize);
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
FW_ASSERT(_argSize == sizeof(FwEnumStoreType),_argSize,sizeof(FwEnumStoreType)); FW_ASSERT(_argSize == sizeof(FwEnumStoreType),_argSize,sizeof(FwEnumStoreType));
} }
@ -1017,7 +1017,7 @@ $emit_cpp_params([ $param_const_timeTag, $param_val ])
_status = args.deserialize(_argSize); _status = args.deserialize(_argSize);
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
FW_ASSERT(_argSize == sizeof(${type}),_argSize,sizeof(${type})); FW_ASSERT(_argSize == sizeof(${type}),_argSize,sizeof(${type}));
} }
@ -1026,7 +1026,7 @@ $emit_cpp_params([ $param_const_timeTag, $param_val ])
#end if #end if
FW_ASSERT( FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK, _status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status) static_cast<FwAssertArgType>(_status)
); );
#end for #end for

2
Autocoders/Python/templates/ExampleType.hpp
View File

@ -2,7 +2,7 @@
#define EXAMPLE_TYPE_HPP #define EXAMPLE_TYPE_HPP
// A hand-coded serializable // A hand-coded serializable
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#if FW_SERIALIZABLE_TO_STRING #if FW_SERIALIZABLE_TO_STRING
#include <Fw/Types/StringType.hpp> #include <Fw/Types/StringType.hpp>

2
Autocoders/Python/test/array_xml/ExampleArrayImpl.cpp
View File

@ -1,5 +1,5 @@
#include <Autocoders/Python/test/array_xml/ExampleArrayImpl.hpp> #include <Autocoders/Python/test/array_xml/ExampleArrayImpl.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/String.hpp> #include <Fw/Types/String.hpp>
#include <iostream> #include <iostream>
#include <cstdio> #include <cstdio>

2
Autocoders/Python/test/array_xml/test/ut/main.cpp
View File

@ -9,7 +9,7 @@
#include <Fw/Obj/SimpleObjRegistry.hpp> #include <Fw/Obj/SimpleObjRegistry.hpp>
#include <Fw/Types/SerialBuffer.hpp> #include <Fw/Types/SerialBuffer.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/String.hpp> #include <Fw/Types/String.hpp>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>

2
Autocoders/Python/test/command2/TestCommandComponentImpl.cpp
View File

@ -12,7 +12,7 @@
#include <Autocoders/Python/test/command2/TestCommandComponentImpl.hpp> #include <Autocoders/Python/test/command2/TestCommandComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace AcTest { namespace AcTest {

2
Autocoders/Python/test/command_res/Test1ComponentImpl.cpp
View File

@ -12,7 +12,7 @@
#include <Autocoders/Python/test/command_res/Test1ComponentImpl.hpp> #include <Autocoders/Python/test/command_res/Test1ComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace Cmd { namespace Cmd {

2
Autocoders/Python/test/enum1port/DrvTimingSignalPort.hpp
View File

@ -4,7 +4,7 @@
#include <Fw/Port/FwInputPortBase.hpp> #include <Fw/Port/FwInputPortBase.hpp>
#include <Fw/Port/FwOutputPortBase.hpp> #include <Fw/Port/FwOutputPortBase.hpp>
#include <Fw/Comp/FwCompBase.hpp> #include <Fw/Comp/FwCompBase.hpp>
#include <Fw/Types/FwBasicTypes.hpp> #include <FpConfig.hpp>
namespace Drv { namespace Drv {

2
Autocoders/Python/test/enum_xml/Component1Impl.cpp
View File

@ -1,5 +1,5 @@
#include <Autocoders/Python/test/enum_xml/Component1Impl.hpp> #include <Autocoders/Python/test/enum_xml/Component1Impl.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <iostream> #include <iostream>
#include <cstdio> #include <cstdio>

12
Autocoders/Python/test/enum_xml/main.cpp
View File

@ -130,12 +130,12 @@ void checkAssertionFailure(
Test::UnitTestAssert::File file = Test::UnitTestAssert::fileInit; Test::UnitTestAssert::File file = Test::UnitTestAssert::fileInit;
NATIVE_UINT_TYPE lineNo = 0; NATIVE_UINT_TYPE lineNo = 0;
NATIVE_UINT_TYPE numArgs = 0; NATIVE_UINT_TYPE numArgs = 0;
AssertArg arg1 = 0; FwAssertArgType arg1 = 0;
AssertArg arg2 = 0; FwAssertArgType arg2 = 0;
AssertArg arg3 = 0; FwAssertArgType arg3 = 0;
AssertArg arg4 = 0; FwAssertArgType arg4 = 0;
AssertArg arg5 = 0; FwAssertArgType arg5 = 0;
AssertArg arg6 = 0; FwAssertArgType arg6 = 0;
uta.retrieveAssert(file, lineNo, numArgs, arg1, arg2, arg3, arg4, arg5, arg6); uta.retrieveAssert(file, lineNo, numArgs, arg1, arg2, arg3, arg4, arg5, arg6);
ASSERT_EQ(expectedLineNumber, lineNo); ASSERT_EQ(expectedLineNumber, lineNo);
ASSERT_EQ(1U, numArgs); ASSERT_EQ(1U, numArgs);

2
Autocoders/Python/test/ext_dict/ExampleType.hpp
View File

@ -2,7 +2,7 @@
#define EXAMPLE_TYPE_HPP #define EXAMPLE_TYPE_HPP
// A hand-coded serializable // A hand-coded serializable
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#if FW_SERIALIZABLE_TO_STRING #if FW_SERIALIZABLE_TO_STRING
#include <Fw/Types/StringType.hpp> #include <Fw/Types/StringType.hpp>

2
Autocoders/Python/test/implgen/templates/MathSenderComponentImpl_cpp-template.txt
View File

@ -1,5 +1,5 @@
#include <Autocoders/Python/test/implgen/MathSenderComponentImpl.hpp> #include <Autocoders/Python/test/implgen/MathSenderComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace Ref { namespace Ref {

2
Autocoders/Python/test/interface1/SomeStruct.hpp
View File

@ -1,7 +1,7 @@
#ifndef SOME_STRUCT_HPP #ifndef SOME_STRUCT_HPP
#define SOME_STRUCT_HPP #define SOME_STRUCT_HPP
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
extern "C" { extern "C" {
typedef struct { typedef struct {

2
Autocoders/Python/test/interface1/UserSerializer.hpp
View File

@ -2,7 +2,7 @@
#define EXAMPLE_TYPE_HPP #define EXAMPLE_TYPE_HPP
// A hand-coded serializable // A hand-coded serializable
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#include <Autocoders/Python/test/interface1/SomeStruct.hpp> #include <Autocoders/Python/test/interface1/SomeStruct.hpp>
#if FW_SERIALIZABLE_TO_STRING #if FW_SERIALIZABLE_TO_STRING

2
Autocoders/Python/test/noargport/ExampleComponentImpl.cpp
View File

@ -12,7 +12,7 @@
#include <Autocoders/Python/test/noargport/ExampleComponentImpl.hpp> #include <Autocoders/Python/test/noargport/ExampleComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace ExampleComponents { namespace ExampleComponents {

2
Autocoders/Python/test/partition/DuckDuckImpl.cpp
View File

@ -1,5 +1,5 @@
#include <Autocoders/Python/test/partition/DuckDuckImpl.hpp> #include <Autocoders/Python/test/partition/DuckDuckImpl.hpp>
#include <Fw/Types/FwBasicTypes.hpp> #include <FpConfig.hpp>
#include <iostream> #include <iostream>
#include <cstdio> #include <cstdio>

2
Autocoders/Python/test/partition/PartitionImpl.cpp
View File

@ -1,5 +1,5 @@
#include <Autocoders/Python/test/partition/PartitionImpl.hpp> #include <Autocoders/Python/test/partition/PartitionImpl.hpp>
#include <Fw/Types/FwBasicTypes.hpp> #include <FpConfig.hpp>
#include <iostream> #include <iostream>
#include <cstdio> #include <cstdio>

2
Autocoders/Python/test/pass_by_attrib/Msg1Port.hpp
View File

@ -12,7 +12,7 @@
#include <Fw/Port/FwInputPortBase.hpp> #include <Fw/Port/FwInputPortBase.hpp>
#include <Fw/Port/FwOutputPortBase.hpp> #include <Fw/Port/FwOutputPortBase.hpp>
#include <Fw/Comp/FwCompBase.hpp> #include <Fw/Comp/FwCompBase.hpp>
#include <Fw/Types/FwBasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/FwSerializable.hpp> #include <Fw/Types/FwSerializable.hpp>
#include <Fw/Types/FwStringType.hpp> #include <Fw/Types/FwStringType.hpp>

2
Autocoders/Python/test/pass_by_kind/Component1.cpp
View File

@ -1,6 +1,6 @@
#include <Autocoders/Python/test/pass_by_kind/Component1.hpp> #include <Autocoders/Python/test/pass_by_kind/Component1.hpp>
#include <Autocoders/Python/test/pass_by_kind/ExampleTypeSerializableAc.hpp> #include <Autocoders/Python/test/pass_by_kind/ExampleTypeSerializableAc.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/SerialBuffer.hpp> #include <Fw/Types/SerialBuffer.hpp>
#include <cstdio> #include <cstdio>
#include <iostream> #include <iostream>

2
Autocoders/Python/test/port_loopback/ExampleComponentImpl.cpp
View File

@ -12,7 +12,7 @@
#include <Autocoders/Python/test/port_loopback/ExampleComponentImpl.hpp> #include <Autocoders/Python/test/port_loopback/ExampleComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
#include <cstdio> #include <cstdio>
namespace ExampleComponents { namespace ExampleComponents {

2
Autocoders/Python/test/port_loopback/ExampleType.hpp
View File

@ -2,7 +2,7 @@
#define EXAMPLE_TYPE_HPP #define EXAMPLE_TYPE_HPP
// A hand-coded serializable // A hand-coded serializable
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#if FW_SERIALIZABLE_TO_STRING #if FW_SERIALIZABLE_TO_STRING
#include <Fw/Types/StringType.hpp> #include <Fw/Types/StringType.hpp>

2
Autocoders/Python/test/port_nogen/ExampleType.hpp
View File

@ -2,7 +2,7 @@
#define EXAMPLE_TYPE_HPP #define EXAMPLE_TYPE_HPP
// A hand-coded serializable // A hand-coded serializable
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#if FW_SERIALIZABLE_TO_STRING #if FW_SERIALIZABLE_TO_STRING
#include <Fw/Types/StringType.hpp> #include <Fw/Types/StringType.hpp>

2
Autocoders/Python/test/serial_passive/TestSerialImpl.cpp
View File

@ -12,7 +12,7 @@
#include <Autocoders/Python/test/serial_passive/TestSerialImpl.hpp> #include <Autocoders/Python/test/serial_passive/TestSerialImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace TestComponents { namespace TestComponents {

2
Autocoders/Python/test/serialize_user/SomeStruct.hpp
View File

@ -1,7 +1,7 @@
#ifndef SOME_STRUCT_HPP #ifndef SOME_STRUCT_HPP
#define SOME_STRUCT_HPP #define SOME_STRUCT_HPP
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
extern "C" { extern "C" {
typedef struct { typedef struct {

2
Autocoders/Python/test/serialize_user/UserSerializer.hpp
View File

@ -2,7 +2,7 @@
#define EXAMPLE_TYPE_HPP #define EXAMPLE_TYPE_HPP
// A hand-coded serializable // A hand-coded serializable
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#include <Autocoders/Python/test/serialize_user/SomeStruct.hpp> #include <Autocoders/Python/test/serialize_user/SomeStruct.hpp>
#if FW_SERIALIZABLE_TO_STRING #if FW_SERIALIZABLE_TO_STRING

2
Autocoders/Python/test/testgen/MathSenderComponentImpl.cpp
View File

@ -12,7 +12,7 @@
#include <Autocoders/Python/test/testgen/MathSenderComponentImpl.hpp> #include <Autocoders/Python/test/testgen/MathSenderComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace Ref { namespace Ref {

2
CFDP/Checksum/Checksum.hpp
View File

@ -13,7 +13,7 @@
#ifndef CFDP_Checksum_HPP #ifndef CFDP_Checksum_HPP
#define CFDP_Checksum_HPP #define CFDP_Checksum_HPP
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace CFDP { namespace CFDP {

2
Drv/BlockDriver/BlockDriverImpl.cpp
View File

@ -1,5 +1,5 @@
#include <Drv/BlockDriver/BlockDriverImpl.hpp> #include <Drv/BlockDriver/BlockDriverImpl.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>
namespace Drv { namespace Drv {

2
Drv/DataTypes/DataBuffer.hpp
View File

@ -1,7 +1,7 @@
#ifndef _DrvDataBuffer_hpp_ #ifndef _DrvDataBuffer_hpp_
#define _DrvDataBuffer_hpp_ #define _DrvDataBuffer_hpp_
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
namespace Drv { namespace Drv {

2
Drv/Ip/IpSocket.cpp
View File

@ -12,7 +12,7 @@
#include <cstring> #include <cstring>
#include <Drv/Ip/IpSocket.hpp> #include <Drv/Ip/IpSocket.hpp>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/StringUtils.hpp> #include <Fw/Types/StringUtils.hpp>
#include <sys/time.h> #include <sys/time.h>

2
Drv/Ip/IpSocket.hpp
View File

@ -12,7 +12,7 @@
#ifndef DRV_IP_IPHELPER_HPP_ #ifndef DRV_IP_IPHELPER_HPP_
#define DRV_IP_IPHELPER_HPP_ #define DRV_IP_IPHELPER_HPP_
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <IpCfg.hpp> #include <IpCfg.hpp>
#include <Os/Mutex.hpp> #include <Os/Mutex.hpp>

2
Drv/Ip/TcpClientSocket.cpp
View File

@ -12,7 +12,7 @@
#include <Drv/Ip/TcpClientSocket.hpp> #include <Drv/Ip/TcpClientSocket.hpp>
#include <Fw/Logger/Logger.hpp> #include <Fw/Logger/Logger.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#ifdef TGT_OS_TYPE_VXWORKS #ifdef TGT_OS_TYPE_VXWORKS
#include <socket.h> #include <socket.h>

2
Drv/Ip/TcpClientSocket.hpp
View File

@ -12,7 +12,7 @@
#ifndef DRV_TCPCLIENT_TCPHELPER_HPP_ #ifndef DRV_TCPCLIENT_TCPHELPER_HPP_
#define DRV_TCPCLIENT_TCPHELPER_HPP_ #define DRV_TCPCLIENT_TCPHELPER_HPP_
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Drv/Ip/IpSocket.hpp> #include <Drv/Ip/IpSocket.hpp>
#include <IpCfg.hpp> #include <IpCfg.hpp>

2
Drv/Ip/TcpServerSocket.cpp
View File

@ -11,7 +11,7 @@
// ====================================================================== // ======================================================================
#include <Drv/Ip/TcpServerSocket.hpp> #include <Drv/Ip/TcpServerSocket.hpp>
#include <Fw/Logger/Logger.hpp> #include <Fw/Logger/Logger.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#ifdef TGT_OS_TYPE_VXWORKS #ifdef TGT_OS_TYPE_VXWORKS

2
Drv/Ip/TcpServerSocket.hpp
View File

@ -12,7 +12,7 @@
#ifndef DRV_TCPSERVER_TCPHELPER_HPP_ #ifndef DRV_TCPSERVER_TCPHELPER_HPP_
#define DRV_TCPSERVER_TCPHELPER_HPP_ #define DRV_TCPSERVER_TCPHELPER_HPP_
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Drv/Ip/IpSocket.hpp> #include <Drv/Ip/IpSocket.hpp>
#include <IpCfg.hpp> #include <IpCfg.hpp>

2
Drv/Ip/UdpSocket.cpp
View File

@ -12,7 +12,7 @@
#include <Drv/Ip/UdpSocket.hpp> #include <Drv/Ip/UdpSocket.hpp>
#include <Fw/Logger/Logger.hpp> #include <Fw/Logger/Logger.hpp>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/StringUtils.hpp> #include <Fw/Types/StringUtils.hpp>
#ifdef TGT_OS_TYPE_VXWORKS #ifdef TGT_OS_TYPE_VXWORKS

2
Drv/Ip/UdpSocket.hpp
View File

@ -12,7 +12,7 @@
#ifndef DRV_IP_UDPSOCKET_HPP_ #ifndef DRV_IP_UDPSOCKET_HPP_
#define DRV_IP_UDPSOCKET_HPP_ #define DRV_IP_UDPSOCKET_HPP_
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Drv/Ip/IpSocket.hpp> #include <Drv/Ip/IpSocket.hpp>
#include <IpCfg.hpp> #include <IpCfg.hpp>

2
Drv/Ip/test/ut/PortSelector.hpp
View File

@ -1,7 +1,7 @@
// //
// Created by mstarch on 12/10/20. // Created by mstarch on 12/10/20.
// //
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#ifndef DRV_TEST_PORTSELECTOR_HPP #ifndef DRV_TEST_PORTSELECTOR_HPP
#define DRV_TEST_PORTSELECTOR_HPP #define DRV_TEST_PORTSELECTOR_HPP

2
Drv/Ip/test/ut/SocketTestHelper.hpp
View File

@ -1,7 +1,7 @@
// //
// Created by mstarch on 12/10/20. // Created by mstarch on 12/10/20.
// //
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw//Buffer/Buffer.hpp> #include <Fw//Buffer/Buffer.hpp>
#include <Drv/Ip/IpSocket.hpp> #include <Drv/Ip/IpSocket.hpp>

2
Drv/LinuxGpioDriver/LinuxGpioDriverComponentImpl.cpp
View File

@ -12,7 +12,7 @@
#include <Drv/LinuxGpioDriver/LinuxGpioDriverComponentImpl.hpp> #include <Drv/LinuxGpioDriver/LinuxGpioDriverComponentImpl.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Os/TaskString.hpp> #include <Os/TaskString.hpp>
// TODO make proper static constants for these // TODO make proper static constants for these

2
Drv/LinuxGpioDriver/LinuxGpioDriverComponentImplCommon.cpp
View File

@ -12,7 +12,7 @@
#include <Drv/LinuxGpioDriver/LinuxGpioDriverComponentImpl.hpp> #include <Drv/LinuxGpioDriver/LinuxGpioDriverComponentImpl.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
namespace Drv { namespace Drv {

2
Drv/LinuxGpioDriver/LinuxGpioDriverComponentImplStub.cpp
View File

@ -12,7 +12,7 @@
#include <Drv/LinuxGpioDriver/LinuxGpioDriverComponentImpl.hpp> #include <Drv/LinuxGpioDriver/LinuxGpioDriverComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace Drv { namespace Drv {

2
Drv/LinuxI2cDriver/LinuxI2cDriver.cpp
View File

@ -11,7 +11,7 @@
// ====================================================================== // ======================================================================
#include "Fw/Types/Assert.hpp" #include "Fw/Types/Assert.hpp"
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
#include <Drv/LinuxI2cDriver/LinuxI2cDriver.hpp> #include <Drv/LinuxI2cDriver/LinuxI2cDriver.hpp>
#include <Fw/Logger/Logger.hpp> #include <Fw/Logger/Logger.hpp>

2
Drv/LinuxI2cDriver/LinuxI2cDriverStub.cpp
View File

@ -11,7 +11,7 @@
// ====================================================================== // ======================================================================
#include "Fw/Types/Assert.hpp" #include "Fw/Types/Assert.hpp"
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
#include <Drv/LinuxI2cDriver/LinuxI2cDriver.hpp> #include <Drv/LinuxI2cDriver/LinuxI2cDriver.hpp>
#define DEBUG_PRINT 0 #define DEBUG_PRINT 0

2
Drv/LinuxSpiDriver/LinuxSpiDriverComponentImpl.cpp
View File

@ -11,7 +11,7 @@
// ====================================================================== // ======================================================================
#include <Drv/LinuxSpiDriver/LinuxSpiDriverComponentImpl.hpp> #include <Drv/LinuxSpiDriver/LinuxSpiDriverComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>
#include <cstdint> #include <cstdint>

2
Drv/LinuxSpiDriver/LinuxSpiDriverComponentImplCommon.cpp
View File

@ -11,7 +11,7 @@
// ====================================================================== // ======================================================================
#include <Drv/LinuxSpiDriver/LinuxSpiDriverComponentImpl.hpp> #include <Drv/LinuxSpiDriver/LinuxSpiDriverComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace Drv { namespace Drv {

2
Drv/LinuxSpiDriver/LinuxSpiDriverComponentImplStub.cpp
View File

@ -11,7 +11,7 @@
// ====================================================================== // ======================================================================
#include <Drv/LinuxSpiDriver/LinuxSpiDriverComponentImpl.hpp> #include <Drv/LinuxSpiDriver/LinuxSpiDriverComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace Drv { namespace Drv {

2
Drv/TcpClient/TcpClientComponentImpl.cpp
View File

@ -11,7 +11,7 @@
// ====================================================================== // ======================================================================
#include <Drv/TcpClient/TcpClientComponentImpl.hpp> #include <Drv/TcpClient/TcpClientComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
#include "Fw/Types/Assert.hpp" #include "Fw/Types/Assert.hpp"

2
Drv/TcpServer/TcpServerComponentImpl.cpp
View File

@ -11,7 +11,7 @@
// ====================================================================== // ======================================================================
#include <Drv/TcpServer/TcpServerComponentImpl.hpp> #include <Drv/TcpServer/TcpServerComponentImpl.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
#include "Fw/Types/Assert.hpp" #include "Fw/Types/Assert.hpp"
namespace Drv { namespace Drv {

2
Drv/Udp/UdpComponentImpl.cpp
View File

@ -12,7 +12,7 @@
#include <Drv/Udp/UdpComponentImpl.hpp> #include <Drv/Udp/UdpComponentImpl.hpp>
#include <IpCfg.hpp> #include <IpCfg.hpp>
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
#include "Fw/Types/Assert.hpp" #include "Fw/Types/Assert.hpp"

2
Fw/Buffer/Buffer.cpp
View File

@ -11,7 +11,7 @@
// ====================================================================== // ======================================================================
#include <Fw/Buffer/Buffer.hpp> #include <Fw/Buffer/Buffer.hpp>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#if FW_SERIALIZABLE_TO_STRING #if FW_SERIALIZABLE_TO_STRING
#include <Fw/Types/String.hpp> #include <Fw/Types/String.hpp>

2
Fw/Buffer/Buffer.hpp
View File

@ -12,7 +12,7 @@
#ifndef BUFFER_HPP_ #ifndef BUFFER_HPP_
#define BUFFER_HPP_ #define BUFFER_HPP_
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#if FW_SERIALIZABLE_TO_STRING #if FW_SERIALIZABLE_TO_STRING
#include <Fw/Types/StringType.hpp> #include <Fw/Types/StringType.hpp>

2
Fw/Buffer/test/ut/TestBuffer.cpp
View File

@ -2,7 +2,7 @@
// Created by mstarch on 11/13/20. // Created by mstarch on 11/13/20.
// //
#include "Fw/Buffer/Buffer.hpp" #include "Fw/Buffer/Buffer.hpp"
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
#include <gtest/gtest.h> #include <gtest/gtest.h>

1
Fw/Cfg/ConfigCheck.cpp
View File

@ -11,7 +11,6 @@
*/ */
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/BasicTypes.hpp>
// Check that command/telemetry strings are not larger than an argument buffer // Check that command/telemetry strings are not larger than an argument buffer

3
Fw/Cmd/CmdArgBuffer.hpp
View File

@ -12,9 +12,8 @@
#ifndef FW_CMD_ARG_BUFFER_HPP #ifndef FW_CMD_ARG_BUFFER_HPP
#define FW_CMD_ARG_BUFFER_HPP #define FW_CMD_ARG_BUFFER_HPP
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/Serializable.hpp>
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>
namespace Fw { namespace Fw {

3
Fw/Cmd/CmdString.hpp
View File

@ -1,9 +1,8 @@
#ifndef FW_CMD_STRING_TYPE_HPP #ifndef FW_CMD_STRING_TYPE_HPP
#define FW_CMD_STRING_TYPE_HPP #define FW_CMD_STRING_TYPE_HPP
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/StringType.hpp>
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>
namespace Fw { namespace Fw {

1
Fw/Com/ComBuffer.hpp
View File

@ -13,7 +13,6 @@
#define FW_COM_BUFFER_HPP #define FW_COM_BUFFER_HPP
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
namespace Fw { namespace Fw {

2
Fw/FilePacket/FilePacket.hpp
View File

@ -15,7 +15,7 @@
#include <CFDP/Checksum/Checksum.hpp> #include <CFDP/Checksum/Checksum.hpp>
#include <Fw/Buffer/Buffer.hpp> #include <Fw/Buffer/Buffer.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/SerialBuffer.hpp> #include <Fw/Types/SerialBuffer.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>

1
Fw/Log/LogBuffer.hpp
View File

@ -13,7 +13,6 @@
#define FW_LOG_BUFFER_HPP #define FW_LOG_BUFFER_HPP
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>

3
Fw/Log/LogString.hpp
View File

@ -1,9 +1,8 @@
#ifndef FW_LOG_STRING_TYPE_HPP #ifndef FW_LOG_STRING_TYPE_HPP
#define FW_LOG_STRING_TYPE_HPP #define FW_LOG_STRING_TYPE_HPP
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/StringType.hpp>
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>
namespace Fw { namespace Fw {

3
Fw/Log/TextLogString.hpp
View File

@ -1,9 +1,8 @@
#ifndef FW_TEXT_LOG_STRING_TYPE_HPP #ifndef FW_TEXT_LOG_STRING_TYPE_HPP
#define FW_TEXT_LOG_STRING_TYPE_HPP #define FW_TEXT_LOG_STRING_TYPE_HPP
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/StringType.hpp>
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>
namespace Fw { namespace Fw {

12
Fw/Logger/LogAssert.cpp
View File

@ -36,12 +36,12 @@ namespace Fw {
FILE_NAME_ARG file, FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo, NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs, NATIVE_UINT_TYPE numArgs,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4, FwAssertArgType arg4,
AssertArg arg5, FwAssertArgType arg5,
AssertArg arg6 FwAssertArgType arg6
) { ) {
// Assumption is that file (when string) goes back to static macro in the code and will persist // Assumption is that file (when string) goes back to static macro in the code and will persist
switch (numArgs) { switch (numArgs) {

12
Fw/Logger/LogAssert.hpp
View File

@ -22,12 +22,12 @@ namespace Fw {
FILE_NAME_ARG file, FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo, NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs, NATIVE_UINT_TYPE numArgs,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4, FwAssertArgType arg4,
AssertArg arg5, FwAssertArgType arg5,
AssertArg arg6 FwAssertArgType arg6
); );
void printAssert(const CHAR* msg); void printAssert(const CHAR* msg);
void doAssert(); void doAssert();

2
Fw/Logger/Logger.hpp
View File

@ -9,7 +9,7 @@
#ifndef _Fw_Logger_hpp_ #ifndef _Fw_Logger_hpp_
#define _Fw_Logger_hpp_ #define _Fw_Logger_hpp_
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
namespace Fw { namespace Fw {
class Logger { class Logger {

2
Fw/Logger/test/ut/FakeLogger.hpp
View File

@ -7,7 +7,7 @@
* @author mstarch * @author mstarch
*/ */
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Logger/Logger.hpp> #include <Fw/Logger/Logger.hpp>
#ifndef FPRIME_FAKELOGGER_HPP #ifndef FPRIME_FAKELOGGER_HPP

2
Fw/Logger/test/ut/LoggerRules.hpp
View File

@ -15,7 +15,7 @@
#ifndef FPRIME_LOGGERRULES_HPP #ifndef FPRIME_LOGGERRULES_HPP
#define FPRIME_LOGGERRULES_HPP #define FPRIME_LOGGERRULES_HPP
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/String.hpp> #include <Fw/Types/String.hpp>
#include <Fw/Logger/test/ut/FakeLogger.hpp> #include <Fw/Logger/test/ut/FakeLogger.hpp>
#include <STest/STest/Rule/Rule.hpp> #include <STest/STest/Rule/Rule.hpp>

1
Fw/Obj/ObjBase.hpp
View File

@ -13,7 +13,6 @@
#ifndef FW_OBJ_BASE_HPP #ifndef FW_OBJ_BASE_HPP
#define FW_OBJ_BASE_HPP #define FW_OBJ_BASE_HPP
#include <Fw/Types/BasicTypes.hpp>
#include <FpConfig.hpp> #include <FpConfig.hpp>
namespace Fw { namespace Fw {

1
Fw/Obj/SimpleObjRegistry.hpp
View File

@ -21,7 +21,6 @@
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Obj/ObjBase.hpp> #include <Fw/Obj/ObjBase.hpp>
#include <Fw/Types/BasicTypes.hpp>
#if FW_OBJECT_REGISTRATION == 1 #if FW_OBJECT_REGISTRATION == 1

2
Fw/Port/InputPortBase.cpp
View File

@ -1,8 +1,6 @@
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Port/InputPortBase.hpp> #include <Fw/Port/InputPortBase.hpp>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>
#include <Fw/Types/BasicTypes.hpp>
#include <cstdio> #include <cstdio>
namespace Fw { namespace Fw {

2
Fw/Port/InputPortBase.hpp
View File

@ -2,9 +2,7 @@
#define FW_INPUT_PORT_BASE_HPP #define FW_INPUT_PORT_BASE_HPP
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Obj/ObjBase.hpp> #include <Fw/Obj/ObjBase.hpp>
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#include <Fw/Comp/PassiveComponentBase.hpp> #include <Fw/Comp/PassiveComponentBase.hpp>
#include <Fw/Port/PortBase.hpp> #include <Fw/Port/PortBase.hpp>

2
Fw/Port/OutputPortBase.cpp
View File

@ -1,7 +1,5 @@
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Port/OutputPortBase.hpp> #include <Fw/Port/OutputPortBase.hpp>
#include <Fw/Types/BasicTypes.hpp>
#include <Os/Log.hpp> #include <Os/Log.hpp>
#include <cstdio> #include <cstdio>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>

2
Fw/Port/OutputPortBase.hpp
View File

@ -2,9 +2,7 @@
#define FW_OUTPUT_PORT_BASE_HPP #define FW_OUTPUT_PORT_BASE_HPP
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Obj/ObjBase.hpp> #include <Fw/Obj/ObjBase.hpp>
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#include <Fw/Port/InputPortBase.hpp> #include <Fw/Port/InputPortBase.hpp>

2
Fw/Port/PortBase.cpp
View File

@ -1,5 +1,5 @@
#include <Fw/Port/PortBase.hpp> #include <Fw/Port/PortBase.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Logger/Logger.hpp> #include <Fw/Logger/Logger.hpp>
#include <cstdio> #include <cstdio>
#include "Fw/Types/Assert.hpp" #include "Fw/Types/Assert.hpp"

2
Fw/Port/PortBase.hpp
View File

@ -2,7 +2,7 @@
#define FW_PORT_BASE_HPP #define FW_PORT_BASE_HPP
#include <Fw/Obj/ObjBase.hpp> #include <Fw/Obj/ObjBase.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#if FW_PORT_TRACING == 1 #if FW_PORT_TRACING == 1

1
Fw/Prm/PrmBuffer.hpp
View File

@ -13,7 +13,6 @@
#define FW_PRM_BUFFER_HPP #define FW_PRM_BUFFER_HPP
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>

3
Fw/Prm/PrmString.hpp
View File

@ -1,9 +1,8 @@
#ifndef FW_PRM_STRING_TYPE_HPP #ifndef FW_PRM_STRING_TYPE_HPP
#define FW_PRM_STRING_TYPE_HPP #define FW_PRM_STRING_TYPE_HPP
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/StringType.hpp>
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>
namespace Fw { namespace Fw {

2
Fw/SerializableFile/test/ut/Test.cpp
View File

@ -4,7 +4,7 @@
#include <cstring> #include <cstring>
#include <cstdio> #include <cstdio>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>
#include <Fw/Types/MallocAllocator.hpp> #include <Fw/Types/MallocAllocator.hpp>
#include <Fw/SerializableFile/SerializableFile.hpp> #include <Fw/SerializableFile/SerializableFile.hpp>

2
Fw/Test/String.hpp
View File

@ -1,7 +1,7 @@
#ifndef TEST_STRING_TYPE_HPP #ifndef TEST_STRING_TYPE_HPP
#define TEST_STRING_TYPE_HPP #define TEST_STRING_TYPE_HPP
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp> #include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>

28
Fw/Test/UnitTestAssert.cpp
View File

@ -43,9 +43,9 @@ namespace Test {
void UnitTestAssert::doAssert() { void UnitTestAssert::doAssert() {
this->m_assertFailed = true; this->m_assertFailed = true;
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT #if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
(void)fprintf(stderr,"Assert File: 0x%x, Line: %u\n", this->m_file, this->m_lineNo); (void)fprintf(stderr,"Assert File: 0x%x, Line: %" PRI_FwAssertArgType "\n", this->m_file, this->m_lineNo);
#else #else
(void)fprintf(stderr,"Assert File: %s, Line: %u\n", this->m_file.toChar(), this->m_lineNo); (void)fprintf(stderr,"Assert File: %s, Line: %" PRI_FwAssertArgType "\n", this->m_file.toChar(), this->m_lineNo);
#endif #endif
} }
@ -53,12 +53,12 @@ namespace Test {
FILE_NAME_ARG file, FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo, NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs, NATIVE_UINT_TYPE numArgs,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4, FwAssertArgType arg4,
AssertArg arg5, FwAssertArgType arg5,
AssertArg arg6 FwAssertArgType arg6
) { ) {
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT #if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
@ -82,12 +82,12 @@ namespace Test {
File& file, File& file,
NATIVE_UINT_TYPE& lineNo, NATIVE_UINT_TYPE& lineNo,
NATIVE_UINT_TYPE& numArgs, NATIVE_UINT_TYPE& numArgs,
AssertArg& arg1, FwAssertArgType& arg1,
AssertArg& arg2, FwAssertArgType& arg2,
AssertArg& arg3, FwAssertArgType& arg3,
AssertArg& arg4, FwAssertArgType& arg4,
AssertArg& arg5, FwAssertArgType& arg5,
AssertArg& arg6 FwAssertArgType& arg6
) const { ) const {
file = this->m_file; file = this->m_file;

36
Fw/Test/UnitTestAssert.hpp
View File

@ -34,24 +34,24 @@ namespace Test {
FILE_NAME_ARG file, FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo, NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs, NATIVE_UINT_TYPE numArgs,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4, FwAssertArgType arg4,
AssertArg arg5, FwAssertArgType arg5,
AssertArg arg6 FwAssertArgType arg6
); );
// retrieves assertion failure values // retrieves assertion failure values
void retrieveAssert( void retrieveAssert(
File& file, File& file,
NATIVE_UINT_TYPE& lineNo, NATIVE_UINT_TYPE& lineNo,
NATIVE_UINT_TYPE& numArgs, NATIVE_UINT_TYPE& numArgs,
AssertArg& arg1, FwAssertArgType& arg1,
AssertArg& arg2, FwAssertArgType& arg2,
AssertArg& arg3, FwAssertArgType& arg3,
AssertArg& arg4, FwAssertArgType& arg4,
AssertArg& arg5, FwAssertArgType& arg5,
AssertArg& arg6 FwAssertArgType& arg6
) const; ) const;
// check whether assertion failure occurred // check whether assertion failure occurred
@ -64,12 +64,12 @@ namespace Test {
File m_file; File m_file;
NATIVE_UINT_TYPE m_lineNo; NATIVE_UINT_TYPE m_lineNo;
NATIVE_INT_TYPE m_numArgs; NATIVE_INT_TYPE m_numArgs;
AssertArg m_arg1; FwAssertArgType m_arg1;
AssertArg m_arg2; FwAssertArgType m_arg2;
AssertArg m_arg3; FwAssertArgType m_arg3;
AssertArg m_arg4; FwAssertArgType m_arg4;
AssertArg m_arg5; FwAssertArgType m_arg5;
AssertArg m_arg6; FwAssertArgType m_arg6;
// Whether an assertion failed // Whether an assertion failed
bool m_assertFailed; bool m_assertFailed;

2
Fw/Time/Time.cpp
View File

@ -1,5 +1,5 @@
#include <Fw/Time/Time.hpp> #include <Fw/Time/Time.hpp>
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
namespace Fw { namespace Fw {
const Time ZERO_TIME = Time(); const Time ZERO_TIME = Time();

3
Fw/Time/Time.hpp
View File

@ -1,10 +1,9 @@
#ifndef FW_TIME_HPP #ifndef FW_TIME_HPP
#define FW_TIME_HPP #define FW_TIME_HPP
#include <Fw/Types/BasicTypes.hpp> #include <FpConfig.hpp>
#include <Fw/Types/Assert.hpp> #include <Fw/Types/Assert.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#include <FpConfig.hpp>
namespace Fw { namespace Fw {
class Time: public Serializable { class Time: public Serializable {

1
Fw/Tlm/TlmBuffer.hpp
View File

@ -12,7 +12,6 @@
#define FW_TLM_BUFFER_HPP #define FW_TLM_BUFFER_HPP
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/Serializable.hpp> #include <Fw/Types/Serializable.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>

3
Fw/Tlm/TlmString.hpp
View File

@ -1,9 +1,8 @@
#ifndef FW_TLM_STRING_TYPE_HPP #ifndef FW_TLM_STRING_TYPE_HPP
#define FW_TLM_STRING_TYPE_HPP #define FW_TLM_STRING_TYPE_HPP
#include <Fw/Types/BasicTypes.hpp>
#include <Fw/Types/StringType.hpp>
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/StringType.hpp>
#include <Fw/Cfg/SerIds.hpp> #include <Fw/Cfg/SerIds.hpp>
namespace Fw { namespace Fw {

1
Fw/Trap/TrapHandler.hpp
View File

@ -1,7 +1,6 @@
#ifndef FW_TRAP_HPP #ifndef FW_TRAP_HPP
#define FW_TRAP_HPP #define FW_TRAP_HPP
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/BasicTypes.hpp>
namespace Fw { namespace Fw {
/** /**

70
Fw/Types/Assert.cpp
View File

@ -10,9 +10,9 @@
#else #else
#if FW_ASSERT_LEVEL == FW_FILEID_ASSERT #if FW_ASSERT_LEVEL == FW_FILEID_ASSERT
#define fileIdFs "Assert file ID 0x%08X: Line: %d " #define fileIdFs "Assert file ID 0x%08X: Line: %" PRI_FwAssertArgType
#else #else
#define fileIdFs "Assert file \"%s\": Line: %d " #define fileIdFs "Assert file \"%s\": Line: %" PRI_FwAssertArgType
#endif #endif
namespace Fw { namespace Fw {
@ -26,12 +26,12 @@ namespace Fw {
FILE_NAME_ARG file, FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo, NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs, NATIVE_UINT_TYPE numArgs,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4, FwAssertArgType arg4,
AssertArg arg5, FwAssertArgType arg5,
AssertArg arg6, FwAssertArgType arg6,
CHAR* destBuffer, CHAR* destBuffer,
NATIVE_INT_TYPE buffSize NATIVE_INT_TYPE buffSize
) { ) {
@ -82,12 +82,12 @@ namespace Fw {
FILE_NAME_ARG file, FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo, NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs, NATIVE_UINT_TYPE numArgs,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4, FwAssertArgType arg4,
AssertArg arg5, FwAssertArgType arg5,
AssertArg arg6 FwAssertArgType arg6
) )
{ {
CHAR destBuffer[FW_ASSERT_DFL_MSG_LEN]; CHAR destBuffer[FW_ASSERT_DFL_MSG_LEN];
@ -149,7 +149,7 @@ namespace Fw {
} }
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo,
AssertArg arg1) { FwAssertArgType arg1) {
if (nullptr == s_assertHook) { if (nullptr == s_assertHook) {
CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN]; CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN];
defaultReportAssert( defaultReportAssert(
@ -174,8 +174,8 @@ namespace Fw {
} }
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2) { FwAssertArgType arg2) {
if (nullptr == s_assertHook) { if (nullptr == s_assertHook) {
CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN]; CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN];
defaultReportAssert( defaultReportAssert(
@ -199,9 +199,9 @@ namespace Fw {
} }
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3) { FwAssertArgType arg3) {
if (nullptr == s_assertHook) { if (nullptr == s_assertHook) {
CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN]; CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN];
defaultReportAssert( defaultReportAssert(
@ -225,10 +225,10 @@ namespace Fw {
} }
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4) { FwAssertArgType arg4) {
if (nullptr == s_assertHook) { if (nullptr == s_assertHook) {
CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN]; CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN];
defaultReportAssert( defaultReportAssert(
@ -252,11 +252,11 @@ namespace Fw {
} }
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4, FwAssertArgType arg4,
AssertArg arg5) { FwAssertArgType arg5) {
if (nullptr == s_assertHook) { if (nullptr == s_assertHook) {
CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN]; CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN];
defaultReportAssert( defaultReportAssert(
@ -280,12 +280,12 @@ namespace Fw {
} }
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4, FwAssertArgType arg4,
AssertArg arg5, FwAssertArgType arg5,
AssertArg arg6) { FwAssertArgType arg6) {
if (nullptr == s_assertHook) { if (nullptr == s_assertHook) {
CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN]; CHAR assertMsg[FW_ASSERT_DFL_MSG_LEN];
defaultReportAssert( defaultReportAssert(

25
Fw/Types/Assert.hpp
View File

@ -2,7 +2,6 @@
#define FW_ASSERT_HPP #define FW_ASSERT_HPP
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/BasicTypes.hpp>
#if FW_ASSERT_LEVEL == FW_NO_ASSERT #if FW_ASSERT_LEVEL == FW_NO_ASSERT
#define FW_ASSERT(...) #define FW_ASSERT(...)
@ -36,12 +35,12 @@
namespace Fw { namespace Fw {
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo) CLANG_ANALYZER_NORETURN; //!< Assert with no arguments NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo) CLANG_ANALYZER_NORETURN; //!< Assert with no arguments
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, AssertArg arg1) CLANG_ANALYZER_NORETURN; //!< Assert with one argument NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, FwAssertArgType arg1) CLANG_ANALYZER_NORETURN; //!< Assert with one argument
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, AssertArg arg1, AssertArg arg2) CLANG_ANALYZER_NORETURN; //!< Assert with two arguments NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, FwAssertArgType arg1, FwAssertArgType arg2) CLANG_ANALYZER_NORETURN; //!< Assert with two arguments
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, AssertArg arg1, AssertArg arg2, AssertArg arg3) CLANG_ANALYZER_NORETURN; //!< Assert with three arguments NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, FwAssertArgType arg1, FwAssertArgType arg2, FwAssertArgType arg3) CLANG_ANALYZER_NORETURN; //!< Assert with three arguments
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, AssertArg arg1, AssertArg arg2, AssertArg arg3, AssertArg arg4) CLANG_ANALYZER_NORETURN; //!< Assert with four arguments NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, FwAssertArgType arg1, FwAssertArgType arg2, FwAssertArgType arg3, FwAssertArgType arg4) CLANG_ANALYZER_NORETURN; //!< Assert with four arguments
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, AssertArg arg1, AssertArg arg2, AssertArg arg3, AssertArg arg4, AssertArg arg5) CLANG_ANALYZER_NORETURN; //!< Assert with five arguments NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, FwAssertArgType arg1, FwAssertArgType arg2, FwAssertArgType arg3, FwAssertArgType arg4, FwAssertArgType arg5) CLANG_ANALYZER_NORETURN; //!< Assert with five arguments
NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, AssertArg arg1, AssertArg arg2, AssertArg arg3, AssertArg arg4, AssertArg arg5, AssertArg arg6) CLANG_ANALYZER_NORETURN; //!< Assert with six arguments NATIVE_INT_TYPE SwAssert(FILE_NAME_ARG file, NATIVE_UINT_TYPE lineNo, FwAssertArgType arg1, FwAssertArgType arg2, FwAssertArgType arg3, FwAssertArgType arg4, FwAssertArgType arg5, FwAssertArgType arg6) CLANG_ANALYZER_NORETURN; //!< Assert with six arguments
} }
// Base class for declaring an assert hook // Base class for declaring an assert hook
@ -59,12 +58,12 @@ namespace Fw {
FILE_NAME_ARG file, FILE_NAME_ARG file,
NATIVE_UINT_TYPE lineNo, NATIVE_UINT_TYPE lineNo,
NATIVE_UINT_TYPE numArgs, NATIVE_UINT_TYPE numArgs,
AssertArg arg1, FwAssertArgType arg1,
AssertArg arg2, FwAssertArgType arg2,
AssertArg arg3, FwAssertArgType arg3,
AssertArg arg4, FwAssertArgType arg4,
AssertArg arg5, FwAssertArgType arg5,
AssertArg arg6 FwAssertArgType arg6
); );
// default reportAssert() will call this when the message is built // default reportAssert() will call this when the message is built
// override it to do another kind of print. printf by default // override it to do another kind of print. printf by default

109
Fw/Types/BasicTypes.hpp
View File

@ -1,7 +1,7 @@
/** /**
* \file * \file
* \author T. Canham * \author T. Canham
* \brief Declares ISF basic types * \brief Declares fprime basic types
* *
* \copyright * \copyright
* Copyright 2009-2016, by the California Institute of Technology. * Copyright 2009-2016, by the California Institute of Technology.
@ -13,90 +13,52 @@
#ifndef FW_BASIC_TYPES_HPP #ifndef FW_BASIC_TYPES_HPP
#define FW_BASIC_TYPES_HPP #define FW_BASIC_TYPES_HPP
#include <FpConfig.hpp> #include <PlatformTypes.hpp>
#include <StandardTypes.hpp> // This header will be found be include paths by target. This hides different header files for each target.
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif // __cplusplus #endif // __cplusplus
// Define native integer/unsigned integer types
#ifdef _WRS_KERNEL
typedef int32_t NATIVE_INT_TYPE;
typedef uint32_t NATIVE_UINT_TYPE;
#else
// Allow overriding of native types for systems whose stdint.h is malformed
#ifndef FPRIME_OVERRIDE_NATIVE_TYPES
typedef int NATIVE_INT_TYPE; //!< native integer type declaration
typedef unsigned int NATIVE_UINT_TYPE; //!< native unsigned integer type declaration
#endif
#endif
#if defined __GNUC__ || __llvm__ #if defined __GNUC__ || __llvm__
// This is used to cast pointers to integers
// when a pointer needs to be stored generically.
// In order to avoid chopping off bits,
// the integer bit size needs to match
// the pointer bit size.
#ifdef __SIZEOF_POINTER__
#if __SIZEOF_POINTER__ == 8
#define POINTER_CAST U64
#elif __SIZEOF_POINTER__ == 4
#define POINTER_CAST U32
#elif __SIZEOF_POINTER__ == 2
#define POINTER_CAST U16
#else
#define POINTER_CAST U8
#endif
#elif defined (__i386) && __i386 == 1 // GCC 4.1.2
#define POINTER_CAST U32
#elif defined (__x86_64) && __x86_64 == 1 // GCC 4.1.2
#define POINTER_CAST U64
#elif defined (CPU) && defined (PPC604) && CPU == PPC604 // VxWorks 6.7 RAD750
#define POINTER_CAST U32
#elif defined (CPU) && defined(SPARC) && CPU == SPARC
#define POINTER_CAST U32
#else #else
#error Cannot get size of pointer cast! #error Unsupported compiler!
#endif #endif
#else
#error Unsupported compiler!
#endif
// compile-time assert
#define COMPILE_TIME_ASSERT( condition, name )\
do { \
enum { assert_failed_ ## name = 1/(condition) }; \
} while(0)
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
typedef int8_t I8; //!< 8-bit signed integer typedef int8_t I8; //!< 8-bit signed integer
typedef uint8_t U8; //!< 8-bit unsigned integer typedef uint8_t U8; //!< 8-bit unsigned integer
typedef U8 BYTE; //!< byte type typedef U8 BYTE; //!< byte type
typedef char CHAR;
#if FW_HAS_16_BIT #if FW_HAS_16_BIT
typedef int16_t I16; //!< 16-bit signed integer typedef int16_t I16; //!< 16-bit signed integer
typedef uint16_t U16; //!< 16-bit unsigned integer typedef uint16_t U16; //!< 16-bit unsigned integer
#endif #endif
#if FW_HAS_32_BIT #if FW_HAS_32_BIT
typedef uint32_t U32; //!< 32-bit signed integer typedef uint32_t U32; //!< 32-bit signed integer
typedef int32_t I32; //!< 32-bit unsigned integer typedef int32_t I32; //!< 32-bit unsigned integer
#endif #endif
#if FW_HAS_64_BIT #if FW_HAS_64_BIT
typedef int64_t I64; //!< 64-bit signed integer typedef int64_t I64; //!< 64-bit signed integer
typedef uint64_t U64; //!< 64-bit unsigned integer typedef uint64_t U64; //!< 64-bit unsigned integer
#endif #endif
typedef float F32; //!< 32-bit floating point typedef float F32; //!< 32-bit floating point
#if FW_HAS_F64 #if FW_HAS_F64
typedef double F64; //!< 64-bit floating point typedef double F64; //!< 64-bit floating point
#endif #endif
typedef char CHAR; typedef PlatformIntType NATIVE_INT_TYPE;
typedef PlatformUIntType NATIVE_UINT_TYPE;
typedef PlatformPointerCastType POINTER_CAST;
// compile-time assert
#define COMPILE_TIME_ASSERT( condition, name )\
do { \
enum { assert_failed_ ## name = 1/(condition) }; \
} while(0)
#define FW_NUM_ARRAY_ELEMENTS(a) (sizeof(a)/sizeof((a)[0])) //!< number of elements in an array #define FW_NUM_ARRAY_ELEMENTS(a) (sizeof(a)/sizeof((a)[0])) //!< number of elements in an array
@ -121,4 +83,33 @@ typedef char CHAR;
#endif // __cplusplus #endif // __cplusplus
/**
* BasicLimits:
*
* Limits for the fprime provided types. Implemented as a class with static
* constants to ensure that storage is not allocated although the definitions
* exist.
*/
struct BasicLimits : PlatformLimits {
static const int8_t I8_MIN = INT8_MIN;
static const int8_t I8_MAX = INT8_MAX;
static const uint8_t U8_MIN = 0;
static const uint8_t U8_MAX = UINT8_MAX;
static const I16 I16_MIN = INT16_MIN;
static const I16 I16_MAX = INT16_MAX;
static const U16 U16_MIN = 0;
static const U16 U16_MAX = UINT16_MAX;
static const I32 I32_MIN = INT32_MIN;
static const I32 I32_MAX = INT32_MAX;
static const U32 U32_MIN = 0;
static const U32 U32_MAX = UINT32_MAX;
static const I64 I64_MIN = INT64_MIN;
static const I64 I64_MAX = INT64_MAX;
static const U64 U64_MIN = 0;
static const U64 U64_MAX = UINT64_MAX;
};
#endif #endif

2
Fw/Types/ByteArray.hpp
View File

@ -13,7 +13,7 @@
#ifndef Fw_ByteArray_HPP #ifndef Fw_ByteArray_HPP
#define Fw_ByteArray_HPP #define Fw_ByteArray_HPP
#include "Fw/Types/BasicTypes.hpp" #include <FpConfig.hpp>
namespace Fw { namespace Fw {

1
Fw/Types/CAssert.hpp
View File

@ -9,7 +9,6 @@
#define FWCASSERT_HPP_ #define FWCASSERT_HPP_
#include <FpConfig.hpp> #include <FpConfig.hpp>
#include <Fw/Types/BasicTypes.hpp>
#if FW_ASSERT_LEVEL == FW_NO_ASSERT #if FW_ASSERT_LEVEL == FW_NO_ASSERT

5
Fw/Types/CMakeLists.txt
View File

@ -6,8 +6,9 @@
# #
# Note: using PROJECT_NAME as EXECUTABLE_NAME # Note: using PROJECT_NAME as EXECUTABLE_NAME
#### ####
set(SOURCE_FILES "${CMAKE_CURRENT_LIST_DIR}/Assert.cpp"
"${CMAKE_CURRENT_LIST_DIR}/Types.fpp" set(SOURCE_FILES "${CMAKE_CURRENT_LIST_DIR}/Types.fpp"
"${CMAKE_CURRENT_LIST_DIR}/Assert.cpp"
"${CMAKE_CURRENT_LIST_DIR}/String.cpp" "${CMAKE_CURRENT_LIST_DIR}/String.cpp"
"${CMAKE_CURRENT_LIST_DIR}/InternalInterfaceString.cpp" "${CMAKE_CURRENT_LIST_DIR}/InternalInterfaceString.cpp"
"${CMAKE_CURRENT_LIST_DIR}/MallocAllocator.cpp" "${CMAKE_CURRENT_LIST_DIR}/MallocAllocator.cpp"

Some files were not shown because too many files have changed in this diff Show More