| Age | Commit message (Collapse) | Author |
|---|
|
|
|
To be more accurate, this changeset doesn't actually eliminate the dependency:
it eliminates the use cases for the llifstream / llofstream feature that
requires it.
Currently you can construct an llifstream or llofstream from an open LLFILE*
file handle (or, except on Windows, an int file descriptor). But rather than
containing a streambuf implementation based on FILE*, llfile.h relies on the
fact that the Windows std::filebuf happens to support that as a nonstandard
extension; also on a nonstandard GNU extension __gnu_cxx::stdio_filebuf<char>.
To move from GNU libstdc++ to clang's libc++ (the direction on Mac), we could
code a streambuf that supports FILE*. But before doing that, it's worth asking
whether anyone actually uses this questionable feature.
In fact there were only two methods: LLWearable::exportFile() and importFile()
-- and only one call to either, in LLViewerWearable::saveNewAsset(). The code
in saveNewAsset() opened the LLFILE* immediately before calling exportFile(),
meaning we could reasonably push the open operation down into exportFile().
That logic was complex anyway due to the need for the caller to close the
LLFILE* regardless of the success of the exportFile().
Change LLWearable::exportFile() and importFile() to accept a std::string
filename rather than an open LLFILE*. Change LLViewerWearable::saveNewAsset()
to simply call exportFile(filename) rather than horsing around with an LLFILE*
handle. (This improves the code in another way too: it encapsulates the need
to open the relevant file in binary mode. Previously, each caller had to
remember to do that.)
To prevent inadvertent reintroduction of ll[io]fstream(LLFILE*) code, add
llstream_LLFILE preprocessor macro (default 0) to control access to the
relevant constructors. Also suppress rdbuf() override, the only method whose
signature references llstdio_filebuf.
|
|
A particular LLInitParam::TypeValuesHelper specialization is derived from a
different TypeValuesHelper specialization. The subclass constructor
TypeValuesHelper(...) has previously forwarded the call to its base-class
constructor with:
TypeValuesHelper(val): TypeValuesHelper(val) {}
This is the first time I've looked at that; I'm a bit surprised that previous
compilers blithely accept it, and apparently understand the intent. gcc 4.7
complains that we would need to turn on -std=c++11 to support delegating
constructors; obviously the second TypeValuesHelper is now assumed to be the
class being defined, rather than its base class.
Fortunately the class already has typedefs for both specializations, fully
qualified with all template parameters, so I simply replaced the second
TypeValuesHelper reference with base_t.
|
|
For some reason, after the upgrade to Boost 1.57, gcc 4.6.3 has trouble with
the boost::lambda::_1 usage in stringize.h. This is consistent with other
cases we've encountered in which Boost.Lambda appears to be unmaintained and
losing its compatibility with other libraries. Fortunately Phoenix provides a
functional equivalent, albeit spelled differently.
|
|
The new toolchain may (!) have fixed a longstanding bug in LLLeap / APR when
we try to pump large volumes of data through a Windows named pipe using APR
nonblocking I/O. This used to fail pretty consistently because the APR
nonblocking write call would sometimes spuriously return "would block" when in
fact the data buffer was completely written; the caller would later retry,
which of course would duplicate some of the data in the pipe. Preliminary
experiments with VS 2013 suggest this may have been resolved. This changeset
is to propagate the experiment to a wider range of Windows systems; we may
need to revert it if in fact the bug persists.
|
|
|
|
|
|
ms_sleep() calls and adjust expectations accordingly
|
|
|
|
We use boost::phoenix::placeholders::arg1 to imply a whole lambda expression,
replacing boost::lambda. But to bind a plain function in a more
straightforward way, seems classic boost::bind() works while
boost::phoenix::bind() does not.
|
|
It's very irritating that Visual Studio produces a warning for unrecognized
#pragmas, which we then merrily turn into an error -- #pragma is inherently
compiler-specific!
|
|
|
|
https://svn.boost.org/trac/boost/ticket/10864
I've used boost::lambda with boost::function in a number of creative ways over
the years. But the clang 6 shipped with Xcode 6 seems to have somehow broken
lambda + function in Boost 1.57. boost::phoenix is a partial workaround.
Sadly, lambda's comma-operator overload doesn't seem to be supported,
necessitating a couple ugly workarounds.
With real lambdas now supported by current compilers, I'm sure the Boost
community has little incentive to repair the lambda + function problem.
Presumably we'll be able to use such features ourselves Real Soon Now...
|
|
These were of the form ensure(std::string, something convertible to bool). Not
sure what the ambiguity was, but ensure(std::string, bool(something)) works
better.
|
|
For some reason VS 2013 (unlike its predecessors and other current compilers)
needs us to explicitly convert an operator bool() method's return expression
to bool. :-P
|
|
(only)
|
|
|
|
support
|
|
|
|
|
|
|
|
|
|
|
|
Hopefully this is temporary until we figure out the real problem!
|
|
The new TUT library build eliminates the ambiguity about ensure_equals(const
char*, ...) versus ensure_equals(const std::string&, ...). Now it's all based
on const std::string&. Remove pointless const char* overloads and ambiguous
forwarding templates.
With clang in Xcode 6, any new datatypes we intend to use with ensure_equals()
must have operator<<(std::ostream&, datatype) declared BEFORE lltut.h
#includes tut.hpp. Reorder code in certain test source files to guarantee that
visibility.
|
|
test
|
|
in: 'cout << a() << b()' the order of evaluation of a() and b() is undefined.
|
|
|
|
|
|
|
|
now - operator << issues on clang
|
|
trigger clang warnings
|
|
|
|
|
|
|
|
|
|
- tidy up)
|
|
|
|
warnings/errors [-Wunused-const-variable]
|
|
to >=0 - correct ifx here is to retype the variable as signed
|
|
|
|
|
|
|
|
|
|
it's true purpose becomes clear
|
|
virtuals [-Woverloaded-virtual] and fix up first (of many) files
|
|
classes to make clang happy
|
|
|
|
|
|
|
