Build WTF as dll in component build

Source/wtf/text/StringImpl.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef StringImpl_h
 #define StringImpl_h
 
 #include <limits.h>
-#include <wtf/ASCIICType.h>
-#include <wtf/Forward.h>
-#include <wtf/StdLibExtras.h>
-#include <wtf/StringHasher.h>
-#include <wtf/Vector.h>
-#include <wtf/unicode/Unicode.h>
+#include "wtf/ASCIICType.h"
+#include "wtf/Forward.h"
+#include "wtf/StdLibExtras.h"
+#include "wtf/StringHasher.h"
+#include "wtf/Vector.h"
+#include "wtf/WTFExport.h"
+#include "wtf/unicode/Unicode.h"
 
 #if USE(CF)
 typedef const struct __CFString * CFStringRef;
 #endif
 
 #ifdef __OBJC__
 @class NSString;
 #endif
 
 namespace WTF {
@@ skipping 63 matching lines @@
 #define STRING_STATS_REMOVE_STRING(string) StringImpl::stringStats().removeString(string)
 #else
 #define STRING_STATS_ADD_8BIT_STRING(length) ((void)0)
 #define STRING_STATS_ADD_8BIT_STRING2(length, isSubString) ((void)0)
 #define STRING_STATS_ADD_16BIT_STRING(length) ((void)0)
 #define STRING_STATS_ADD_16BIT_STRING2(length, isSubString) ((void)0)
 #define STRING_STATS_ADD_UPCONVERTED_STRING(length) ((void)0)
 #define STRING_STATS_REMOVE_STRING(string) ((void)0)
 #endif
 
-class StringImpl {
+class WTF_EXPORT StringImpl {
     WTF_MAKE_NONCOPYABLE(StringImpl);
     // This is needed because we malloc() space for a StringImpl plus an
     // immediately following buffer, as a performance tweak.
     NEW_DELETE_SAME_AS_MALLOC_FREE;
     friend struct WTF::CStringTranslator;
     template<typename CharacterType> friend struct WTF::HashAndCharactersTranslator;
     friend struct WTF::HashAndUTF8CharactersTranslator;
     friend struct WTF::CharBufferFromLiteralDataTranslator;
     friend struct WTF::LCharBufferTranslator;
     friend struct WTF::SubstringTranslator;
@@ skipping 639 matching lines @@
     static void checkConsistency(const StringImpl*) { }
 };
 #endif
 
 template <>
 ALWAYS_INLINE const LChar* StringImpl::getCharacters<LChar>() const { return characters8(); }
 
 template <>
 ALWAYS_INLINE const UChar* StringImpl::getCharacters<UChar>() const { return characters(); }
 
-bool equal(const StringImpl*, const StringImpl*);
-bool equal(const StringImpl*, const LChar*);
+WTF_EXPORT bool equal(const StringImpl*, const StringImpl*);
+WTF_EXPORT bool equal(const StringImpl*, const LChar*);
 inline bool equal(const StringImpl* a, const char* b) { return equal(a, reinterpret_cast<const LChar*>(b)); }
-bool equal(const StringImpl*, const LChar*, unsigned);
+WTF_EXPORT bool equal(const StringImpl*, const LChar*, unsigned);
 inline bool equal(const StringImpl* a, const char* b, unsigned length) { return equal(a, reinterpret_cast<const LChar*>(b), length); }
 inline bool equal(const LChar* a, StringImpl* b) { return equal(b, a); }
 inline bool equal(const char* a, StringImpl* b) { return equal(b, reinterpret_cast<const LChar*>(a)); }
-bool equal(const StringImpl*, const UChar*, unsigned);
-bool equalNonNull(const StringImpl* a, const StringImpl* b);
+WTF_EXPORT bool equal(const StringImpl*, const UChar*, unsigned);
+WTF_EXPORT bool equalNonNull(const StringImpl* a, const StringImpl* b);
 
 // Do comparisons 8 or 4 bytes-at-a-time on architectures where it's safe.
 #if CPU(X86_64)
 ALWAYS_INLINE bool equal(const LChar* a, const LChar* b, unsigned length)
 {
     unsigned dwordLength = length >> 3;
 
     if (dwordLength) {
         const uint64_t* aDWordCharacters = reinterpret_cast<const uint64_t*>(a);
         const uint64_t* bDWordCharacters = reinterpret_cast<const uint64_t*>(b);
@@ skipping 137 matching lines @@
 ALWAYS_INLINE bool equal(const UChar* a, const LChar* b, unsigned length)
 {
     for (unsigned i = 0; i != length; ++i) {
         if (a[i] != b[i])
             return false;
     }
 
     return true;
 }
 
-bool equalIgnoringCase(const StringImpl*, const StringImpl*);
-bool equalIgnoringCase(const StringImpl*, const LChar*);
+WTF_EXPORT bool equalIgnoringCase(const StringImpl*, const StringImpl*);
+WTF_EXPORT bool equalIgnoringCase(const StringImpl*, const LChar*);
 inline bool equalIgnoringCase(const LChar* a, const StringImpl* b) { return equalIgnoringCase(b, a); }
-bool equalIgnoringCase(const LChar*, const LChar*, unsigned);
-bool equalIgnoringCase(const UChar*, const LChar*, unsigned);
+WTF_EXPORT bool equalIgnoringCase(const LChar*, const LChar*, unsigned);
+WTF_EXPORT bool equalIgnoringCase(const UChar*, const LChar*, unsigned);
 inline bool equalIgnoringCase(const UChar* a, const char* b, unsigned length) { return equalIgnoringCase(a, reinterpret_cast<const LChar*>(b), length); }
 inline bool equalIgnoringCase(const LChar* a, const UChar* b, unsigned length) { return equalIgnoringCase(b, a, length); }
 inline bool equalIgnoringCase(const char* a, const UChar* b, unsigned length) { return equalIgnoringCase(b, reinterpret_cast<const LChar*>(a), length); }
 inline bool equalIgnoringCase(const char* a, const LChar* b, unsigned length) { return equalIgnoringCase(b, reinterpret_cast<const LChar*>(a), length); }
 inline bool equalIgnoringCase(const UChar* a, const UChar* b, int length)
 {
     ASSERT(length >= 0);
     return !Unicode::umemcasecmp(a, b, length);
 }
-bool equalIgnoringCaseNonNull(const StringImpl*, const StringImpl*);
+WTF_EXPORT bool equalIgnoringCaseNonNull(const StringImpl*, const StringImpl*);
 
-bool equalIgnoringNullity(StringImpl*, StringImpl*);
+WTF_EXPORT bool equalIgnoringNullity(StringImpl*, StringImpl*);
 
 template<typename CharacterType>
 inline size_t find(const CharacterType* characters, unsigned length, CharacterType matchCharacter, unsigned index = 0)
 {
     while (index < length) {
         if (characters[index] == matchCharacter)
             return index;
         ++index;
     }
     return notFound;
@@ skipping 227 matching lines @@
 }
 
 using WTF::StringImpl;
 using WTF::equal;
 using WTF::equalNonNull;
 using WTF::TextCaseSensitivity;
 using WTF::TextCaseSensitive;
 using WTF::TextCaseInsensitive;
 
 #endif