Alexander Nasonov ha escrito:

Joaquín Mª López Muñoz <joaquin <at> tid.es> writes:

...

OK, I think I've got it: MSVC++ 6.5 behaves funny with static constants inside templates, as it does not see their correct value during template parsing. For instance, the following:

#include <boost/config.hpp> #include <boost/static_assert.hpp>

template<typename T> struct foo { BOOST_STATIC_CONSTANT(int,x=2); BOOST_STATIC_ASSERT(x==2); };

int main() { return 0; }

fails at the static assertion line (x is seen as 1, btw). After instantiation, however, the static constant holds the correct value, this phenomenon only happens at the parsing stage.

Does this change

BOOST_STATIC_ASSERT(foo<T>::x==2); // qualified name

help?

No, same assertion failure :(

...

Is it OK to commit? I'd rather disabled compile-time calculation.

The decision is yours to make, of course, but disabling the static assertions seems to suffice --the compile-time calculations are indeed OK and hold correct values once lcast_precision is instantiated. Joaquín M López Muñoz Telefónica, Investigación y Desarrollo

Joaquín Mª López Muñoz <joaquin <at> tid.es> writes:

The decision is yours to make, of course, but disabling the static assertions seems to suffice --the compile-time calculations are indeed OK and hold correct values once lcast_precision is instantiated.

My decision is based on the fact that your change ommits some checks while my suggestion just moves them to runtime. Though, these checks can be violated only if a user sets digits or digits10 to extrememly high value. -- Alexander

I am trying to make the very first example in serialization work: http://www.boost.org/libs/serialization/doc/index.html (A Very Simple Case) I get linker errors about missing destructor : boost::archive::detail::basic_pointer_oserializer::~basic_pointer_oserializer(void) And similar errors. It seems the implementation of this destructor, which is declared in: boost/boost/archive/detail/basic_pointer_oserializer.hpp For some reason is implemented in: boost/libs/serialization/src/basic_pointer_oserializer.cpp The first obvious question is offcourse: Why is the implementation not under : boost/boost/archive/src/basic_pointer_oserializer.cpp ? Other questen is why is the "basic_pointer_oserializer.cpp" file not listed anywhere in the jamfiles? I can only find it in the vc71 solution provided in the serialization lib. I am aware that it might work if I use the official jambuilt libraries, but we really want to use our own Cmake files instead of Jam. I suppose I could just add the files like "basic_pointer_oserializer.cpp" to my Cmake files along with others that probably contains implemetations of other linker errors I get. Just its' still strange to me why they are not needed in the original jamfiles. -Martin Lutken

Paul A Bristow <pbristow <at> hetp.u-net.com> writes:

Although I made some input on this, I'm not the maintainer for lexical_cast (and don't have thiese platforms to test).

Maintainer is Alexander Nasonov [alexander.nasonov <at> gmail.com]) but in case he isn't listening:

I'm listening but I couldn't reply last few times because gmane rejects to send my messages. Sorry to all who didn't get a reply. I don't have an access to this complier either.

I can't see an obvious cause (presume it works OK on other platforms), so I can only suggest breaking this down into separate assertions to see which one is causing the trouble, and perhaps getting the values of std::limits<T>::digits and boost::is_abstract<T>.

It seems that the suitable precision (decimal digits to use to get the full accuracy for type T) can't be calculated.

It would also be useful to see what T is? Is this some funny type for which std::numeric_limits isn't properly specialised?

There is no specialication at all in the example:

#include <boost/lexical_cast.hpp> int main() { return 0; }

Joaquín, can you try #include <boost/detail/lcast_precision.hpp> int main() {} and then break this assertion down to see which part is failing? If it doesn't help, you can disable precision calculation at compile-time. Currently, it's disabled only if BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS is defined but of course it can be changed. -- Alexander