EmaMaker
/
tc-homework2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

convert use of <cassert> to "ns3/assert.h"

Mathieu Lacage 2007-02-16 09:56:21 +01:00
parent 342ada342a
commit d9318db068
37 changed files with 150 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
samples/main-callback.cc
View File

@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#include "ns3/callback.h"
#include <cassert>
#include "ns3/assert.h"
#include <iostream>
using namespace ns3;
@ -30,7 +30,7 @@ int main (int argc, char *argv[])
// build callback instance which points to cbOne function
one = MakeCallback (&CbOne);
// this is not a null callback
assert (!one.IsNull ());
NS_ASSERT (!one.IsNull ());
// invoke cbOne function through callback instance
double retOne;
retOne = one (10.0, 20.0);
@ -42,7 +42,7 @@ int main (int argc, char *argv[])
// build callback instance which points to MyCb::cbTwo
two = MakeCallback (&MyCb::CbTwo, &cb);
// this is not a null callback
assert (!two.IsNull ());
NS_ASSERT (!two.IsNull ());
// invoke MyCb::cbTwo through callback instance
int retTwo;
retTwo = two (10.0);
@ -52,7 +52,7 @@ int main (int argc, char *argv[])
// invoking a null function pointer:
// it will crash.
//int retTwoNull = two (20.0);
assert (two.IsNull ());
NS_ASSERT (two.IsNull ());
return 0;
}

2
samples/main-ptr.cc
View File

