caught non-std exception

[Mike - EMAIL IGNORED]

On FC4 with g++ using STL and Posix threads
and sockets I am catching an exception that
is not a std::exception. Any idea what it
might be? An outline of my catch macro is
below.

Thanks,
Mike.

#define MY_MACRO \
catch (MyExceptions& e) \
{ \
... \\ process them \
} \
catch (std::exception& e) \
{ \
... \\ process them \
} \
catch (...) \
{ \
... \\ what is this \
}

[Jacek Dziedzic]

Mike wrote:

On FC4 with g++ using STL and Posix threads
and sockets I am catching an exception that
is not a std::exception. Any idea what it
might be? An outline of my catch macro is
below.

Thanks,
Mike.

#define MY_MACRO \
catch (MyExceptions& e) \
{ \
... \\ process them \
} \
catch (std::exception& e) \
{ \
... \\ process them \
} \
catch (...) \
{ \
... \\ what is this \
}

I have no idea, but some systems give you C++-style
exceptions in the event of a signal, like a segmentation
violation of division by zero.

I assume you have ruled out all custom exceptions
that have decided not to derive from std::exception?

Try running the program in gdb, when it stops do
a backtrace with the "bt" command and see which
function is immediately before (in time), that is
below (in the printout), something that resembles
a "throw".

HTH,
- J.

[Mike - EMAIL IGNORED]

On Sat, 18 Mar 2006 21:27:58 +0100, Jacek Dziedzic wrote:

Mike wrote:

On FC4 with g++ using STL and Posix threads
and sockets I am catching an exception that
is not a std::exception. Any idea what it
might be? An outline of my catch macro is
below.

[...] I assume you have ruled out all custom exceptions
that have decided not to derive from std::exception?

Try running the program in gdb, when it stops do
a backtrace with the "bt" command and see which
function is immediately before (in time), that is
below (in the printout), something that resembles
a "throw".

HTH,
- J.

Sorry to trouble you with a typo. I had:
throw(MyStuff);
instead of:
throw MyException(MyStuff);

I am surprised that it compiled.

Mike.

[Jakob Bieling]

Mike - EMAIL IGNORED <m_*************@yahoo.com> wrote:

Sorry to trouble you with a typo. I had:
throw(MyStuff);
instead of:
throw MyException(MyStuff);

I am surprised that it compiled.

Why? You can throw pretty much everything. Actually, I cannot think
of anything you cannot throw.

regards
--
jb

(reply address in rot13, unscramble first)

[Rolf Magnus]

Jakob Bieling wrote:

Mike - EMAIL IGNORED <m_*************@yahoo.com> wrote:

Sorry to trouble you with a typo. I had:
throw(MyStuff);
instead of:
throw MyException(MyStuff);

I am surprised that it compiled.

Why? You can throw pretty much everything.

Well, you can only throw objects, not types, and MyStuff is a type.
Instantiating it would require parens after it.

[Jakob Bieling]

Rolf Magnus <ra******@t-online.de> wrote:

Jakob Bieling wrote:

Mike - EMAIL IGNORED <m_*************@yahoo.com> wrote:

Sorry to trouble you with a typo. I had:
throw(MyStuff);
instead of:
throw MyException(MyStuff);

I am surprised that it compiled.

Why? You can throw pretty much everything.

Well, you can only throw objects, not types, and MyStuff is a type.
Instantiating it would require parens after it.

Hmm, if MyStuff is a type .. and MyException is also a type .. what
does MyException(MyStuff); mean? I apologize if the answer is really
simple, been a long day ;)

regards
--
jb

(reply address in rot13, unscramble first)

[Mike - EMAIL IGNORED]

On Sat, 18 Mar 2006 23:43:29 +0100, Jakob Bieling wrote:

Rolf Magnus <ra******@t-online.de> wrote:

Jakob Bieling wrote:

Mike - EMAIL IGNORED <m_*************@yahoo.com> wrote: Sorry to trouble you with a typo. I had:
throw(MyStuff);
instead of:
throw MyException(MyStuff);

