include/rtl/character.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_RTL_CHARACTER_HXX
  21 #define INCLUDED_RTL_CHARACTER_HXX
  22
  23 #include "sal/config.h"
  24
  25 #include <cassert>
  26 #include <cstddef>
  27
  28 #include "sal/types.h"
  29
  30 namespace rtl
  31 {
  32
  33 /** Check for Unicode code point.
  34
  35     @param code  An integer.
  36
  37     @return  True if code is a Unicode code point.
  38
  39     @since LibreOffice 5.2
  40 */
  41 inline bool isUnicodeCodePoint(sal_uInt32 code)
  42 {
  43     return code <= 0x10FFFF;
  44 }
  45
  46 /** Check for ASCII character.
  47
  48     @param code  A Unicode code point.
  49
  50     @return  True if code is an ASCII character (0x00--0x7F).
  51
  52     @since LibreOffice 4.1
  53  */
  54 inline bool isAscii(sal_uInt32 code)
  55 {
  56     assert(isUnicodeCodePoint(code));
  57     return code <= 0x7F;
  58 }
  59
  60 /** Check for Unicode variation sequence selectors
  61
  62     @param code  A Unicode code point.
  63
  64     @return  True if code is an Unicode variation sequence selector.
  65
  66     @since LibreOffice 6.3
  67  */
  68 inline bool isIVSSelector(sal_uInt32 nCode)
  69 {
  70     return (nCode >= 0xFE00 && nCode <= 0xFE0F)   // Variation Selectors block
  71         || (nCode >= 0xE0100 && nCode <= 0xE01EF);// Variation Selectors Supplement block
  72 }
  73
  74 /** Check for base characters of a CJK ideographic variation sequence (IVS)
  75
  76     @param code  A Unicode code point.
  77
  78     @return  True if code is an Unicode base character part of CJK IVS
  79
  80     @since LibreOffice 6.3
  81  */
  82 inline bool isCJKIVSCharacter(sal_uInt32 nCode)
  83 {
  84     return (nCode >= 0x4E00 && nCode <= 0x9FFF)       // CJK Unified Ideographs
  85         || (nCode >= 0x3400 && nCode <= 0x4DBF)       // CJK Unified Ideographs Extension A
  86         || (nCode >= 0x20000 && nCode <= 0x2A6DF);    // CJK Unified Ideographs Extension B
  87 }
  88
  89 #if defined LIBO_INTERNAL_ONLY
  90 bool isAscii(char) = delete;
  91 bool isAscii(signed char) = delete;
  92 template<typename T> inline bool isAscii(T code)
  93 { return isAscii(sal_uInt32(code)); }
  94 #endif
  95
  96 /** Check for ASCII lower case character.
  97
  98     @param code  A Unicode code point.
  99
 100     @return  True if code is an ASCII lower case alphabetic character (ASCII
 101     'a'--'z').
 102
 103     @since LibreOffice 4.1
 104  */
 105 inline bool isAsciiLowerCase(sal_uInt32 code)
 106 {
 107     assert(isUnicodeCodePoint(code));
 108     return code >= 'a' && code <= 'z';
 109 }
 110
 111 #if defined LIBO_INTERNAL_ONLY
 112 bool isAsciiLowerCase(char) = delete;
 113 bool isAsciiLowerCase(signed char) = delete;
 114 template<typename T> inline bool isAsciiLowerCase(T code)
 115 { return isAsciiLowerCase(sal_uInt32(code)); }
 116 #endif
 117
 118 /** Check for ASCII upper case character.
 119
 120     @param code  A Unicode code point.
 121
 122     @return  True if code is an ASCII upper case alphabetic character (ASCII
 123     'A'--'Z').
 124
 125     @since LibreOffice 4.1
 126  */
 127 inline bool isAsciiUpperCase(sal_uInt32 code)
 128 {
 129     assert(isUnicodeCodePoint(code));
 130     return code >= 'A' && code <= 'Z';
 131 }
 132
 133 #if defined LIBO_INTERNAL_ONLY
 134 bool isAsciiUpperCase(char) = delete;
 135 bool isAsciiUpperCase(signed char) = delete;
 136 template<typename T> inline bool isAsciiUpperCase(T code)
 137 { return isAsciiUpperCase(sal_uInt32(code)); }
 138 #endif
 139
 140 /** Check for ASCII alphabetic character.
 141
 142     @param code  A Unicode code point.
 143
 144     @return  True if code is an ASCII alphabetic character (ASCII 'A'--'Z' or
 145     'a'--'z').
 146
 147     @since LibreOffice 4.1
 148  */
 149 inline bool isAsciiAlpha(sal_uInt32 code)
 150 {
 151     assert(isUnicodeCodePoint(code));
 152     return isAsciiLowerCase(code) || isAsciiUpperCase(code);
 153 }
 154
 155 #if defined LIBO_INTERNAL_ONLY
 156 bool isAsciiAlpha(char) = delete;
 157 bool isAsciiAlpha(signed char) = delete;
 158 template<typename T> inline bool isAsciiAlpha(T code)
 159 { return isAsciiAlpha(sal_uInt32(code)); }
 160 #endif
 161
 162 /** Check for ASCII digit character.
 163
 164     @param code  A Unicode code point.
 165
 166     @return  True if code is an ASCII (decimal) digit character (ASCII
 167     '0'--'9').
 168
 169     @since LibreOffice 4.1
 170  */
 171 inline bool isAsciiDigit(sal_uInt32 code)
 172 {
 173     assert(isUnicodeCodePoint(code));
 174     return code >= '0' && code <= '9';
 175 }
 176
 177 #if defined LIBO_INTERNAL_ONLY
 178 bool isAsciiDigit(char) = delete;
 179 bool isAsciiDigit(signed char) = delete;
 180 template<typename T> inline bool isAsciiDigit(T code)
 181 { return isAsciiDigit(sal_uInt32(code)); }
 182 #endif
 183
 184 /** Check for ASCII alphanumeric character.
 185
 186     @param code  A Unicode code point.
 187
 188     @return  True if code is an ASCII alphanumeric character (ASCII '0'--'9',
 189     'A'--'Z', or 'a'--'z').
 190
 191     @since LibreOffice 4.1
 192  */
 193 inline bool isAsciiAlphanumeric(sal_uInt32 code)
 194 {
 195     assert(isUnicodeCodePoint(code));
 196     return isAsciiDigit(code) || isAsciiAlpha(code);
 197 }
 198
 199 #if defined LIBO_INTERNAL_ONLY
 200 bool isAsciiAlphanumeric(char) = delete;
 201 bool isAsciiAlphanumeric(signed char) = delete;
 202 template<typename T> inline bool isAsciiAlphanumeric(T code)
 203 { return isAsciiAlphanumeric(sal_uInt32(code)); }
 204 #endif
 205
 206 /** Check for ASCII canonic hexadecimal digit character.
 207
 208     @param code  A Unicode code point.
 209
 210     @return  True if code is an ASCII canonic (i.e., upper case) hexadecimal
 211     digit character (ASCII '0'--'9' or 'A'--'F').
 212
 213     @since LibreOffice 4.1
 214  */
 215 inline bool isAsciiCanonicHexDigit(sal_uInt32 code)
 216 {
 217     assert(isUnicodeCodePoint(code));
 218     return isAsciiDigit(code) || (code >= 'A' && code <= 'F');
 219 }
 220
 221 #if defined LIBO_INTERNAL_ONLY
 222 bool isAsciiCanonicHexDigit(char) = delete;
 223 bool isAsciiCanonicHexDigit(signed char) = delete;
 224 template<typename T> inline bool isAsciiCanonicHexDigit(T code)
 225 { return isAsciiCanonicHexDigit(sal_uInt32(code)); }
 226 #endif
 227
 228 /** Check for ASCII hexadecimal digit character.
 229
 230     @param code  A Unicode code point.
 231
 232     @return  True if code is an ASCII hexadecimal digit character (ASCII
 233     '0'--'9', 'A'--'F', or 'a'--'f').
 234
 235     @since LibreOffice 4.1
 236  */
 237 inline bool isAsciiHexDigit(sal_uInt32 code)
 238 {
 239     assert(isUnicodeCodePoint(code));
 240     return isAsciiCanonicHexDigit(code) || (code >= 'a' && code <= 'f');
 241 }
 242
 243 #if defined LIBO_INTERNAL_ONLY
 244 bool isAsciiHexDigit(char) = delete;
 245 bool isAsciiHexDigit(signed char) = delete;
 246 template<typename T> inline bool isAsciiHexDigit(T code)
 247 { return isAsciiHexDigit(sal_uInt32(code)); }
 248 #endif
 249
 250 /** Check for ASCII octal digit character.
 251
 252     @param code  A Unicode code point.
 253
 254     @return  True if code is an ASCII octal digit character (ASCII '0'--'7').
 255
 256     @since LibreOffice 5.0
 257  */
 258 inline bool isAsciiOctalDigit(sal_uInt32 code)
 259 {
 260     assert(isUnicodeCodePoint(code));
 261     return code >= '0' && code <= '7';
 262 }
 263
 264 #if defined LIBO_INTERNAL_ONLY
 265 bool isAsciiOctalDigit(char) = delete;
 266 bool isAsciiOctalDigit(signed char) = delete;
 267 template<typename T> inline bool isAsciiOctalDigit(T code)
 268 { return isAsciiOctalDigit(sal_uInt32(code)); }
 269 #endif
 270
 271 /** Check for ASCII white space character.
 272
 273     @param code  A Unicode code point.
 274
 275     @return  True if code is an ASCII white space character as defined by C for
 276     isspace in the "C" locale (ASCII ' ', '\\f', '\\n', '\\r', '\\t' '\\v').
 277
 278     @since LibreOffice 5.4
 279 */
 280 inline bool isAsciiWhiteSpace(sal_uInt32 code)
 281 {
 282     assert(isUnicodeCodePoint(code));
 283     return code == ' ' || code == '\f' || code == '\n' || code == '\r'
 284         || code == '\t' || code == '\v';
 285 }
 286
 287 #if defined LIBO_INTERNAL_ONLY
 288 bool isAsciiWhiteSpace(char) = delete;
 289 bool isAsciiWhiteSpace(signed char) = delete;
 290 template<typename T> inline bool isAsciiWhiteSpace(T code)
 291 { return isAsciiWhiteSpace(sal_uInt32(code)); }
 292 #endif
 293
 294 /** Convert a character, if ASCII, to upper case.
 295
 296     @param code  A Unicode code point.
 297
 298     @return  code converted to ASCII upper case.
 299
 300     @since LibreOffice 4.2
 301 */
 302 inline sal_uInt32 toAsciiUpperCase(sal_uInt32 code)
 303 {
 304     assert(isUnicodeCodePoint(code));
 305     return isAsciiLowerCase(code) ? code - 32 : code;
 306 }
 307
 308 #if defined LIBO_INTERNAL_ONLY
 309 sal_uInt32 toAsciiUpperCase(char) = delete;
 310 sal_uInt32 toAsciiUpperCase(signed char) = delete;
 311 template<typename T> inline sal_uInt32 toAsciiUpperCase(T code)
 312 { return toAsciiUpperCase(sal_uInt32(code)); }
 313 #endif
 314
 315 /** Convert a character, if ASCII, to lower case.
 316
 317     @param code  A Unicode code point.
 318
 319     @return  code converted to ASCII lower case.
 320
 321     @since LibreOffice 4.2
 322 */
 323 inline sal_uInt32 toAsciiLowerCase(sal_uInt32 code)
 324 {
 325     assert(isUnicodeCodePoint(code));
 326     return isAsciiUpperCase(code) ? code + 32 : code;
 327 }
 328
 329 #if defined LIBO_INTERNAL_ONLY
 330 sal_uInt32 toAsciiLowerCase(char) = delete;
 331 sal_uInt32 toAsciiLowerCase(signed char) = delete;
 332 template<typename T> inline sal_uInt32 toAsciiLowerCase(T code)
 333 { return toAsciiLowerCase(sal_uInt32(code)); }
 334 #endif
 335
 336 /** Compare two characters ignoring ASCII case.
 337
 338     @param code1  A Unicode code point.
 339
 340     @param code2  A unicode code point.
 341
 342     @return  0 if both code points are equal,
 343              < 0 if code1 is less than code2,
 344              > 0 if code1 is greater than code2.
 345
 346     @since LibreOffice 4.2
 347  */
 348 inline sal_Int32 compareIgnoreAsciiCase(sal_uInt32 code1, sal_uInt32 code2)
 349 {
 350     assert(isUnicodeCodePoint(code1));
 351     assert(isUnicodeCodePoint(code2));
 352     return static_cast<sal_Int32>(toAsciiLowerCase(code1))
 353         - static_cast<sal_Int32>(toAsciiLowerCase(code2));
 354 }
 355
 356 /// @cond INTERNAL
 357 namespace detail {
 358
 359 sal_uInt32 const surrogatesHighFirst = 0xD800;
 360 sal_uInt32 const surrogatesHighLast = 0xDBFF;
 361 sal_uInt32 const surrogatesLowFirst = 0xDC00;
 362 sal_uInt32 const surrogatesLowLast = 0xDFFF;
 363
 364 }
 365 /// @endcond
 366
 367 /** Check for surrogate.
 368
 369     @param code  A Unicode code point.
 370
 371     @return  True if code is a surrogate code point (0xD800--0xDFFF).
 372
 373     @since LibreOffice 6.0
 374 */
 375 inline bool isSurrogate(sal_uInt32 code) {
 376     assert(isUnicodeCodePoint(code));
 377     return code >= detail::surrogatesHighFirst
 378         && code <= detail::surrogatesLowLast;
 379 }
 380
 381 /** Check for high surrogate.
 382
 383     @param code  A Unicode code point.
 384
 385     @return  True if code is a high surrogate code point (0xD800--0xDBFF).
 386
 387     @since LibreOffice 5.0
 388 */
 389 inline bool isHighSurrogate(sal_uInt32 code) {
 390     assert(isUnicodeCodePoint(code));
 391     return code >= detail::surrogatesHighFirst
 392         && code <= detail::surrogatesHighLast;
 393 }
 394
 395 /** Check for low surrogate.
 396
 397     @param code  A Unicode code point.
 398
 399     @return  True if code is a low surrogate code point (0xDC00--0xDFFF).
 400
 401     @since LibreOffice 5.0
 402 */
 403 inline bool isLowSurrogate(sal_uInt32 code) {
 404     assert(isUnicodeCodePoint(code));
 405     return code >= detail::surrogatesLowFirst
 406         && code <= detail::surrogatesLowLast;
 407 }
 408
 409 /** Get high surrogate half of a non-BMP Unicode code point.
 410
 411     @param code  A non-BMP Unicode code point.
 412
 413     @return  The UTF-16 high surrogate half for the give code point.
 414
 415     @since LibreOffice 5.0
 416  */
 417 inline sal_Unicode getHighSurrogate(sal_uInt32 code) {
 418     assert(isUnicodeCodePoint(code));
 419     assert(code >= 0x10000);
 420     return static_cast<sal_Unicode>(((code - 0x10000) >> 10) | detail::surrogatesHighFirst);
 421 }
 422
 423 /** Get low surrogate half of a non-BMP Unicode code point.
 424
 425     @param code  A non-BMP Unicode code point.
 426
 427     @return  The UTF-16 low surrogate half for the give code point.
 428
 429     @since LibreOffice 5.0
 430  */
 431 inline sal_Unicode getLowSurrogate(sal_uInt32 code) {
 432     assert(isUnicodeCodePoint(code));
 433     assert(code >= 0x10000);
 434     return static_cast<sal_Unicode>(((code - 0x10000) & 0x3FF) | detail::surrogatesLowFirst);
 435 }
 436
 437 /** Combine surrogates to form a code point.
 438
 439     @param high  A high surrogate code point.
 440
 441     @param low  A low surrogate code point.
 442
 443     @return  The code point represented by the surrogate pair.
 444
 445     @since LibreOffice 5.0
 446 */
 447 inline sal_uInt32 combineSurrogates(sal_uInt32 high, sal_uInt32 low) {
 448     assert(isHighSurrogate(high));
 449     assert(isLowSurrogate(low));
 450     return ((high - detail::surrogatesHighFirst) << 10)
 451         + (low - detail::surrogatesLowFirst) + 0x10000;
 452 }
 453
 454 /** Split a Unicode code point into UTF-16 code units.
 455
 456     @param code  A Unicode code point.
 457
 458     @param output  A non-null pointer to an array with space for at least two
 459     sal_Unicode UTF-16 code units.
 460
 461     @return  The number of UTF-16 code units placed into the output (either one
 462     or two).
 463
 464     @since LibreOffice 5.3
 465 */
 466 inline std::size_t splitSurrogates(sal_uInt32 code, sal_Unicode * output) {
 467     assert(isUnicodeCodePoint(code));
 468     assert(output != NULL);
 469     if (code < 0x10000) {
 470         output[0] = code;
 471         return 1;
 472     } else {
 473         output[0] = getHighSurrogate(code);
 474         output[1] = getLowSurrogate(code);
 475         return 2;
 476     }
 477 }
 478
 479 /** Check for Unicode scalar value.
 480
 481     @param code  An integer.
 482
 483     @return  True if code is a Unicode scalar value.
 484
 485     @since LibreOffice 6.0
 486 */
 487 inline bool isUnicodeScalarValue(sal_uInt32 code)
 488 {
 489     return isUnicodeCodePoint(code) && !isSurrogate(code);
 490 }
 491
 492 }
 493
 494 #endif
 495
 496 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */