Re: [rtl] unresolved symbol atexit

[Ivan Martinez]

        Yes, it's my only unresolved symbol. I have reduced my inludes to 
<rtl_cpp.h> and "testclass.h" and I still have the error, so I guess it has 
something to do with my test class. I send it's source code attached in this 
mail.
        Thank you,
        Ivan

On Friday 09 November 2001 15:22, Dresner, Norman A. wrote:
> You may not call it explicitly, but I'll bet it's invoked as part of the
> "invisible" C++ startup routine so that all of the distructors can be
> executed on program termination.  Since I'm not a C++ expert, I don't know
> what would happen if you just included a do-nothing stub.
>
> Is that the only unresolved symbol?
>
>       Norm
>
> > -----Original Message-----
> > From:       Ivan Martinez [SMTP:[EMAIL PROTECTED]]
> > Sent:       Friday, November 09, 2001 4:41 AM
> > To: [EMAIL PROTECTED]; Dresner, Norman A.; '[EMAIL PROTECTED]'
> > Subject:    Re: [rtl] unresolved symbol atexit
> >
> > I don't call atexit() at all. This is my list of includes:
> >
> > #include <asm/page.h>
> > #include <math.h>
> > #include "testclass.h"
> > #include <rtl_cpp.h>
> > #include <rtl_fifo.h>
> > #include <rtl_sync.h>
> > #include <sys/stat.h>
> > #include <sys/types.h>
> >
> > Ivan
> >
> > On Thursday 08 November 2001 18:10, Dresner, Norman A. wrote:
> > > You can't use the standard C/C++ library in a real-time module.  Most
> > > of those capabilities involve calls to the normal Linux kernel that are
> > > incompatible with real-time scheduling.  In particular, a real-time
> >
> > module
> >
> > > does not exit the same way that a program does so calling atexit() is
> > > simply impossible.
> > >
> > >   Norm
> > >
> > > > -----Original Message-----
> > > > From:   Ivan Martinez [SMTP:[EMAIL PROTECTED]]
> > > > Sent:   Thursday, November 08, 2001 10:17 AM
> > > > To:     RTLinux mailing list
> > > > Subject:        [rtl] unresolved symbol atexit
> > > >
> > > > Hello all,
> > > > When installing my C++ realtime module, I get the following error:
> > > > app.o: unresolved symbol atexit
> > > > Do you know what can be wrong?. Thank you.
> > > > Ivan Martinez
> > > > -- [rtl] ---
> > > > To unsubscribe:
> > > > echo "unsubscribe rtl" | mail [EMAIL PROTECTED] OR
> > > > echo "unsubscribe rtl <Your_email>" | mail [EMAIL PROTECTED]
> > > > --
> > > > For more information on Real-Time Linux see:
> > > > http://www.rtlinux.org/
> > >
> > > -- [rtl] ---
> > > To unsubscribe:
> > > echo "unsubscribe rtl" | mail [EMAIL PROTECTED] OR
> > > echo "unsubscribe rtl <Your_email>" | mail [EMAIL PROTECTED]
> >
> > -- [rtl] ---
> > To unsubscribe:
> > echo "unsubscribe rtl" | mail [EMAIL PROTECTED] OR
> > echo "unsubscribe rtl <Your_email>" | mail [EMAIL PROTECTED]
> > --
> > For more information on Real-Time Linux see:
> > http://www.rtlinux.org/

#include "../distribution/rtfifoioclass.h"

class TestClass;
class TestClass : public CRTFifoIOClass
{
public:
	TestClass();

	virtual ~TestClass();

	/** Needed to perform the assignation of inputs to outputs */
	void operator = (const TestClass &b);

	/** Needed to set the initial state of the intergrators and update
		the output in summing points */
	void operator = (float);

	/** Needed to calculate the output in summing point blocks */
	TestClass operator + (const TestClass &b);

	/** Needed to calculate the output in summing points blocks */
	TestClass operator - (const TestClass &b);

	/** Needed to calculate the output in gain and integrator blocks */
	float operator * (float);

	void SetValue(float);

	float GetValue() const;

  /** No descriptions */
  void RTFifoWrite(int);

  /** No descriptions */
  void RTFifoRead(int);

  /** No descriptions */
  void SharedMemoryRead(void *);

protected:
	float m_fValue;
};

#include "testclass.h"

extern "C"
{
#include <rtl_printf.h>
//#include <string.h>
}
#include <string.h>

TestClass::TestClass()
{
	rtl_printf("TestClass %p created\n", this);
}


TestClass::~TestClass()
{
	rtl_printf("TestCLass %p destroyed with Int=%d\n", this, m_fValue);
}

float	TestClass::GetValue() const
{
	rtl_printf("TestClass %p returning Value %d\n", this, m_fValue);

	return m_fValue;
}

void TestClass::SetValue(float fValue)
{
	m_fValue = fValue;

	rtl_printf("TestClass %p Value set to %d\n", this, m_fValue);
}

void TestClass::operator = (const TestClass &b)
{
	m_fValue = b.GetValue();

	rtl_printf("TestClass %p Value assigned to %p Value %d\n", this, &b,
		m_fValue);
}

void TestClass::operator = (float fValue)
{
	m_fValue = fValue;

	rtl_printf("TestClass %p Value assigned to %d\n", this, fValue);
}

TestClass TestClass::operator + (const TestClass &b)
{
	TestClass Result;

	Result.SetValue(GetValue() + b.GetValue());

	return Result;
}

TestClass TestClass::operator - (const TestClass &b)
{
	TestClass Result;

	Result.SetValue(GetValue() - b.GetValue());

	return Result;
}

float TestClass::operator * (float fValue)
{
	return GetValue() * fValue;
}

/** No descriptions */
void TestClass::RTFifoRead(int ){
}

/** No descriptions */
void TestClass::RTFifoWrite(int ){
}

void TestClass::SharedMemoryRead(void *)
{
}