I am surprised that it compiled. Why? You can throw pretty much everything.

Well, you can only throw objects, not types, and MyStuff is a type.
Instantiating it would require parens after it.

Hmm, if MyStuff is a type .. and MyException is also a type .. what
does MyException(MyStuff); mean? I apologize if the answer is really
simple, been a long day ;)

regards

In this case, (MyStuff) is of the form:

(const char* file, int line, const char* class,
const char* method, const char* cmt)

I am still surprised that it compiled with the error.
I hope for enlightenment.

Mike.

[Jakob Bieling]

Mike - EMAIL IGNORED <m_*************@yahoo.com> wrote:

On Sat, 18 Mar 2006 23:43:29 +0100, Jakob Bieling wrote:

Rolf Magnus <ra******@t-online.de> wrote:

Jakob Bieling wrote: Mike - EMAIL IGNORED <m_*************@yahoo.com> wrote: Sorry to trouble you with a typo. I had:
> throw(MyStuff);
> instead of:
> throw MyException(MyStuff);
>
> I am surprised that it compiled. Why? You can throw pretty much everything. Well, you can only throw objects, not types, and MyStuff is a type.
Instantiating it would require parens after it.

Hmm, if MyStuff is a type .. and MyException is also a type ..
what does MyException(MyStuff); mean? [..]

(MyStuff) is of the form:

(const char* file, int line, const char* class,
const char* method, const char* cmt)

Hm. Do you mean MyStuff is typedef'd to be a function pointer taking
those arguments? Or a function taking those arguments? Or is MyStuff a
#define for what is inside those parenthesis?

Either way, I still cannot see how 'throw MyException(MyStuff);' can
compile, if 'throw(MyStuff);' cannot and the other around. I was aware
of the fact that you can only throw objects and not types. But suppose:

1) MyStuff is a typedef (and as such a type), then you could
not have passed it to the ctor of MyException but you could
not have thrown MyStuff either.

2) MyStuff is a function, then 'throw(MyStuff);' would throw a
pointer to this function and 'MyException(MyStuff);' would
pass a pointer to this function to the ctor of MyException.

3) MyStuff is a #define as in

#define MyStuff const char* file, \
int line, \
const char* class, \
const char* method, \
const char* cmt

then 'throw(MyStuff);' expands to something that cannot be
compiled, just like 'throw Exception(MyStuff);' expands to
something that cannot be compiled either.

In other words, I am either missing something, or 'throw(MyStuff);'
compiles if and only if 'throw Exception(MyStuff);' compiles.

regards
--
jb

(reply address in rot13, unscramble first)

[Rolf Magnus]

Jakob Bieling wrote:

Rolf Magnus <ra******@t-online.de> wrote:

Jakob Bieling wrote:

Mike - EMAIL IGNORED <m_*************@yahoo.com> wrote: Sorry to trouble you with a typo. I had:
throw(MyStuff);
instead of:
throw MyException(MyStuff);

I am surprised that it compiled. Why? You can throw pretty much everything.

Well, you can only throw objects, not types, and MyStuff is a type.
Instantiating it would require parens after it.

Hmm, if MyStuff is a type .. and MyException is also a type .. what
does MyException(MyStuff); mean? I apologize if the answer is really
simple, been a long day ;)

Hmm, right. I was assuming MyStuff is a type, but actually, it could also be
a varible. Only then MyException(MyStuff) would make sense. Then it would
instantiate the type MyException and give MyStuff as argument to the
constructor.

[Mike - EMAIL IGNORED]

On Sun, 19 Mar 2006 09:50:24 +0100, Jakob Bieling wrote:
[...]

Hm. Do you mean MyStuff is typedef'd to be a function pointer taking
those arguments? Or a function taking those arguments? Or is MyStuff a
#define for what is inside those parenthesis?

Either way, I still cannot see how 'throw MyException(MyStuff);' can
compile, if 'throw(MyStuff);' cannot and the other around. I was aware
of the fact that you can only throw objects and not types. But suppose:

1) MyStuff is a typedef (and as such a type), then you could
not have passed it to the ctor of MyException but you could
not have thrown MyStuff either.