@ -51,7 +51,7 @@ int main (int argc, char *argv[])
Ptr<A> a = new A ();
a->Method ();
Ptr<A> prev = StoreA (a);
assert (prev == 0);
NS_ASSERT (prev == 0);
}
{

38
src/common/buffer.cc
View File

@ -19,7 +19,7 @@
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include "buffer.h"
#include <cassert>
#include "ns3/assert.h"
#include <iostream>
//#define TRACE(x) std::cout << x << std::endl;
@ -38,7 +38,7 @@ Buffer::Allocate (uint32_t reqSize, uint32_t reqStart)
{
reqSize = 1;
}
assert (reqSize >= 1);
NS_ASSERT (reqSize >= 1);
uint32_t size = reqSize - 1 + sizeof (struct Buffer::BufferData);
uint8_t *b = new uint8_t [size];
struct BufferData *data = reinterpret_cast<struct Buffer::BufferData*>(b);
@ -60,7 +60,7 @@ Buffer::Deallocate (struct Buffer::BufferData *data)
void
Buffer::Recycle (struct Buffer::BufferData *data)
{
assert (data->m_count == 0);
NS_ASSERT (data->m_count == 0);
/* get rid of it if it is too small for later reuse. */
if (data->m_size < (Buffer::m_maxTotalAddStart + Buffer::m_maxTotalAddEnd))
{
@ -98,7 +98,7 @@ Buffer::Create (void)
}
struct Buffer::BufferData *data = Buffer::Allocate (m_maxTotalAddStart+m_maxTotalAddEnd,
m_maxTotalAddStart);
assert (data->m_count == 1);
NS_ASSERT (data->m_count == 1);
return data;
}
#else
@ -119,7 +119,7 @@ Buffer::Create (void)
}; // namespace ns3
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {
@ -127,7 +127,7 @@ namespace ns3 {
void
Buffer::AddAtStart (uint32_t start)
{
assert (m_start <= m_data->m_initialStart);
NS_ASSERT (m_start <= m_data->m_initialStart);
bool isDirty = m_data->m_count > 1 && m_start > m_data->m_dirtyStart;
if (m_start >= start && !isDirty)
{
@ -139,7 +139,7 @@ Buffer::AddAtStart (uint32_t start)
{
/* enough space but need to move data around to fit new data */
memmove (m_data->m_data + start, GetStart (), m_size);
assert (start > m_start);
NS_ASSERT (start > m_start);
m_data->m_initialStart += start;
m_start = 0;
m_size += start;
@ -163,7 +163,7 @@ Buffer::AddAtStart (uint32_t start)
else
{
/* enough space in the buffer but it is dirty ! */
assert (isDirty);
NS_ASSERT (isDirty);
struct Buffer::BufferData *newData = Buffer::Create ();
memcpy (newData->m_data + m_start, GetStart (), m_size);
newData->m_initialStart = m_data->m_initialStart;
@ -200,7 +200,7 @@ Buffer::AddAtStart (uint32_t start)
void
Buffer::AddAtEnd (uint32_t end)
{
assert (m_start <= m_data->m_initialStart);
NS_ASSERT (m_start <= m_data->m_initialStart);
bool isDirty = m_data->m_count > 1 &&
m_start + m_size < m_data->m_dirtyStart + m_data->m_dirtySize;
if (m_start + m_size + end <= m_data->m_size && !isDirty)
@ -213,7 +213,7 @@ Buffer::AddAtEnd (uint32_t end)
/* enough space but need to move data around to fit the extra data */
uint32_t newStart = m_data->m_size - (m_size + end);
memmove (m_data->m_data + newStart, GetStart (), m_size);
assert (newStart < m_start);
NS_ASSERT (newStart < m_start);
m_data->m_initialStart -= m_start - newStart;
m_start = newStart;
m_size += end;
@ -237,7 +237,7 @@ Buffer::AddAtEnd (uint32_t end)
else
{
/* enough space in the buffer but it is dirty ! */
assert (isDirty);
NS_ASSERT (isDirty);
struct Buffer::BufferData *newData = Buffer::Create ();
memcpy (newData->m_data + m_start, GetStart (), m_size);
newData->m_initialStart = m_data->m_initialStart;
@ -290,7 +290,7 @@ Buffer::RemoveAtStart (uint32_t start)
}
else
{
assert (m_data->m_initialStart >= m_start);
NS_ASSERT (m_data->m_initialStart >= m_start);
uint32_t zeroStart = m_data->m_initialStart - m_start;
uint32_t zeroEnd = zeroStart + m_zeroAreaSize;
uint32_t dataEnd = m_size + m_zeroAreaSize;
@ -306,7 +306,7 @@ Buffer::RemoveAtStart (uint32_t start)
m_start += zeroStart;
uint32_t zeroDelta = start - zeroStart;
m_zeroAreaSize -= zeroDelta;
assert (zeroDelta <= start);
NS_ASSERT (zeroDelta <= start);
m_size -= zeroStart;
}
else if (start <= dataEnd)
@ -346,12 +346,12 @@ Buffer::RemoveAtEnd (uint32_t end)
}
else
{
assert (m_data->m_initialStart >= m_start);
NS_ASSERT (m_data->m_initialStart >= m_start);
uint32_t zeroStart = m_data->m_initialStart - m_start;
uint32_t zeroEnd = zeroStart + m_zeroAreaSize;
uint32_t dataEnd = m_size + m_zeroAreaSize;
assert (zeroStart <= m_size);
assert (zeroEnd <= m_size + m_zeroAreaSize);
NS_ASSERT (zeroStart <= m_size);
NS_ASSERT (zeroEnd <= m_size + m_zeroAreaSize);
if (dataEnd <= end)
{
/* remove all buffer */
@ -362,7 +362,7 @@ Buffer::RemoveAtEnd (uint32_t end)
else if (dataEnd - zeroStart <= end)
{
/* remove end of buffer, zero area, part of start of buffer */
assert (end >= m_zeroAreaSize);
NS_ASSERT (end >= m_zeroAreaSize);
m_size -= end - m_zeroAreaSize;
m_zeroAreaSize = 0;
}
@ -406,8 +406,8 @@ Buffer::TransformIntoRealBuffer (void) const
{
if (m_zeroAreaSize != 0)
{
assert (m_data->m_initialStart >= m_start);
assert (m_size >= (m_data->m_initialStart - m_start));
NS_ASSERT (m_data->m_initialStart >= m_start);
NS_ASSERT (m_size >= (m_data->m_initialStart - m_start));
Buffer tmp;
tmp.AddAtStart (m_zeroAreaSize);
tmp.Begin ().WriteU8 (0, m_zeroAreaSize);

28
src/common/buffer.h
View File

@ -361,7 +361,7 @@ private:
need to be inline for performance reasons.
*************************************************/
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {
@ -375,7 +375,7 @@ Buffer::Buffer ()
{
m_start = 0;
}
assert (m_start <= m_data->m_size);
NS_ASSERT (m_start <= m_data->m_size);
}
Buffer::Buffer (uint32_t dataSize)
@ -388,7 +388,7 @@ Buffer::Buffer (uint32_t dataSize)
{
m_start = 0;
}
assert (m_start <= m_data->m_size);
NS_ASSERT (m_start <= m_data->m_size);
}
@ -399,7 +399,7 @@ Buffer::Buffer (Buffer const&o)
m_size (o.m_size)
{
m_data->m_count++;
assert (m_start <= m_data->m_size);
NS_ASSERT (m_start <= m_data->m_size);
}
Buffer &
@ -419,7 +419,7 @@ Buffer::operator = (Buffer const&o)
m_zeroAreaSize = o.m_zeroAreaSize;
m_start = o.m_start;
m_size = o.m_size;
assert (m_start <= m_data->m_size);
NS_ASSERT (m_start <= m_data->m_size);
return *this;
}
@ -475,31 +475,31 @@ Buffer::Iterator::Iterator (Buffer const*buffer, uint32_t current)
void
Buffer::Iterator::Next (void)
{
assert (m_current + 1 <= m_dataEnd);
NS_ASSERT (m_current + 1 <= m_dataEnd);
m_current++;
}
void
Buffer::Iterator::Prev (void)
{
assert (m_current >= 1);
NS_ASSERT (m_current >= 1);
m_current--;
}
void
Buffer::Iterator::Next (uint32_t delta)
{
assert (m_current + delta <= m_dataEnd);
NS_ASSERT (m_current + delta <= m_dataEnd);
m_current += delta;
}
void
Buffer::Iterator::Prev (uint32_t delta)
{
assert (m_current >= delta);
NS_ASSERT (m_current >= delta);
m_current -= delta;
}
int32_t
Buffer::Iterator::GetDistanceFrom (Iterator const &o) const
{
assert (m_data == o.m_data);
NS_ASSERT (m_data == o.m_data);
int32_t start = m_current;
int32_t end = o.m_current;
return end - start;
@ -519,7 +519,7 @@ Buffer::Iterator::IsStart (void) const
uint32_t
Buffer::Iterator::GetIndex (uint32_t n)
{
assert (
NS_ASSERT (
(m_current + n <= m_dataEnd) &&
((m_current + n <= m_zeroStart) ||
(m_current >= m_zeroEnd))
@ -540,9 +540,9 @@ Buffer::Iterator::GetIndex (uint32_t n)
void
Buffer::Iterator::Write (Iterator start, Iterator end)
{
assert (start.m_data == end.m_data);
assert (start.m_current <= end.m_current);
assert (m_data != start.m_data);
NS_ASSERT (start.m_data == end.m_data);
NS_ASSERT (start.m_current <= end.m_current);
NS_ASSERT (m_data != start.m_data);
uint32_t size = end.m_current - start.m_current;
uint8_t *src = start.m_data + start.GetIndex (size);
uint8_t *dest = m_data + GetIndex (size);

6
src/common/data-writer.cc
View File

@ -25,7 +25,7 @@
#include <sys/poll.h>
#include <fcntl.h>
#include <unistd.h>
#include <cassert>
#include "ns3/assert.h"
#include <string.h>
#include <list>
@ -71,7 +71,7 @@ void
DataWriterPrivate::Open (char const *filename)
{
m_fd = ::Open (filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
assert (m_fd != -1);
NS_ASSERT (m_fd != -1);
}
#ifndef min
@ -92,7 +92,7 @@ DataWriterPrivate::Write (uint8_t *buffer, uint32_t size)
{
ssize_t written = 0;
written = ::Write (m_fd, m_data, BUFFER_SIZE);
assert (written == BUFFER_SIZE);
NS_ASSERT (written == BUFFER_SIZE);
m_current = 0;
}
}

2
src/common/header.cc
View File

@ -20,7 +20,7 @@
*/
#include "header.h"
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {

8
src/common/packet.cc
View File

@ -19,7 +19,7 @@
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include "packet.h"
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {
@ -81,7 +81,7 @@ Packet::Peek (Header &header)
void
Packet::Remove (Header const &header)
{
assert (header.IsDeserialized ());
NS_ASSERT (header.IsDeserialized ());
m_buffer.RemoveAtStart (header.GetSize ());
}
void
@ -102,7 +102,7 @@ Packet::Peek (Trailer &trailer)
void
Packet::Remove (Trailer const &trailer)
{
assert (trailer.IsDeserialized ());
NS_ASSERT (trailer.IsDeserialized ());
m_buffer.RemoveAtEnd (trailer.GetSize ());
}
@ -123,7 +123,7 @@ Packet::AddAtEnd (Packet packet)
void
Packet::AddAtEnd (Packet packet, uint32_t start, uint32_t size)
{
assert (packet.GetSize () <= start + size);
NS_ASSERT (packet.GetSize () <= start + size);
Buffer src = packet.m_buffer;
m_buffer.AddAtEnd (src.GetSize ());
Buffer::Iterator destStart = m_buffer.End ();

8
src/common/tags.cc
View File

@ -30,7 +30,7 @@ TagRegistry::TagsData TagRegistry::m_registry;
void
TagRegistry::Record (std::string uuid, PrettyPrinter prettyPrinter)
{
assert (!m_sorted);
NS_ASSERT (!m_sorted);
m_registry.push_back (make_pair (uuid, prettyPrinter));
}
uint32_t
@ -41,7 +41,7 @@ TagRegistry::LookupUid (std::string uuid)
std::sort (m_registry.begin (), m_registry.end ());
m_sorted = true;
}
assert (m_sorted);
NS_ASSERT (m_sorted);
uint32_t uid = 1;
for (TagsDataCI i = m_registry.begin (); i != m_registry.end (); i++)
{
@ -52,14 +52,14 @@ TagRegistry::LookupUid (std::string uuid)
uid++;
}
// someone asked for a uid for an unregistered uuid.
assert (!"You tried to use unregistered tag: make sure you create an instance of type TagRegistration<YouTagType>.");
NS_ASSERT (!"You tried to use unregistered tag: make sure you create an instance of type TagRegistration<YouTagType>.");
// quiet compiler
return 0;
}
void
TagRegistry::PrettyPrint (uint32_t uid, uint8_t buf[Tags::SIZE], std::ostream &os)
{
assert (m_registry.size () > uid);
NS_ASSERT (m_registry.size () > uid);
PrettyPrinter prettyPrinter = m_registry[uid].second;
if (prettyPrinter != 0)
{

14
src/common/tags.h
View File

@ -109,7 +109,7 @@ private:
/**************************************************************
An implementation of the templates defined above
*************************************************************/
#include <cassert>
#include "ns3/assert.h"
#include <string>
namespace ns3 {
@ -179,7 +179,7 @@ std::string *TypeUid<T>::GetUuid (void)
template <typename T>
TagRegistration<T>::TagRegistration (std::string uuid, void (*prettyPrinter) (T const*, std::ostream &))
{
assert (sizeof (T) <= Tags::SIZE);
NS_ASSERT (sizeof (T) <= Tags::SIZE);
m_prettyPrinter = prettyPrinter;
TagRegistry::Record (uuid, &TagRegistration<T>::PrettyPrinterCb);
TypeUid<T>::Record (uuid);
@ -188,7 +188,7 @@ template <typename T>
void
TagRegistration<T>::PrettyPrinterCb (uint8_t *buf, std::ostream &os)
{
assert (sizeof (T) <= Tags::SIZE);
NS_ASSERT (sizeof (T) <= Tags::SIZE);
T *tag = reinterpret_cast<T *> (buf);
(*m_prettyPrinter) (tag, os);
}
@ -203,12 +203,12 @@ template <typename T>
void
Tags::Add (T const&tag)
{
assert (sizeof (T) <= Tags::SIZE);
NS_ASSERT (sizeof (T) <= Tags::SIZE);
uint8_t const*buf = reinterpret_cast<uint8_t const*> (&tag);
// ensure this id was not yet added
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next)
{
assert (cur->m_id != TypeUid<T>::GetUid ());
NS_ASSERT (cur->m_id != TypeUid<T>::GetUid ());
}
struct TagData *newStart = AllocData ();
newStart->m_count = 1;
@ -223,7 +223,7 @@ template <typename T>
bool
Tags::Remove (T &tag)
{
assert (sizeof (T) <= Tags::SIZE);
NS_ASSERT (sizeof (T) <= Tags::SIZE);
return Remove (TypeUid<T>::GetUid ());
}
@ -231,7 +231,7 @@ template <typename T>
bool
Tags::Peek (T &tag) const
{
assert (sizeof (T) <= Tags::SIZE);
NS_ASSERT (sizeof (T) <= Tags::SIZE);
uint8_t *buf = reinterpret_cast<uint8_t *> (&tag);
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next)
{

12
src/common/trace-container.cc
View File

@ -22,7 +22,7 @@
#include "trace-container.h"
#include "stream-tracer.h"
#include <utility>
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {
@ -46,7 +46,7 @@ TraceContainer::SetUiVariableCallback (char const *name, Callback<void,uint64_t,
return;
}
}
assert (false);
NS_ASSERT (false);
}
void
TraceContainer::SetSiVariableCallback (char const *name, Callback<void,int64_t, int64_t> callback)
@ -59,12 +59,12 @@ TraceContainer::SetSiVariableCallback (char const *name, Callback<void,int64_t,
return;
}
}
assert (false);
NS_ASSERT (false);
}
void
TraceContainer::SetFVariableCallback (char const *name, Callback<void,double, double> callback)
{
assert (false);
NS_ASSERT (false);
}
void
TraceContainer::SetStream (char const *name, std::ostream *os)
@ -77,7 +77,7 @@ TraceContainer::SetStream (char const *name, std::ostream *os)
return;
}
}
assert (false);
NS_ASSERT (false);
}
void
@ -111,7 +111,7 @@ TraceContainer::RegisterSiVariable (char const *name, SiVariableTracerBase *var)
void
TraceContainer::RegisterFVariable (char const *name, FVariableTracerBase *var)
{
assert (false);
NS_ASSERT (false);
}
void

22
src/common/trace-container.h
View File

@ -196,7 +196,7 @@ private:
}; // namespace ns3
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {
@ -215,11 +215,11 @@ TraceContainer::SetCallback (char const *name, Callback<void,T1> callback)
}
else
{
assert (!"non-matching callback");
NS_ASSERT (!"non-matching callback");
}
}
}
assert (false);
NS_ASSERT (false);
}
template <typename T1, typename T2>
void
@ -236,11 +236,11 @@ TraceContainer::SetCallback (char const *name, Callback<void,T1,T2> callback)
}
else
{
assert (!"non-matching callback");
NS_ASSERT (!"non-matching callback");
}
}
}
assert (false);
NS_ASSERT (false);
}
template <typename T1, typename T2, typename T3>
void
@ -257,11 +257,11 @@ TraceContainer::SetCallback (char const *name, Callback<void,T1,T2,T3> callback)
}
else
{
assert (!"non-matching callback");
NS_ASSERT (!"non-matching callback");
}
}
}
assert (false);
NS_ASSERT (false);
}
template <typename T1, typename T2, typename T3, typename T4>
void
@ -278,11 +278,11 @@ TraceContainer::SetCallback (char const *name, Callback<void,T1,T2,T3,T4> callba
}
else
{
assert (!"non-matching callback");
NS_ASSERT (!"non-matching callback");
}
}
}
assert (false);
NS_ASSERT (false);
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
void
@ -299,11 +299,11 @@ TraceContainer::SetCallback (char const *name, Callback<void,T1,T2,T3,T4,T5> cal
}
else
{
assert (!"non-matching callback");
NS_ASSERT (!"non-matching callback");
}
}
}
assert (false);
NS_ASSERT (false);
}

