From 6ea75fd4b03ce3a9155781764c9bcf13a637b749 Mon Sep 17 00:00:00 2001 From: maksymsproductengine Date: Tue, 7 Oct 2014 18:59:11 +0300 Subject: MAINT-4548 & MAINT-4557 FIXED build issues --- indra/llcommon/CMakeLists.txt | 5 + indra/llcommon/lluriparser.cpp | 228 +++++++++++++++++++++++++++++++++++++++++ indra/llcommon/lluriparser.h | 84 +++++++++++++++ 3 files changed, 317 insertions(+) create mode 100644 indra/llcommon/lluriparser.cpp create mode 100644 indra/llcommon/lluriparser.h (limited to 'indra/llcommon') diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt index 763f5a3521..debb42fb5f 100755 --- a/indra/llcommon/CMakeLists.txt +++ b/indra/llcommon/CMakeLists.txt @@ -12,12 +12,14 @@ include(GoogleBreakpad) include(GooglePerfTools) include(Copy3rdPartyLibs) include(ZLIB) +include(URIPARSER) include_directories( ${EXPAT_INCLUDE_DIRS} ${LLCOMMON_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIRS} ${BREAKPAD_INCLUDE_DIRECTORIES} + ${URIPARSER_INCLUDE_DIRS} ) # add_executable(lltreeiterators lltreeiterators.cpp) @@ -103,6 +105,7 @@ set(llcommon_SOURCE_FILES lltracerecording.cpp lltracethreadrecorder.cpp lluri.cpp + lluriparser.cpp lluuid.cpp llworkerthread.cpp timing.cpp @@ -217,6 +220,7 @@ set(llcommon_HEADER_FILES llunits.h llunittype.h lluri.h + lluriparser.h lluuid.h llwin32headers.h llwin32headerslean.h @@ -261,6 +265,7 @@ target_link_libraries( ${BOOST_PROGRAM_OPTIONS_LIBRARY} ${BOOST_REGEX_LIBRARY} ${GOOGLE_PERFTOOLS_LIBRARIES} + ${URIPARSER_LIBRARIES} ) if (DARWIN) diff --git a/indra/llcommon/lluriparser.cpp b/indra/llcommon/lluriparser.cpp new file mode 100644 index 0000000000..ef4481d32f --- /dev/null +++ b/indra/llcommon/lluriparser.cpp @@ -0,0 +1,228 @@ +/** + * @file lluriparser.cpp + * @author Protey + * @date 2014-10-07 + * @brief Implementation of the LLUriParser class. + * + * $LicenseInfo:firstyear=2014&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2014, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#include "linden_common.h" +#include "lluriparser.h" + +LLUriParser::LLUriParser(const std::string& u) : mTmpScheme(false), mRes(0) +{ + mState.uri = &mUri; + + if (u.find("://") == std::string::npos) + { + mNormalizedUri = "http://"; + mTmpScheme = true; + } + + mNormalizedUri += u.c_str(); + + mRes = parse(); +} + +LLUriParser::~LLUriParser() +{ + uriFreeUriMembersA(&mUri); +} + +S32 LLUriParser::parse() +{ + mRes = uriParseUriA(&mState, mNormalizedUri.c_str()); + return mRes; +} + +const char * LLUriParser::scheme() const +{ + return mScheme.c_str(); +} + +void LLUriParser::sheme(const std::string& s) +{ + mTmpScheme = !s.size(); + mScheme = s; +} + +const char * LLUriParser::port() const +{ + return mPort.c_str(); +} + +void LLUriParser::port(const std::string& s) +{ + mPort = s; +} + +const char * LLUriParser::host() const +{ + return mHost.c_str(); +} + +void LLUriParser::host(const std::string& s) +{ + mHost = s; +} + +const char * LLUriParser::path() const +{ + return mPath.c_str(); +} + +void LLUriParser::path(const std::string& s) +{ + mPath = s; +} + +const char * LLUriParser::query() const +{ + return mQuery.c_str(); +} + +void LLUriParser::query(const std::string& s) +{ + mQuery = s; +} + +const char * LLUriParser::fragment() const +{ + return mFragment.c_str(); +} + +void LLUriParser::fragment(const std::string& s) +{ + mFragment = s; +} + +void LLUriParser::textRangeToString(UriTextRangeA& textRange, std::string& str) +{ + S32 len = textRange.afterLast - textRange.first; + if (len) + { + str = textRange.first; + str = str.substr(0, len); + } +} + +void LLUriParser::extractParts() +{ + if (mTmpScheme) + { + mScheme.clear(); + } + else + { + textRangeToString(mUri.scheme, mScheme); + } + + textRangeToString(mUri.hostText, mHost); + textRangeToString(mUri.portText, mPort); + textRangeToString(mUri.query, mQuery); + textRangeToString(mUri.fragment, mFragment); + + UriPathSegmentA * pathHead = mUri.pathHead; + while (pathHead) + { + std::string partOfPath; + textRangeToString(pathHead->text, partOfPath); + + mPath += '/'; + mPath += partOfPath; + + pathHead = pathHead->next; + } +} + +S32 LLUriParser::normalize() +{ + if (!mRes) + { + mRes = uriNormalizeSyntaxExA(&mUri, URI_NORMALIZE_SCHEME | URI_NORMALIZE_HOST); + + if (!mRes) + { + S32 chars_required; + mRes = uriToStringCharsRequiredA(&mUri, &chars_required); + + if (!mRes) + { + chars_required++; + std::vector label_buf(chars_required); + mRes = uriToStringA(&label_buf[0], &mUri, chars_required, NULL); + + if (!mRes) + { + mNormalizedUri = &label_buf[mTmpScheme ? 7 : 0]; + } + } + } + } + + return mRes; +} + +void LLUriParser::glue(std::string& uri) const +{ + if (mScheme.size()) + { + uri = mScheme; + uri += "://"; + } + + uri += mHost; + + if (mPort.size()) + { + uri += ':'; + uri += mPort; + } + + uri += mPath; + + if (mQuery.size()) + { + uri += '?'; + uri += mQuery; + + if (mFragment.size()) + { + uri += '#'; + uri += mFragment; + } + } +} + +bool LLUriParser::test() const +{ + std::string uri; + glue(uri); + + return uri == mNormalizedUri; +} + +const char * LLUriParser::normalizedUri() const +{ + return mNormalizedUri.c_str(); +} diff --git a/indra/llcommon/lluriparser.h b/indra/llcommon/lluriparser.h new file mode 100644 index 0000000000..719f916837 --- /dev/null +++ b/indra/llcommon/lluriparser.h @@ -0,0 +1,84 @@ +/** + * @file lluriparser.h + * @author Protey + * @date 20146-10-07 + * @brief Declaration of the UriParser class. + * + * $LicenseInfo:firstyear=2014&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2014, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#ifndef LL_LLURIPARSER_H +#define LL_LLURIPARSER_H + +#include +#include "uriparser/Uri.h" + +class LL_COMMON_API LLUriParser +{ +public: + LLUriParser(const std::string& u); + virtual ~LLUriParser(); + + const char * scheme() const; + void sheme (const std::string& s); + + const char * port() const; + void port (const std::string& s); + + const char * host() const; + void host (const std::string& s); + + const char * path() const; + void path (const std::string& s); + + const char * query() const; + void query (const std::string& s); + + const char * fragment() const; + void fragment (const std::string& s); + + const char * normalizedUri() const; + + void extractParts(); + void glue(std::string& uri) const; + bool test() const; + S32 normalize(); + +private: + S32 parse(); + void textRangeToString(UriTextRangeA& textRange, std::string& str); + std::string mScheme; + std::string mHost; + std::string mPort; + std::string mPath; + std::string mQuery; + std::string mFragment; + std::string mNormalizedUri; + + UriParserStateA mState; + UriUriA mUri; + + S32 mRes; + bool mTmpScheme; +}; + +#endif // LL_LLURIPARSER_H -- cgit v1.2.3 From ae6440eecc4d6c018a3634c2c06052757bde962f Mon Sep 17 00:00:00 2001 From: Nat Goodspeed Date: Wed, 28 Jan 2015 15:55:18 -0500 Subject: MAINT-4744: Eliminate viewer dependency on (old) GNU libstdc++. 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. 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. --- indra/llcommon/llfile.cpp | 4 ++++ indra/llcommon/llfile.h | 14 ++++++++++++++ 2 files changed, 18 insertions(+) (limited to 'indra/llcommon') diff --git a/indra/llcommon/llfile.cpp b/indra/llcommon/llfile.cpp index aabc195ba8..304d702979 100755 --- a/indra/llcommon/llfile.cpp +++ b/indra/llcommon/llfile.cpp @@ -919,6 +919,7 @@ llifstream::llifstream(const char* _Filename, #endif +#if llstream_LLFILE // explicit llifstream::llifstream(_Filet *_File, ios_base::openmode _Mode, size_t _Size) : @@ -942,6 +943,7 @@ llifstream::llifstream(int __fd, this->init(&_M_filebuf); } #endif +#endif // llstream_LLFILE bool llifstream::is_open() const { // test if C stream has been opened @@ -1039,6 +1041,7 @@ llofstream::llofstream(const char* _Filename, } #endif +#if llstream_LLFILE // explicit llofstream::llofstream(_Filet *_File, ios_base::openmode _Mode, size_t _Size) : @@ -1062,6 +1065,7 @@ llofstream::llofstream(int __fd, this->init(&_M_filebuf); } #endif +#endif // llstream_LLFILE bool llofstream::is_open() const { // test if C stream has been opened diff --git a/indra/llcommon/llfile.h b/indra/llcommon/llfile.h index 0612071d67..44a1e42fa5 100755 --- a/indra/llcommon/llfile.h +++ b/indra/llcommon/llfile.h @@ -86,6 +86,12 @@ public: static const char * tmpdir(); }; +// Remove ll[io]fstream support for [LL]FILE*, preparing to remove dependency +// on GNU's standard library. +#if ! defined(llstream_LLFILE) +#define llstream_LLFILE 0 +#endif + /** * @brief Provides a layer of compatibility for C/POSIX. * @@ -228,6 +234,7 @@ public: explicit llifstream(const char* _Filename, ios_base::openmode _Mode = ios_base::in); +#if llstream_LLFILE /** * @brief Create a stream using an open c file stream. * @param File An open @c FILE*. @@ -253,6 +260,7 @@ public: //size_t _Size = static_cast(BUFSIZ)); size_t _Size = static_cast(1)); #endif +#endif // llstream_LLFILE /** * @brief The destructor does nothing. @@ -263,6 +271,7 @@ public: virtual ~llifstream() {} // Members: +#if llstream_LLFILE /** * @brief Accessing the underlying buffer. * @return The current basic_filebuf buffer. @@ -271,6 +280,7 @@ public: */ llstdio_filebuf* rdbuf() const { return const_cast(&_M_filebuf); } +#endif // llstream_LLFILE /** * @brief Wrapper to test for an open file. @@ -340,6 +350,7 @@ public: explicit llofstream(const char* _Filename, ios_base::openmode _Mode = ios_base::out|ios_base::trunc); +#if llstream_LLFILE /** * @brief Create a stream using an open c file stream. * @param File An open @c FILE*. @@ -365,6 +376,7 @@ public: //size_t _Size = static_cast(BUFSIZ)); size_t _Size = static_cast(1)); #endif +#endif // llstream_LLFILE /** * @brief The destructor does nothing. @@ -375,6 +387,7 @@ public: virtual ~llofstream() {} // Members: +#if llstream_LLFILE /** * @brief Accessing the underlying buffer. * @return The current basic_filebuf buffer. @@ -383,6 +396,7 @@ public: */ llstdio_filebuf* rdbuf() const { return const_cast(&_M_filebuf); } +#endif // llstream_LLFILE /** * @brief Wrapper to test for an open file. -- cgit v1.2.3