2) MyStuff is a function, then 'throw(MyStuff);' would throw a
pointer to this function and 'MyException(MyStuff);' would
pass a pointer to this function to the ctor of MyException.

3) MyStuff is a #define as in

#define MyStuff const char* file, \
int line, \
const char* class, \
const char* method, \
const char* cmt

then 'throw(MyStuff);' expands to something that cannot be
compiled, just like 'throw Exception(MyStuff);' expands to
something that cannot be compiled either.

In other words, I am either missing something, or 'throw(MyStuff);'
compiles if and only if 'throw Exception(MyStuff);' compiles.

regards

This is how it is, each item in its proper place:
ErrBase::ErrTypBadArg is an enum value
std::exception specifies the base class for BadArg
typedef ErrTmpl<ErrBase::ErrTypBadArg,std::exception> BadArg;
#define ERRLOC __FILE__,__LINE__
#define ERRHERE ERRLOC,className_,methodName
static const char* const className;
const char* const methodName = "myMethod";
const char* const cmt = "dumb error";

throw BadArg(ERRHERE,cmt);

This is a sequence with a long history of success on numerous
systems. The typo was:
throw (ERRHERE,cmt);
which was caught with:
catch (...)

The mystery continues to be that the typo:
throw(ERRHERE,cmt);
compiled. Both the success and failure modes conform to
example 3 above, and in both cases the result is not as
predicted in example 3, with:
FC4, g++ (GCC) 4.0.2 20051125 (Red Hat 4.0.2-8)
..

Mike.

[Jakob Bieling]

Mike - EMAIL IGNORED <m_*************@yahoo.com> wrote:

On Sun, 19 Mar 2006 09:50:24 +0100, Jakob Bieling wrote:
[...]

Hm. Do you mean MyStuff is typedef'd to be a function pointer
taking those arguments? Or a function taking those arguments? Or is
MyStuff a #define for what is inside those parenthesis?

Either way, I still cannot see how 'throw MyException(MyStuff);'
can compile, if 'throw(MyStuff);' cannot and the other around. I was
aware of the fact that you can only throw objects and not types. But
suppose:

1) MyStuff is a typedef (and as such a type), then you could
not have passed it to the ctor of MyException but you could
not have thrown MyStuff either.

2) MyStuff is a function, then 'throw(MyStuff);' would throw a
pointer to this function and 'MyException(MyStuff);' would
pass a pointer to this function to the ctor of MyException.

3) MyStuff is a #define as in

#define MyStuff const char* file, \
int line, \
const char* class, \
const char* method, \
const char* cmt

then 'throw(MyStuff);' expands to something that cannot be
compiled, just like 'throw Exception(MyStuff);' expands to
something that cannot be compiled either.

In other words, I am either missing something, or
'throw(MyStuff);' compiles if and only if 'throw
Exception(MyStuff);' compiles.

regards

This is how it is, each item in its proper place:
ErrBase::ErrTypBadArg is an enum value
std::exception specifies the base class for BadArg
typedef ErrTmpl<ErrBase::ErrTypBadArg,std::exception> BadArg;
#define ERRLOC __FILE__,__LINE__
#define ERRHERE ERRLOC,className_,methodName
static const char* const className;
const char* const methodName = "myMethod";
const char* const cmt = "dumb error";

throw BadArg(ERRHERE,cmt);

This is a sequence with a long history of success on numerous
systems. The typo was:
throw (ERRHERE,cmt);

This utilizes the global "operator," (comma operator). It evaluates
all arguments and returns the last one (the right-most one). So if you
had a "catch(char* c)" clause, it should have reached that.

hth
--
jb

(reply address in rot13, unscramble first)

[Jakob Bieling]

Jakob Bieling <ar****************@rot13.com> wrote:

const char* const cmt = "dumb error"; throw (ERRHERE,cmt);

had a "catch(char* c)" clause, it should have reached that.

Sorry, I meant a "catch (char const* c)" clause .. did not see the
first 'const' :)

regards
--
jb

(reply address in rot13, unscramble first)