Base: More adjustments to BASE_API and project dependencies to

base/string_util.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file defines utility functions for working with strings.
 
 #ifndef BASE_STRING_UTIL_H_
 #define BASE_STRING_UTIL_H_
 #pragma once
 
 #include <stdarg.h>   // va_list
 
 #include <string>
 #include <vector>
 
 #include "base/base_api.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/string16.h"
 #include "base/string_piece.h"  // For implicit conversions.
+#include "base/string_util_static.h"
 
 // TODO(brettw) remove this dependency. Previously StringPrintf lived in this
 // file. We need to convert the callers over to using stringprintf.h instead
 // and then remove this.
 #include "base/stringprintf.h"
 
 // Safe standard library wrappers for all platforms.
 
 namespace base {
 
 // C standard-library functions like "strncasecmp" and "snprintf" that aren't
 // cross-platform are provided as "base::strncasecmp", and their prototypes
 // are listed below.  These functions are then implemented as inline calls
 // to the platform-specific equivalents in the platform-specific headers.
 
 // Compares the two strings s1 and s2 without regard to case using
 // the current locale; returns 0 if they are equal, 1 if s1 > s2, and -1 if
 // s2 > s1 according to a lexicographic comparison.
-BASE_API int strcasecmp(const char* s1, const char* s2);
+int strcasecmp(const char* s1, const char* s2);
 
 // Compares up to count characters of s1 and s2 without regard to case using
 // the current locale; returns 0 if they are equal, 1 if s1 > s2, and -1 if
 // s2 > s1 according to a lexicographic comparison.
-BASE_API int strncasecmp(const char* s1, const char* s2, size_t count);
+int strncasecmp(const char* s1, const char* s2, size_t count);
 
 // Same as strncmp but for char16 strings.
-BASE_API int strncmp16(const char16* s1, const char16* s2, size_t count);
+int strncmp16(const char16* s1, const char16* s2, size_t count);
 
 // Wrapper for vsnprintf that always null-terminates and always returns the
 // number of characters that would be in an untruncated formatted
 // string, even when truncation occurs.
-BASE_API int vsnprintf(char* buffer, size_t size, const char* format,
-                       va_list arguments)
+int vsnprintf(char* buffer, size_t size, const char* format, va_list arguments)
     PRINTF_FORMAT(3, 0);
 
 // vswprintf always null-terminates, but when truncation occurs, it will either
 // return -1 or the number of characters that would be in an untruncated
 // formatted string.  The actual return value depends on the underlying
 // C library's vswprintf implementation.
-BASE_API int vswprintf(wchar_t* buffer, size_t size,
-                       const wchar_t* format, va_list arguments)
+int vswprintf(wchar_t* buffer, size_t size,
+              const wchar_t* format, va_list arguments)
     WPRINTF_FORMAT(3, 0);
 
 // Some of these implementations need to be inlined.
 
 // We separate the declaration from the implementation of this inline
 // function just so the PRINTF_FORMAT works.
 inline int snprintf(char* buffer, size_t size, const char* format, ...)
     PRINTF_FORMAT(3, 4);
 inline int snprintf(char* buffer, size_t size, const char* format, ...) {
   va_list arguments;
@@ skipping 93 matching lines @@
 // DO NOT USE THESE AS A GENERAL-PURPOSE SUBSTITUTE FOR DEFAULT CONSTRUCTORS.
 // There is only one case where you should use these: functions which need to
 // return a string by reference (e.g. as a class member accessor), and don't
 // have an empty string to use (e.g. in an error case).  These should not be
 // used as initializers, function arguments, or return values for functions
 // which return by value or outparam.
 BASE_API const std::string& EmptyString();
 BASE_API const std::wstring& EmptyWString();
 BASE_API const string16& EmptyString16();
 
-extern const wchar_t kWhitespaceWide[];
-extern const char16 kWhitespaceUTF16[];
-extern const char kWhitespaceASCII[];
-
-extern const char kUtf8ByteOrderMark[];
-
 // Removes characters in remove_chars from anywhere in input.  Returns true if
 // any characters were removed.
 // NOTE: Safe to use the same variable for both input and output.
 BASE_API bool RemoveChars(const std::wstring& input,
                           const wchar_t remove_chars[],
                           std::wstring* output);
 BASE_API bool RemoveChars(const string16& input,
                           const char16 remove_chars[],
                           string16* output);
 BASE_API bool RemoveChars(const std::string& input,
@@ skipping 371 matching lines @@
 #elif defined(WCHAR_T_IS_UTF32)
   typedef uint32 Unsigned;
 #endif
 };
 template<>
 struct ToUnsigned<short> {
   typedef unsigned short Unsigned;
 };
 
 #endif  // BASE_STRING_UTIL_H_