1/* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef AAPT_UTIL_H 18#define AAPT_UTIL_H 19 20#include <functional> 21#include <memory> 22#include <ostream> 23#include <string> 24#include <vector> 25 26#include "androidfw/ResourceTypes.h" 27#include "androidfw/StringPiece.h" 28#include "utils/ByteOrder.h" 29 30#include "util/BigBuffer.h" 31#include "util/Maybe.h" 32 33#ifdef _WIN32 34// TODO(adamlesinski): remove once http://b/32447322 is resolved. 35// utils/ByteOrder.h includes winsock2.h on WIN32, 36// which will pull in the ERROR definition. This conflicts 37// with android-base/logging.h, which takes care of undefining 38// ERROR, but it gets included too early (before winsock2.h). 39#ifdef ERROR 40#undef ERROR 41#endif 42#endif 43 44namespace aapt { 45namespace util { 46 47template <typename T> 48struct Range { 49 T start; 50 T end; 51}; 52 53std::vector<std::string> Split(const android::StringPiece& str, char sep); 54std::vector<std::string> SplitAndLowercase(const android::StringPiece& str, char sep); 55 56/** 57 * Returns true if the string starts with prefix. 58 */ 59bool StartsWith(const android::StringPiece& str, const android::StringPiece& prefix); 60 61/** 62 * Returns true if the string ends with suffix. 63 */ 64bool EndsWith(const android::StringPiece& str, const android::StringPiece& suffix); 65 66/** 67 * Creates a new StringPiece16 that points to a substring 68 * of the original string without leading or trailing whitespace. 69 */ 70android::StringPiece TrimWhitespace(const android::StringPiece& str); 71 72/** 73 * UTF-16 isspace(). It basically checks for lower range characters that are 74 * whitespace. 75 */ 76inline bool isspace16(char16_t c) { return c < 0x0080 && isspace(c); } 77 78/** 79 * Returns an iterator to the first character that is not alpha-numeric and that 80 * is not in the allowedChars set. 81 */ 82android::StringPiece::const_iterator FindNonAlphaNumericAndNotInSet( 83 const android::StringPiece& str, const android::StringPiece& allowed_chars); 84 85/** 86 * Tests that the string is a valid Java class name. 87 */ 88bool IsJavaClassName(const android::StringPiece& str); 89 90/** 91 * Tests that the string is a valid Java package name. 92 */ 93bool IsJavaPackageName(const android::StringPiece& str); 94 95/** 96 * Converts the class name to a fully qualified class name from the given 97 * `package`. Ex: 98 * 99 * asdf --> package.asdf 100 * .asdf --> package.asdf 101 * .a.b --> package.a.b 102 * asdf.adsf --> asdf.adsf 103 */ 104Maybe<std::string> GetFullyQualifiedClassName(const android::StringPiece& package, 105 const android::StringPiece& class_name); 106 107/** 108 * Makes a std::unique_ptr<> with the template parameter inferred by the compiler. 109 * This will be present in C++14 and can be removed then. 110 */ 111template <typename T, class... Args> 112std::unique_ptr<T> make_unique(Args&&... args) { 113 return std::unique_ptr<T>(new T{std::forward<Args>(args)...}); 114} 115 116/** 117 * Writes a set of items to the std::ostream, joining the times with the 118 * provided 119 * separator. 120 */ 121template <typename Container> 122::std::function<::std::ostream&(::std::ostream&)> Joiner( 123 const Container& container, const char* sep) { 124 using std::begin; 125 using std::end; 126 const auto begin_iter = begin(container); 127 const auto end_iter = end(container); 128 return [begin_iter, end_iter, sep](::std::ostream& out) -> ::std::ostream& { 129 for (auto iter = begin_iter; iter != end_iter; ++iter) { 130 if (iter != begin_iter) { 131 out << sep; 132 } 133 out << *iter; 134 } 135 return out; 136 }; 137} 138 139/** 140 * Helper method to extract a UTF-16 string from a StringPool. If the string is 141 * stored as UTF-8, 142 * the conversion to UTF-16 happens within ResStringPool. 143 */ 144android::StringPiece16 GetString16(const android::ResStringPool& pool, size_t idx); 145 146/** 147 * Helper method to extract a UTF-8 string from a StringPool. If the string is 148 * stored as UTF-16, 149 * the conversion from UTF-16 to UTF-8 does not happen in ResStringPool and is 150 * done by this method, 151 * which maintains no state or cache. This means we must return an std::string 152 * copy. 153 */ 154std::string GetString(const android::ResStringPool& pool, size_t idx); 155 156/** 157 * Checks that the Java string format contains no non-positional arguments 158 * (arguments without 159 * explicitly specifying an index) when there are more than one argument. This 160 * is an error 161 * because translations may rearrange the order of the arguments in the string, 162 * which will 163 * break the string interpolation. 164 */ 165bool VerifyJavaStringFormat(const android::StringPiece& str); 166 167class StringBuilder { 168 public: 169 StringBuilder& Append(const android::StringPiece& str); 170 const std::string& ToString() const; 171 const std::string& Error() const; 172 bool IsEmpty() const; 173 174 // When building StyledStrings, we need UTF-16 indices into the string, 175 // which is what the Java layer expects when dealing with java 176 // String.charAt(). 177 size_t Utf16Len() const; 178 179 explicit operator bool() const; 180 181 private: 182 std::string str_; 183 size_t utf16_len_ = 0; 184 bool quote_ = false; 185 bool trailing_space_ = false; 186 bool last_char_was_escape_ = false; 187 std::string error_; 188}; 189 190inline const std::string& StringBuilder::ToString() const { return str_; } 191 192inline const std::string& StringBuilder::Error() const { return error_; } 193 194inline bool StringBuilder::IsEmpty() const { return str_.empty(); } 195 196inline size_t StringBuilder::Utf16Len() const { return utf16_len_; } 197 198inline StringBuilder::operator bool() const { return error_.empty(); } 199 200/** 201 * Converts a UTF8 string to a UTF16 string. 202 */ 203std::u16string Utf8ToUtf16(const android::StringPiece& utf8); 204std::string Utf16ToUtf8(const android::StringPiece16& utf16); 205 206/** 207 * Writes the entire BigBuffer to the output stream. 208 */ 209bool WriteAll(std::ostream& out, const BigBuffer& buffer); 210 211/* 212 * Copies the entire BigBuffer into a single buffer. 213 */ 214std::unique_ptr<uint8_t[]> Copy(const BigBuffer& buffer); 215 216/** 217 * A Tokenizer implemented as an iterable collection. It does not allocate 218 * any memory on the heap nor use standard containers. 219 */ 220class Tokenizer { 221 public: 222 class iterator { 223 public: 224 iterator(const iterator&) = default; 225 iterator& operator=(const iterator&) = default; 226 227 iterator& operator++(); 228 229 android::StringPiece operator*() { return token_; } 230 bool operator==(const iterator& rhs) const; 231 bool operator!=(const iterator& rhs) const; 232 233 private: 234 friend class Tokenizer; 235 236 iterator(android::StringPiece s, char sep, android::StringPiece tok, bool end); 237 238 android::StringPiece str_; 239 char separator_; 240 android::StringPiece token_; 241 bool end_; 242 }; 243 244 Tokenizer(android::StringPiece str, char sep); 245 246 iterator begin() { return begin_; } 247 248 iterator end() { return end_; } 249 250 private: 251 const iterator begin_; 252 const iterator end_; 253}; 254 255inline Tokenizer Tokenize(const android::StringPiece& str, char sep) { return Tokenizer(str, sep); } 256 257inline uint16_t HostToDevice16(uint16_t value) { return htods(value); } 258 259inline uint32_t HostToDevice32(uint32_t value) { return htodl(value); } 260 261inline uint16_t DeviceToHost16(uint16_t value) { return dtohs(value); } 262 263inline uint32_t DeviceToHost32(uint32_t value) { return dtohl(value); } 264 265/** 266 * Given a path like: res/xml-sw600dp/foo.xml 267 * 268 * Extracts "res/xml-sw600dp/" into outPrefix. 269 * Extracts "foo" into outEntry. 270 * Extracts ".xml" into outSuffix. 271 * 272 * Returns true if successful. 273 */ 274bool ExtractResFilePathParts(const android::StringPiece& path, android::StringPiece* out_prefix, 275 android::StringPiece* out_entry, android::StringPiece* out_suffix); 276 277} // namespace util 278 279/** 280 * Stream operator for functions. Calls the function with the stream as an 281 * argument. 282 * In the aapt namespace for lookup. 283 */ 284inline ::std::ostream& operator<<( 285 ::std::ostream& out, 286 const ::std::function<::std::ostream&(::std::ostream&)>& f) { 287 return f(out); 288} 289 290} // namespace aapt 291 292#endif // AAPT_UTIL_H 293