2
src/common/trailer.cc
View File

@ -20,7 +20,7 @@
*/
#include "trailer.h"
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {

4
src/core/debug.cc
View File

@ -18,11 +18,11 @@
*
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include <cassert>
#include <list>
#include <utility>
#include <iostream>
#include "debug.h"
#include "assert.h"
#include "ns3/core-config.h"
#ifdef HAVE_STDLIB_H
@ -103,7 +103,7 @@ DebugComponent::DebugComponent (char const * name)
i != g_components.end ();
i++)
{
assert (i->first.compare (name) != 0);
NS_ASSERT (i->first.compare (name) != 0);
}
g_components.push_back (std::make_pair (name, this));
}

4
src/core/ptr.h
View File

@ -23,7 +23,7 @@
#define PTR_H
#include <stdint.h>
#include <cassert>
#include "assert.h"
namespace ns3 {
@ -246,7 +246,7 @@ template <typename T>
T *
Ptr<T>::Remove (void)
{
assert ((*m_count) == 1);
NS_ASSERT ((*m_count) == 1);
T *retval = m_ptr;
m_ptr = 0;
return retval;

2
src/core/reference-list.h
View File

@ -101,7 +101,7 @@ private:
void RemoveFromList (void) {
if (m_prev == this)
{
//assert (m_next == this);
//NS_ASSERT (m_next == this);
delete m_objPtr;
m_objPtr = OBJ_PTR ();
}

7
src/core/unix-system-file.cc
View File

@ -25,10 +25,11 @@
#include <sys/poll.h>
#include <fcntl.h>
#include <unistd.h>
#include <cassert>
#include <string.h>
#include <list>
#include "assert.h"
#define noTRACE_SYS_FILE 1
#ifdef TRACE_SYS_FILE
@ -71,7 +72,7 @@ void
SystemFilePrivate::Open (char const *filename)
{
m_fd = ::open (filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
assert (m_fd != -1);
NS_ASSERT (m_fd != -1);
}
#ifndef min
@ -92,7 +93,7 @@ SystemFilePrivate::Write (uint8_t const*buffer, uint32_t size)
{
ssize_t written = 0;
written = ::write (m_fd, m_data, BUFFER_SIZE);
assert (written == BUFFER_SIZE);
NS_ASSERT (written == BUFFER_SIZE);
m_current = 0;
}
}

18
src/node/arp-cache.cc
View File

@ -18,7 +18,7 @@
*
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include <cassert>
#include "ns3/assert.h"
#include "ns3/packet.h"
#include "ns3/simulator.h"
@ -153,14 +153,14 @@ void
ArpCache::Entry::MarkDead (void)
{
m_state = DEAD;
//assert (m_waiting != 0);
//NS_ASSERT (m_waiting != 0);
UpdateSeen ();
}
Packet
ArpCache::Entry::MarkAlive (MacAddress macAddress)
{
assert (m_state == WAIT_REPLY);
//assert (m_waiting != 0);
NS_ASSERT (m_state == WAIT_REPLY);
//NS_ASSERT (m_waiting != 0);
m_macAddress = macAddress;
m_state = ALIVE;
UpdateSeen ();
@ -172,7 +172,7 @@ ArpCache::Entry::MarkAlive (MacAddress macAddress)
Packet
ArpCache::Entry::UpdateWaitReply (Packet waiting)
{
assert (m_state == WAIT_REPLY);
NS_ASSERT (m_state == WAIT_REPLY);
/* We are already waiting for an answer so
* we dump the previously waiting packet and
* replace it with this one.
@ -184,8 +184,8 @@ ArpCache::Entry::UpdateWaitReply (Packet waiting)
void
ArpCache::Entry::MarkWaitReply (Packet waiting)
{
assert (m_state == ALIVE || m_state == DEAD);
//assert (m_waiting == 0);
NS_ASSERT (m_state == ALIVE || m_state == DEAD);
//NS_ASSERT (m_waiting == 0);
m_state = WAIT_REPLY;
m_waiting = waiting;
UpdateSeen ();
@ -194,7 +194,7 @@ ArpCache::Entry::MarkWaitReply (Packet waiting)
MacAddress
ArpCache::Entry::GetMacAddress (void)
{
assert (m_state == ALIVE);
NS_ASSERT (m_state == ALIVE);
return m_macAddress;
}
bool
@ -212,7 +212,7 @@ ArpCache::Entry::IsExpired (void)
timeout = m_arp->GetAliveTimeout ();
break;
default:
assert (false);
NS_ASSERT (false);
timeout = Seconds (0);
/* NOTREACHED */
break;

6
src/node/arp-header.cc
View File

@ -19,7 +19,7 @@
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include <cassert>
#include "ns3/assert.h"
#include "arp-header.h"
#include "header-utils.h"
@ -96,7 +96,7 @@ ArpHeader::PrintTo (std::ostream &os) const
}
else
{
assert (IsReply ());
NS_ASSERT (IsReply ());
os << " source mac: " << m_macSource
<< " source ipv4: " << m_ipv4Source
<< " dest mac: " << m_macDest
@ -114,7 +114,7 @@ void
ArpHeader::SerializeTo (Buffer::Iterator start) const
{
Buffer::Iterator i = start;
assert (m_macSource.GetLength () == m_macDest.GetLength ());
NS_ASSERT (m_macSource.GetLength () == m_macDest.GetLength ());
/* ethernet */
i.WriteHtonU16 (0x0001);

2
src/node/arp.cc
View File

@ -61,7 +61,7 @@ Arp::FindCache (NetDevice *device)
}
Ipv4Interface *interface = m_node->GetIpv4 ()->FindInterfaceForDevice (device);
ArpCache * cache = new ArpCache (device, interface);
assert (device->IsBroadcast ());
NS_ASSERT (device->IsBroadcast ());
device->SetLinkChangeCallback (MakeCallback (&ArpCache::Flush, cache));
m_cacheList.push_back (cache);
return cache;

8
src/node/ipv4-header.cc
View File

@ -19,7 +19,7 @@
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include <cassert>
#include "ns3/assert.h"
#include "ns3/header.h"
#include "ipv4-header.h"
@ -137,13 +137,13 @@ Ipv4Header::IsDontFragment (void) const
void
Ipv4Header::SetFragmentOffset (uint16_t offset)
{
assert (!(offset & (~0x3fff)));
NS_ASSERT (!(offset & (~0x3fff)));
m_fragmentOffset = offset;
}
uint16_t
Ipv4Header::GetFragmentOffset (void) const
{
assert (!(m_fragmentOffset & (~0x3fff)));
NS_ASSERT (!(m_fragmentOffset & (~0x3fff)));
return m_fragmentOffset;
}
@ -272,7 +272,7 @@ Ipv4Header::DeserializeFrom (Buffer::Iterator start)
uint8_t verIhl = i.ReadU8 ();
uint8_t ihl = verIhl & 0x0f;
uint16_t headerSize = ihl * 4;
assert ((verIhl >> 4) == 4);
NS_ASSERT ((verIhl >> 4) == 4);
m_tos = i.ReadU8 ();
uint16_t size = i.ReadNtohU16 ();
m_payloadSize = size - headerSize;

6
src/node/ipv4-route.cc
View File

@ -20,7 +20,7 @@
*/
#include "ipv4-route.h"
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {
@ -180,7 +180,7 @@ std::ostream& operator<< (std::ostream& os, Ipv4Route const& route)
{
if (route.IsDefault ())
{
assert (route.IsGateway ());
NS_ASSERT (route.IsGateway ());
os << "default out=" << route.GetInterface () << ", next hop=" << route.GetGateway ();
}
else if (route.IsHost ())
@ -215,7 +215,7 @@ std::ostream& operator<< (std::ostream& os, Ipv4Route const& route)
}
else
{
assert (false);
NS_ASSERT (false);
}
return os;
}

12
src/node/ipv4.cc
View File

@ -129,7 +129,7 @@ Ipv4::Lookup (Ipv4Address dest)
i != m_hostRoutes.end ();
i++)
{
assert ((*i)->IsHost ());
NS_ASSERT ((*i)->IsHost ());
if ((*i)->GetDest ().IsEqual (dest))
{
return (*i);
@ -139,7 +139,7 @@ Ipv4::Lookup (Ipv4Address dest)
j != m_networkRoutes.end ();
j++)
{
assert ((*j)->IsNetwork ());
NS_ASSERT ((*j)->IsNetwork ());
Ipv4Mask mask = (*j)->GetDestNetworkMask ();
Ipv4Address entry = (*j)->GetDestNetwork ();
if (mask.IsMatch (dest, entry))
@ -149,7 +149,7 @@ Ipv4::Lookup (Ipv4Address dest)
}
if (m_defaultRoute != 0)
{
assert (m_defaultRoute->IsDefault ());
NS_ASSERT (m_defaultRoute->IsDefault ());
return m_defaultRoute;
}
return 0;
@ -204,7 +204,7 @@ Ipv4::GetRoute (uint32_t index)
}
tmp++;
}
assert (false);
NS_ASSERT (false);
// quiet compiler.
return 0;
}
@ -250,7 +250,7 @@ Ipv4::RemoveRoute (uint32_t index)
}
tmp++;
}
assert (false);
NS_ASSERT (false);
}
@ -365,7 +365,7 @@ Ipv4::SendRealOut (Packet const &p, Ipv4Header const &ip, Ipv4Route const &route
Packet packet = p;
packet.Add (ip);
Ipv4Interface *outInterface = GetInterface (route.GetInterface ());
assert (packet.GetSize () <= outInterface->GetMtu ());
NS_ASSERT (packet.GetSize () <= outInterface->GetMtu ());
// XXX log trace here.
if (route.IsGateway ())
{

2
src/node/llc-snap-header.cc
View File

@ -19,7 +19,7 @@
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include <cassert>
#include "ns3/assert.h"
#include "llc-snap-header.h"

6
src/node/mac-address.cc
View File

@ -21,7 +21,7 @@
#include <iostream>
#include <iomanip>
#include <cassert>
#include "ns3/assert.h"
#include "mac-address.h"
#define ASCII_a (0x41)
@ -56,7 +56,7 @@ MacAddress::MacAddress () : m_len(0)
MacAddress::MacAddress (uint8_t const *address, uint8_t len)
{
assert(len <= MacAddress::MAX_LEN);
NS_ASSERT (len <= MacAddress::MAX_LEN);
for (int i=0; i < len; i++)
{
m_address[i] = address[i];
@ -164,7 +164,7 @@ bool operator < (MacAddress const&a, MacAddress const&b)
uint8_t b_p[MacAddress::MAX_LEN];
a.Peek (a_p);
b.Peek (b_p);
assert(a.GetLength() == b.GetLength());
NS_ASSERT (a.GetLength() == b.GetLength());
for (uint8_t i = 0; i < a.GetLength(); i++)
{
if (a_p[i] < b_p[i])

4
src/node/net-device.cc
View File

@ -20,7 +20,7 @@
*/
#include <iostream>
#include <cassert>
#include "ns3/assert.h"
#include "net-device.h"
#include "l3-demux.h"
@ -93,7 +93,7 @@ NetDevice::IsBroadcast (void) const
MacAddress const &
NetDevice::GetBroadcast (void) const
{
assert (m_isBroadcast);
NS_ASSERT (m_isBroadcast);
return m_broadcast;
}

6
src/node/queue.cc
View File

@ -69,8 +69,8 @@ Queue::Deque (Packet &p)
m_nBytes -= p.GetSize ();
m_nPackets--;
assert(m_nBytes >= 0);
assert(m_nPackets >= 0);
NS_ASSERT (m_nBytes >= 0);
NS_ASSERT (m_nPackets >= 0);
NS_DEBUG("Queue::Deque (): m_traceDeque (p)")
m_traceDeque ("+ <timestamp> ", static_cast<const Packet &>(p));
@ -84,7 +84,7 @@ Queue::DequeAll (void)
{
NS_DEBUG("Queue::DequeAll ()")
assert (!"Don't know what to do with dequeued packets!");
NS_ASSERT (!"Don't know what to do with dequeued packets!");
}
uint32_t

2
src/node/udp-socket.cc
View File

@ -30,7 +30,7 @@ UdpSocket::UdpSocket (Node *node)
: m_endPoint (0),
m_node (node)
{
assert (GetUdp () != 0);
NS_ASSERT (GetUdp () != 0);
}
UdpSocket::~UdpSocket ()
{

4
src/node/udp.cc
View File

@ -19,7 +19,7 @@
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include <cassert>
#include "ns3/assert.h"
#include "ns3/packet.h"
#include "udp.h"
#include "udp-header.h"
@ -95,7 +95,7 @@ Udp::Receive(Packet& packet,
}
UdpSocket *socket = endPoint->GetSocket ();
socket->ForwardUp (packet, source, udpHeader.GetSource ());
assert (socket != 0);
NS_ASSERT (socket != 0);
}
void

2
src/simulator/high-precision-double.cc
View File

@ -21,7 +21,7 @@
#include "high-precision-double.h"
#include <cmath>
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {

2
src/simulator/high-precision.cc
View File

@ -21,7 +21,7 @@
#include "high-precision.h"
#include <cmath>
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {

2
src/simulator/nstime.h
View File

@ -22,7 +22,7 @@
#define TIME_H
#include <stdint.h>
#include <cassert>
#include "ns3/assert.h"
#include <ostream>
#include "high-precision.h"

8
src/simulator/scheduler-heap.cc
View File

@ -34,7 +34,7 @@
#include "scheduler-heap.h"
#include "event-impl.h"
#include <cassert>
#include "ns3/assert.h"
#define noTRACE_HEAP 1
@ -112,7 +112,7 @@ SchedulerHeap::IsBottom (uint32_t id) const
void
SchedulerHeap::Exch (uint32_t a, uint32_t b)
{
assert (b < m_heap.size () && a < m_heap.size ());
NS_ASSERT (b < m_heap.size () && a < m_heap.size ());
TRACE ("Exch " << a << ", " << b);
std::pair<EventImpl*, Scheduler::EventKey> tmp (m_heap[a]);
m_heap[a] = m_heap[b];
@ -191,7 +191,7 @@ SchedulerHeap::TopDown (uint32_t start)
{
return;
}
assert (!IsBottom (index));
NS_ASSERT (!IsBottom (index));
uint32_t left = LeftChild (index);
if (IsBottom (left))
{
@ -248,7 +248,7 @@ SchedulerHeap::RealRemove (EventId id, Scheduler::EventKey *key)
return retval;
}
}
assert (false);
NS_ASSERT (false);
// quiet compiler
return 0;
}

6
src/simulator/scheduler-list.cc
View File

@ -22,7 +22,7 @@
#include "scheduler-list.h"
#include "event-impl.h"
#include <utility>
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {
@ -93,14 +93,14 @@ SchedulerList::RealRemove (EventId id, Scheduler::EventKey *key)
if (i->second.m_uid == id.GetUid ())
{
EventImpl *retval = i->first;
assert (id.GetEventImpl () == retval);
NS_ASSERT (id.GetEventImpl () == retval);
key->m_ns = id.GetNs ();
key->m_uid = id.GetUid ();
m_events.erase (i);
return retval;
}
}
assert (false);
NS_ASSERT (false);
return 0;
}

8
src/simulator/scheduler-map.cc
View File

@ -22,7 +22,7 @@
#include "scheduler-map.h"
#include "event-impl.h"
#include <cassert>
#include "ns3/assert.h"
#define noTRACE_MAP 1
@ -76,7 +76,7 @@ SchedulerMap::RealInsert (EventImpl *event, Scheduler::EventKey key)
{
std::pair<EventMapI,bool> result;
result = m_list.insert (std::make_pair (key, event));
assert (result.second);
NS_ASSERT (result.second);
return EventId (event, key.m_ns, key.m_uid);
}
@ -90,14 +90,14 @@ EventImpl *
SchedulerMap::RealPeekNext (void) const
{
EventMapCI i = m_list.begin ();
assert (i != m_list.end ());
NS_ASSERT (i != m_list.end ());
return (*i).second;
}
Scheduler::EventKey
SchedulerMap::RealPeekNextKey (void) const
{
EventMapCI i = m_list.begin ();
assert (i != m_list.end ());
NS_ASSERT (i != m_list.end ());
return (*i).first;
}
void

10
src/simulator/scheduler.cc
View File

@ -20,7 +20,7 @@
*/
#include "scheduler.h"
#include <cassert>
#include "ns3/assert.h"
namespace ns3 {
@ -40,25 +40,25 @@ Scheduler::IsEmpty (void) const
EventImpl *
Scheduler::PeekNext (void) const
{
assert (!RealIsEmpty ());
NS_ASSERT (!RealIsEmpty ());
return RealPeekNext ();
}
Scheduler::EventKey
Scheduler::PeekNextKey (void) const
{
assert (!RealIsEmpty ());
NS_ASSERT (!RealIsEmpty ());
return RealPeekNextKey ();
}
void
Scheduler::RemoveNext (void)
{
assert (!RealIsEmpty ());
NS_ASSERT (!RealIsEmpty ());
return RealRemoveNext ();
}
EventImpl *
Scheduler::Remove (EventId id, EventKey *key)
{
assert (!RealIsEmpty ());
NS_ASSERT (!RealIsEmpty ());
return RealRemove (id, key);
}

14
src/simulator/simulator.cc
View File

@ -24,7 +24,7 @@
#include "event-impl.h"
#include <math.h>
#include <cassert>
#include "ns3/assert.h"
#include <fstream>
#include <list>
#include <vector>
@ -147,7 +147,7 @@ SimulatorPrivate::IsFinished (void) const
uint64_t
SimulatorPrivate::NextNs (void) const
{
assert (!m_events->IsEmpty ());
NS_ASSERT (!m_events->IsEmpty ());
Scheduler::EventKey nextKey = m_events->PeekNextKey ();
return nextKey.m_ns;
}
@ -179,14 +179,14 @@ SimulatorPrivate::Stop (void)
void
SimulatorPrivate::StopAt (Time const &at)
{
assert (at.IsPositive ());
NS_ASSERT (at.IsPositive ());
m_stopAt = at.GetNanoSeconds ();
}
EventId
SimulatorPrivate::Schedule (Time const &time, EventImpl *event)
{
assert (time.IsPositive ());
assert (time >= NanoSeconds (m_currentNs));
NS_ASSERT (time.IsPositive ());
NS_ASSERT (time >= NanoSeconds (m_currentNs));
uint64_t ns = (uint64_t) time.GetNanoSeconds ();
Scheduler::EventKey key = {ns, m_uid};
if (m_logEnable)
@ -296,7 +296,7 @@ void Simulator::SetStdMap (void)
void
Simulator::SetExternal (SchedulerFactory const*factory)
{
assert (factory != 0);
NS_ASSERT (factory != 0);
m_schedFactory = factory;
m_listType = EXTERNAL;
}
@ -326,7 +326,7 @@ Simulator::GetPriv (void)
events = m_schedFactory->Create ();
default: // not reached
events = 0;
assert (false);
NS_ASSERT (false);
break;
}
m_priv = new SimulatorPrivate (events);

4
utils/replay-simulation.cc
View File

@ -206,7 +206,7 @@ LogReader::ExecuteLogCommands (uint32_t uid)
//std::cout << "exec insert remove" << std::endl;
EventId id = Simulator::Schedule (NanoSeconds (cmd.insertRemove.m_evNs) - Now (),
&LogReader::ExecuteLogCommands, this, m_uid);
assert (id.GetUid () == m_uid);
NS_ASSERT (id.GetUid () == m_uid);
if (cmd.insertRemove.m_evLoc + 1 > m_removeEvents.size ())
{
uint32_t missing = cmd.insertRemove.m_evLoc + 1 - m_removeEvents.size ();
@ -218,7 +218,7 @@ LogReader::ExecuteLogCommands (uint32_t uid)
m_uid++;
} break;
default:
assert (false);
NS_ASSERT (false);
break;
}
cmd = *m_command;