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 "util/BigBuffer.h" 21#include "util/Maybe.h" 22#include "util/StringPiece.h" 23 24#include <androidfw/ResourceTypes.h> 25#include <functional> 26#include <memory> 27#include <ostream> 28#include <string> 29#include <vector> 30 31namespace aapt { 32namespace util { 33 34std::vector<std::string> split(const StringPiece& str, char sep); 35std::vector<std::string> splitAndLowercase(const StringPiece& str, char sep); 36 37/** 38 * Returns true if the string starts with prefix. 39 */ 40template <typename T> 41bool stringStartsWith(const BasicStringPiece<T>& str, const BasicStringPiece<T>& prefix) { 42 if (str.size() < prefix.size()) { 43 return false; 44 } 45 return str.substr(0, prefix.size()) == prefix; 46} 47 48/** 49 * Returns true if the string ends with suffix. 50 */ 51template <typename T> 52bool stringEndsWith(const BasicStringPiece<T>& str, const BasicStringPiece<T>& suffix) { 53 if (str.size() < suffix.size()) { 54 return false; 55 } 56 return str.substr(str.size() - suffix.size(), suffix.size()) == suffix; 57} 58 59/** 60 * Creates a new StringPiece16 that points to a substring 61 * of the original string without leading or trailing whitespace. 62 */ 63StringPiece16 trimWhitespace(const StringPiece16& str); 64 65StringPiece trimWhitespace(const StringPiece& str); 66 67/** 68 * UTF-16 isspace(). It basically checks for lower range characters that are 69 * whitespace. 70 */ 71inline bool isspace16(char16_t c) { 72 return c < 0x0080 && isspace(c); 73} 74 75/** 76 * Returns an iterator to the first character that is not alpha-numeric and that 77 * is not in the allowedChars set. 78 */ 79StringPiece16::const_iterator findNonAlphaNumericAndNotInSet(const StringPiece16& str, 80 const StringPiece16& allowedChars); 81 82/** 83 * Tests that the string is a valid Java class name. 84 */ 85bool isJavaClassName(const StringPiece16& str); 86 87/** 88 * Tests that the string is a valid Java package name. 89 */ 90bool isJavaPackageName(const StringPiece16& str); 91 92/** 93 * Converts the class name to a fully qualified class name from the given `package`. Ex: 94 * 95 * asdf --> package.asdf 96 * .asdf --> package.asdf 97 * .a.b --> package.a.b 98 * asdf.adsf --> asdf.adsf 99 */ 100Maybe<std::u16string> getFullyQualifiedClassName(const StringPiece16& package, 101 const StringPiece16& className); 102 103 104/** 105 * Makes a std::unique_ptr<> with the template parameter inferred by the compiler. 106 * This will be present in C++14 and can be removed then. 107 */ 108template <typename T, class... Args> 109std::unique_ptr<T> make_unique(Args&&... args) { 110 return std::unique_ptr<T>(new T{std::forward<Args>(args)...}); 111} 112 113/** 114 * Writes a set of items to the std::ostream, joining the times with the provided 115 * separator. 116 */ 117template <typename Iterator> 118::std::function<::std::ostream&(::std::ostream&)> joiner(Iterator begin, Iterator end, 119 const char* sep) { 120 return [begin, end, sep](::std::ostream& out) -> ::std::ostream& { 121 for (auto iter = begin; iter != end; ++iter) { 122 if (iter != begin) { 123 out << sep; 124 } 125 out << *iter; 126 } 127 return out; 128 }; 129} 130 131inline ::std::function<::std::ostream&(::std::ostream&)> formatSize(size_t size) { 132 return [size](::std::ostream& out) -> ::std::ostream& { 133 constexpr size_t K = 1024u; 134 constexpr size_t M = K * K; 135 constexpr size_t G = M * K; 136 if (size < K) { 137 out << size << "B"; 138 } else if (size < M) { 139 out << (double(size) / K) << " KiB"; 140 } else if (size < G) { 141 out << (double(size) / M) << " MiB"; 142 } else { 143 out << (double(size) / G) << " GiB"; 144 } 145 return out; 146 }; 147} 148 149/** 150 * Helper method to extract a string from a StringPool. 151 */ 152inline StringPiece16 getString(const android::ResStringPool& pool, size_t idx) { 153 size_t len; 154 const char16_t* str = pool.stringAt(idx, &len); 155 if (str != nullptr) { 156 return StringPiece16(str, len); 157 } 158 return StringPiece16(); 159} 160 161inline StringPiece getString8(const android::ResStringPool& pool, size_t idx) { 162 size_t len; 163 const char* str = pool.string8At(idx, &len); 164 if (str != nullptr) { 165 return StringPiece(str, len); 166 } 167 return StringPiece(); 168} 169 170/** 171 * Checks that the Java string format contains no non-positional arguments (arguments without 172 * explicitly specifying an index) when there are more than one argument. This is an error 173 * because translations may rearrange the order of the arguments in the string, which will 174 * break the string interpolation. 175 */ 176bool verifyJavaStringFormat(const StringPiece16& str); 177 178class StringBuilder { 179public: 180 StringBuilder& append(const StringPiece16& str); 181 const std::u16string& str() const; 182 const std::string& error() const; 183 operator bool() const; 184 185private: 186 std::u16string mStr; 187 bool mQuote = false; 188 bool mTrailingSpace = false; 189 bool mLastCharWasEscape = false; 190 std::string mError; 191}; 192 193inline const std::u16string& StringBuilder::str() const { 194 return mStr; 195} 196 197inline const std::string& StringBuilder::error() const { 198 return mError; 199} 200 201inline StringBuilder::operator bool() const { 202 return mError.empty(); 203} 204 205/** 206 * Converts a UTF8 string to a UTF16 string. 207 */ 208std::u16string utf8ToUtf16(const StringPiece& utf8); 209std::string utf16ToUtf8(const StringPiece16& utf8); 210 211/** 212 * Writes the entire BigBuffer to the output stream. 213 */ 214bool writeAll(std::ostream& out, const BigBuffer& buffer); 215 216/* 217 * Copies the entire BigBuffer into a single buffer. 218 */ 219std::unique_ptr<uint8_t[]> copy(const BigBuffer& buffer); 220 221/** 222 * A Tokenizer implemented as an iterable collection. It does not allocate 223 * any memory on the heap nor use standard containers. 224 */ 225template <typename Char> 226class Tokenizer { 227public: 228 class iterator { 229 public: 230 iterator(const iterator&) = default; 231 iterator& operator=(const iterator&) = default; 232 233 iterator& operator++(); 234 BasicStringPiece<Char> operator*(); 235 bool operator==(const iterator& rhs) const; 236 bool operator!=(const iterator& rhs) const; 237 238 private: 239 friend class Tokenizer<Char>; 240 241 iterator(BasicStringPiece<Char> s, Char sep, BasicStringPiece<Char> tok, bool end); 242 243 BasicStringPiece<Char> mStr; 244 Char mSeparator; 245 BasicStringPiece<Char> mToken; 246 bool mEnd; 247 }; 248 249 Tokenizer(BasicStringPiece<Char> str, Char sep); 250 iterator begin(); 251 iterator end(); 252 253private: 254 const iterator mBegin; 255 const iterator mEnd; 256}; 257 258template <typename Char> 259inline Tokenizer<Char> tokenize(BasicStringPiece<Char> str, Char sep) { 260 return Tokenizer<Char>(str, sep); 261} 262 263template <typename Char> 264typename Tokenizer<Char>::iterator& Tokenizer<Char>::iterator::operator++() { 265 const Char* start = mToken.end(); 266 const Char* end = mStr.end(); 267 if (start == end) { 268 mEnd = true; 269 mToken.assign(mToken.end(), 0); 270 return *this; 271 } 272 273 start += 1; 274 const Char* current = start; 275 while (current != end) { 276 if (*current == mSeparator) { 277 mToken.assign(start, current - start); 278 return *this; 279 } 280 ++current; 281 } 282 mToken.assign(start, end - start); 283 return *this; 284} 285 286template <typename Char> 287inline BasicStringPiece<Char> Tokenizer<Char>::iterator::operator*() { 288 return mToken; 289} 290 291template <typename Char> 292inline bool Tokenizer<Char>::iterator::operator==(const iterator& rhs) const { 293 // We check equality here a bit differently. 294 // We need to know that the addresses are the same. 295 return mToken.begin() == rhs.mToken.begin() && mToken.end() == rhs.mToken.end() && 296 mEnd == rhs.mEnd; 297} 298 299template <typename Char> 300inline bool Tokenizer<Char>::iterator::operator!=(const iterator& rhs) const { 301 return !(*this == rhs); 302} 303 304template <typename Char> 305inline Tokenizer<Char>::iterator::iterator(BasicStringPiece<Char> s, Char sep, 306 BasicStringPiece<Char> tok, bool end) : 307 mStr(s), mSeparator(sep), mToken(tok), mEnd(end) { 308} 309 310template <typename Char> 311inline typename Tokenizer<Char>::iterator Tokenizer<Char>::begin() { 312 return mBegin; 313} 314 315template <typename Char> 316inline typename Tokenizer<Char>::iterator Tokenizer<Char>::end() { 317 return mEnd; 318} 319 320template <typename Char> 321inline Tokenizer<Char>::Tokenizer(BasicStringPiece<Char> str, Char sep) : 322 mBegin(++iterator(str, sep, BasicStringPiece<Char>(str.begin() - 1, 0), false)), 323 mEnd(str, sep, BasicStringPiece<Char>(str.end(), 0), true) { 324} 325 326inline uint16_t hostToDevice16(uint16_t value) { 327 return htods(value); 328} 329 330inline uint32_t hostToDevice32(uint32_t value) { 331 return htodl(value); 332} 333 334inline uint16_t deviceToHost16(uint16_t value) { 335 return dtohs(value); 336} 337 338inline uint32_t deviceToHost32(uint32_t value) { 339 return dtohl(value); 340} 341 342/** 343 * Given a path like: res/xml-sw600dp/foo.xml 344 * 345 * Extracts "res/xml-sw600dp/" into outPrefix. 346 * Extracts "foo" into outEntry. 347 * Extracts ".xml" into outSuffix. 348 * 349 * Returns true if successful. 350 */ 351bool extractResFilePathParts(const StringPiece16& path, StringPiece16* outPrefix, 352 StringPiece16* outEntry, StringPiece16* outSuffix); 353 354} // namespace util 355 356/** 357 * Stream operator for functions. Calls the function with the stream as an argument. 358 * In the aapt namespace for lookup. 359 */ 360inline ::std::ostream& operator<<(::std::ostream& out, 361 ::std::function<::std::ostream&(::std::ostream&)> f) { 362 return f(out); 363} 364 365} // namespace aapt 366 367#endif // AAPT_UTIL_H 368