boost/spirit
2
0
Fork 0
mirror of https://github.com/boostorg/spirit.git synced 2026-01-19 04:42:11 +00:00
Code Issues Projects Releases Wiki Activity

Modernize char_encoding

Browse Source
This commit is contained in:
Nana Sakisaka
2025-09-08 08:38:00 +09:00
parent b9d3fe6d73
commit 572da40062
11 changed files with 8359 additions and 8335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

385
include/boost/spirit/home/x3/char_encoding/ascii.hpp
View File

@@ -1,189 +1,184 @@
/*=============================================================================
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2025 Nana Sakisaka
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#if !defined(BOOST_SPIRIT_ASCII_APRIL_26_2006_1106PM)
#define BOOST_SPIRIT_ASCII_APRIL_26_2006_1106PM
#ifndef BOOST_SPIRIT_X3_CHAR_ENCODING_ASCII_HPP
#define BOOST_SPIRIT_X3_CHAR_ENCODING_ASCII_HPP
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/spirit/home/x3/char_encoding/detail/encoding_warning.hpp>
#include <boost/assert.hpp>
#include <climits>
#include <boost/assert.hpp>
#include <boost/cstdint.hpp>
#include <cstdint>
///////////////////////////////////////////////////////////////////////////////
// constants used to classify the single characters
///////////////////////////////////////////////////////////////////////////////
#define BOOST_CC_DIGIT 0x0001
#define BOOST_CC_XDIGIT 0x0002
#define BOOST_CC_ALPHA 0x0004
#define BOOST_CC_CTRL 0x0008
#define BOOST_CC_LOWER 0x0010
#define BOOST_CC_UPPER 0x0020
#define BOOST_CC_SPACE 0x0040
#define BOOST_CC_PUNCT 0x0080
#define BOOST_SPIRIT_X3_CC_DIGIT 0x0001
#define BOOST_SPIRIT_X3_CC_XDIGIT 0x0002
#define BOOST_SPIRIT_X3_CC_ALPHA 0x0004
#define BOOST_SPIRIT_X3_CC_CTRL 0x0008
#define BOOST_SPIRIT_X3_CC_LOWER 0x0010
#define BOOST_SPIRIT_X3_CC_UPPER 0x0020
#define BOOST_SPIRIT_X3_CC_SPACE 0x0040
#define BOOST_SPIRIT_X3_CC_PUNCT 0x0080
namespace boost { namespace spirit { namespace char_encoding
namespace boost::spirit::x3::char_encoding
{
// The detection of isgraph(), isprint() and isblank() is done programmatically
// to keep the character type table small. Additionally, these functions are
// rather seldom used and the programmatic detection is very simple.
///////////////////////////////////////////////////////////////////////////
// ASCII character classification table
///////////////////////////////////////////////////////////////////////////
const unsigned char ascii_char_types[] =
{
/* NUL 0 0 */ BOOST_CC_CTRL,
/* SOH 1 1 */ BOOST_CC_CTRL,
/* STX 2 2 */ BOOST_CC_CTRL,
/* ETX 3 3 */ BOOST_CC_CTRL,
/* EOT 4 4 */ BOOST_CC_CTRL,
/* ENQ 5 5 */ BOOST_CC_CTRL,
/* ACK 6 6 */ BOOST_CC_CTRL,
/* BEL 7 7 */ BOOST_CC_CTRL,
/* BS 8 8 */ BOOST_CC_CTRL,
/* HT 9 9 */ BOOST_CC_CTRL|BOOST_CC_SPACE,
/* NL 10 a */ BOOST_CC_CTRL|BOOST_CC_SPACE,
/* VT 11 b */ BOOST_CC_CTRL|BOOST_CC_SPACE,
/* NP 12 c */ BOOST_CC_CTRL|BOOST_CC_SPACE,
/* CR 13 d */ BOOST_CC_CTRL|BOOST_CC_SPACE,
/* SO 14 e */ BOOST_CC_CTRL,
/* SI 15 f */ BOOST_CC_CTRL,
/* DLE 16 10 */ BOOST_CC_CTRL,
/* DC1 17 11 */ BOOST_CC_CTRL,
/* DC2 18 12 */ BOOST_CC_CTRL,
/* DC3 19 13 */ BOOST_CC_CTRL,
/* DC4 20 14 */ BOOST_CC_CTRL,
/* NAK 21 15 */ BOOST_CC_CTRL,
/* SYN 22 16 */ BOOST_CC_CTRL,
/* ETB 23 17 */ BOOST_CC_CTRL,
/* CAN 24 18 */ BOOST_CC_CTRL,
/* EM 25 19 */ BOOST_CC_CTRL,
/* SUB 26 1a */ BOOST_CC_CTRL,
/* ESC 27 1b */ BOOST_CC_CTRL,
/* FS 28 1c */ BOOST_CC_CTRL,
/* GS 29 1d */ BOOST_CC_CTRL,
/* RS 30 1e */ BOOST_CC_CTRL,
/* US 31 1f */ BOOST_CC_CTRL,
/* SP 32 20 */ BOOST_CC_SPACE,
/* ! 33 21 */ BOOST_CC_PUNCT,
/* " 34 22 */ BOOST_CC_PUNCT,
/* # 35 23 */ BOOST_CC_PUNCT,
/* $ 36 24 */ BOOST_CC_PUNCT,
/* % 37 25 */ BOOST_CC_PUNCT,
/* & 38 26 */ BOOST_CC_PUNCT,
/* ' 39 27 */ BOOST_CC_PUNCT,
/* ( 40 28 */ BOOST_CC_PUNCT,
/* ) 41 29 */ BOOST_CC_PUNCT,
/* * 42 2a */ BOOST_CC_PUNCT,
/* + 43 2b */ BOOST_CC_PUNCT,
/* , 44 2c */ BOOST_CC_PUNCT,
/* - 45 2d */ BOOST_CC_PUNCT,
/* . 46 2e */ BOOST_CC_PUNCT,
/* / 47 2f */ BOOST_CC_PUNCT,
/* 0 48 30 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* 1 49 31 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* 2 50 32 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* 3 51 33 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* 4 52 34 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* 5 53 35 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* 6 54 36 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* 7 55 37 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* 8 56 38 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* 9 57 39 */ BOOST_CC_DIGIT|BOOST_CC_XDIGIT,
/* : 58 3a */ BOOST_CC_PUNCT,
/* ; 59 3b */ BOOST_CC_PUNCT,
/* < 60 3c */ BOOST_CC_PUNCT,
/* = 61 3d */ BOOST_CC_PUNCT,
/* > 62 3e */ BOOST_CC_PUNCT,
/* ? 63 3f */ BOOST_CC_PUNCT,
/* @ 64 40 */ BOOST_CC_PUNCT,
/* A 65 41 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
/* B 66 42 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
/* C 67 43 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
/* D 68 44 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
/* E 69 45 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
/* F 70 46 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_UPPER,
/* G 71 47 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* H 72 48 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* I 73 49 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* J 74 4a */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* K 75 4b */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* L 76 4c */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* M 77 4d */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* N 78 4e */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* O 79 4f */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* P 80 50 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* Q 81 51 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* R 82 52 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* S 83 53 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* T 84 54 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* U 85 55 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* V 86 56 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* W 87 57 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* X 88 58 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* Y 89 59 */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* Z 90 5a */ BOOST_CC_ALPHA|BOOST_CC_UPPER,
/* [ 91 5b */ BOOST_CC_PUNCT,
/* \ 92 5c */ BOOST_CC_PUNCT,
/* ] 93 5d */ BOOST_CC_PUNCT,
/* ^ 94 5e */ BOOST_CC_PUNCT,
/* _ 95 5f */ BOOST_CC_PUNCT,
/* ` 96 60 */ BOOST_CC_PUNCT,
/* a 97 61 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
/* b 98 62 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
/* c 99 63 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
/* d 100 64 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
/* e 101 65 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
/* f 102 66 */ BOOST_CC_ALPHA|BOOST_CC_XDIGIT|BOOST_CC_LOWER,
/* g 103 67 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* h 104 68 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* i 105 69 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* j 106 6a */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* k 107 6b */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* l 108 6c */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* m 109 6d */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* n 110 6e */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* o 111 6f */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* p 112 70 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* q 113 71 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* r 114 72 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* s 115 73 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* t 116 74 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* u 117 75 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* v 118 76 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* w 119 77 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* x 120 78 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* y 121 79 */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* z 122 7a */ BOOST_CC_ALPHA|BOOST_CC_LOWER,
/* { 123 7b */ BOOST_CC_PUNCT,
/* | 124 7c */ BOOST_CC_PUNCT,
/* } 125 7d */ BOOST_CC_PUNCT,
/* ~ 126 7e */ BOOST_CC_PUNCT,
/* DEL 127 7f */ BOOST_CC_CTRL,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
// Test characters for specified conditions (using ASCII)
///////////////////////////////////////////////////////////////////////////
// Test characters for specified conditions (using ASCII)
///////////////////////////////////////////////////////////////////////////
struct ascii
{
typedef char char_type;
typedef unsigned char classify_type;
using char_type = char;
using classify_type = unsigned char;
// ASCII character classification table
inline static constexpr unsigned char ascii_char_types[] =
{
/* NUL 0 0 */ BOOST_SPIRIT_X3_CC_CTRL,
/* SOH 1 1 */ BOOST_SPIRIT_X3_CC_CTRL,
/* STX 2 2 */ BOOST_SPIRIT_X3_CC_CTRL,
/* ETX 3 3 */ BOOST_SPIRIT_X3_CC_CTRL,
/* EOT 4 4 */ BOOST_SPIRIT_X3_CC_CTRL,
/* ENQ 5 5 */ BOOST_SPIRIT_X3_CC_CTRL,
/* ACK 6 6 */ BOOST_SPIRIT_X3_CC_CTRL,
/* BEL 7 7 */ BOOST_SPIRIT_X3_CC_CTRL,
/* BS 8 8 */ BOOST_SPIRIT_X3_CC_CTRL,
/* HT 9 9 */ BOOST_SPIRIT_X3_CC_CTRL|BOOST_SPIRIT_X3_CC_SPACE,
/* NL 10 a */ BOOST_SPIRIT_X3_CC_CTRL|BOOST_SPIRIT_X3_CC_SPACE,
/* VT 11 b */ BOOST_SPIRIT_X3_CC_CTRL|BOOST_SPIRIT_X3_CC_SPACE,
/* NP 12 c */ BOOST_SPIRIT_X3_CC_CTRL|BOOST_SPIRIT_X3_CC_SPACE,
/* CR 13 d */ BOOST_SPIRIT_X3_CC_CTRL|BOOST_SPIRIT_X3_CC_SPACE,
/* SO 14 e */ BOOST_SPIRIT_X3_CC_CTRL,
/* SI 15 f */ BOOST_SPIRIT_X3_CC_CTRL,
/* DLE 16 10 */ BOOST_SPIRIT_X3_CC_CTRL,
/* DC1 17 11 */ BOOST_SPIRIT_X3_CC_CTRL,
/* DC2 18 12 */ BOOST_SPIRIT_X3_CC_CTRL,
/* DC3 19 13 */ BOOST_SPIRIT_X3_CC_CTRL,
/* DC4 20 14 */ BOOST_SPIRIT_X3_CC_CTRL,
/* NAK 21 15 */ BOOST_SPIRIT_X3_CC_CTRL,
/* SYN 22 16 */ BOOST_SPIRIT_X3_CC_CTRL,
/* ETB 23 17 */ BOOST_SPIRIT_X3_CC_CTRL,
/* CAN 24 18 */ BOOST_SPIRIT_X3_CC_CTRL,
/* EM 25 19 */ BOOST_SPIRIT_X3_CC_CTRL,
/* SUB 26 1a */ BOOST_SPIRIT_X3_CC_CTRL,
/* ESC 27 1b */ BOOST_SPIRIT_X3_CC_CTRL,
/* FS 28 1c */ BOOST_SPIRIT_X3_CC_CTRL,
/* GS 29 1d */ BOOST_SPIRIT_X3_CC_CTRL,
/* RS 30 1e */ BOOST_SPIRIT_X3_CC_CTRL,
/* US 31 1f */ BOOST_SPIRIT_X3_CC_CTRL,
/* SP 32 20 */ BOOST_SPIRIT_X3_CC_SPACE,
/* ! 33 21 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* " 34 22 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* # 35 23 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* $ 36 24 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* % 37 25 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* & 38 26 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* ' 39 27 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* ( 40 28 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* ) 41 29 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* * 42 2a */ BOOST_SPIRIT_X3_CC_PUNCT,
/* + 43 2b */ BOOST_SPIRIT_X3_CC_PUNCT,
/* , 44 2c */ BOOST_SPIRIT_X3_CC_PUNCT,
/* - 45 2d */ BOOST_SPIRIT_X3_CC_PUNCT,
/* . 46 2e */ BOOST_SPIRIT_X3_CC_PUNCT,
/* / 47 2f */ BOOST_SPIRIT_X3_CC_PUNCT,
/* 0 48 30 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* 1 49 31 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* 2 50 32 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* 3 51 33 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* 4 52 34 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* 5 53 35 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* 6 54 36 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* 7 55 37 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* 8 56 38 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* 9 57 39 */ BOOST_SPIRIT_X3_CC_DIGIT|BOOST_SPIRIT_X3_CC_XDIGIT,
/* : 58 3a */ BOOST_SPIRIT_X3_CC_PUNCT,
/* ; 59 3b */ BOOST_SPIRIT_X3_CC_PUNCT,
/* < 60 3c */ BOOST_SPIRIT_X3_CC_PUNCT,
/* = 61 3d */ BOOST_SPIRIT_X3_CC_PUNCT,
/* > 62 3e */ BOOST_SPIRIT_X3_CC_PUNCT,
/* ? 63 3f */ BOOST_SPIRIT_X3_CC_PUNCT,
/* @ 64 40 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* A 65 41 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_UPPER,
/* B 66 42 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_UPPER,
/* C 67 43 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_UPPER,
/* D 68 44 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_UPPER,
/* E 69 45 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_UPPER,
/* F 70 46 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_UPPER,
/* G 71 47 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* H 72 48 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* I 73 49 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* J 74 4a */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* K 75 4b */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* L 76 4c */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* M 77 4d */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* N 78 4e */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* O 79 4f */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* P 80 50 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* Q 81 51 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* R 82 52 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* S 83 53 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* T 84 54 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* U 85 55 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* V 86 56 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* W 87 57 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* X 88 58 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* Y 89 59 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* Z 90 5a */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_UPPER,
/* [ 91 5b */ BOOST_SPIRIT_X3_CC_PUNCT,
/* \ 92 5c */ BOOST_SPIRIT_X3_CC_PUNCT,
/* ] 93 5d */ BOOST_SPIRIT_X3_CC_PUNCT,
/* ^ 94 5e */ BOOST_SPIRIT_X3_CC_PUNCT,
/* _ 95 5f */ BOOST_SPIRIT_X3_CC_PUNCT,
/* ` 96 60 */ BOOST_SPIRIT_X3_CC_PUNCT,
/* a 97 61 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_LOWER,
/* b 98 62 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_LOWER,
/* c 99 63 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_LOWER,
/* d 100 64 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_LOWER,
/* e 101 65 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_LOWER,
/* f 102 66 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_XDIGIT|BOOST_SPIRIT_X3_CC_LOWER,
/* g 103 67 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* h 104 68 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* i 105 69 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* j 106 6a */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* k 107 6b */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* l 108 6c */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* m 109 6d */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* n 110 6e */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* o 111 6f */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* p 112 70 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* q 113 71 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* r 114 72 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* s 115 73 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* t 116 74 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* u 117 75 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* v 118 76 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* w 119 77 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* x 120 78 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* y 121 79 */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* z 122 7a */ BOOST_SPIRIT_X3_CC_ALPHA|BOOST_SPIRIT_X3_CC_LOWER,
/* { 123 7b */ BOOST_SPIRIT_X3_CC_PUNCT,
/* | 124 7c */ BOOST_SPIRIT_X3_CC_PUNCT,
/* } 125 7d */ BOOST_SPIRIT_X3_CC_PUNCT,
/* ~ 126 7e */ BOOST_SPIRIT_X3_CC_PUNCT,
/* DEL 127 7f */ BOOST_SPIRIT_X3_CC_CTRL,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
static bool
isascii_(int ch)
@@ -191,6 +186,7 @@ namespace boost { namespace spirit { namespace char_encoding
return 0 == (ch & ~0x7f);
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
ischar(int ch)
{
@@ -209,42 +205,48 @@ namespace boost { namespace spirit { namespace char_encoding
return ch >= 0 && ch <= 127;
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
isalnum(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return (ascii_char_types[ch] & BOOST_CC_ALPHA)
|| (ascii_char_types[ch] & BOOST_CC_DIGIT);
return (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_ALPHA)
|| (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_DIGIT);
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
isalpha(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return (ascii_char_types[ch] & BOOST_CC_ALPHA) ? true : false;
return (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_ALPHA) ? true : false;
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
isdigit(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return (ascii_char_types[ch] & BOOST_CC_DIGIT) ? true : false;
return (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_DIGIT) ? true : false;
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
isxdigit(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return (ascii_char_types[ch] & BOOST_CC_XDIGIT) ? true : false;
return (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_XDIGIT) ? true : false;
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
iscntrl(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return (ascii_char_types[ch] & BOOST_CC_CTRL) ? true : false;
return (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_CTRL) ? true : false;
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
isgraph(int ch)
{
@@ -256,9 +258,10 @@ namespace boost { namespace spirit { namespace char_encoding
islower(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return (ascii_char_types[ch] & BOOST_CC_LOWER) ? true : false;
return (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_LOWER) ? true : false;
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
isprint(int ch)
{
@@ -266,22 +269,25 @@ namespace boost { namespace spirit { namespace char_encoding
return ('\x20' <= ch && ch <= '\x7e');
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
ispunct(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return (ascii_char_types[ch] & BOOST_CC_PUNCT) ? true : false;
return (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_PUNCT) ? true : false;
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
isspace(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return (ascii_char_types[ch] & BOOST_CC_SPACE) ? true : false;
return (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_SPACE) ? true : false;
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static bool
isblank BOOST_PREVENT_MACRO_SUBSTITUTION (int ch)
(isblank)(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return ('\x09' == ch || '\x20' == ch);
@@ -291,13 +297,12 @@ namespace boost { namespace spirit { namespace char_encoding
isupper(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
return (ascii_char_types[ch] & BOOST_CC_UPPER) ? true : false;
return (ascii_char_types[ch] & BOOST_SPIRIT_X3_CC_UPPER) ? true : false;
}
///////////////////////////////////////////////////////////////////////
// Simple character conversions
///////////////////////////////////////////////////////////////////////
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static int
tolower(int ch)
{
@@ -305,6 +310,7 @@ namespace boost { namespace spirit { namespace char_encoding
return isupper(ch) ? (ch - 'A' + 'a') : ch;
}
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static int
toupper(int ch)
{
@@ -312,7 +318,8 @@ namespace boost { namespace spirit { namespace char_encoding
return islower(ch) ? (ch - 'a' + 'A') : ch;
}
static ::boost::uint32_t
[[deprecated(BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING)]]
static std::uint32_t
toucs4(int ch)
{
BOOST_ASSERT(strict_ischar(ch));
@@ -320,18 +327,16 @@ namespace boost { namespace spirit { namespace char_encoding
}
};
}}}
} // boost::spirit::x3::char_encoding
///////////////////////////////////////////////////////////////////////////////
// undefine macros
///////////////////////////////////////////////////////////////////////////////
#undef BOOST_CC_DIGIT
#undef BOOST_CC_XDIGIT
#undef BOOST_CC_ALPHA
#undef BOOST_CC_CTRL
#undef BOOST_CC_LOWER
#undef BOOST_CC_UPPER
#undef BOOST_CC_PUNCT
#undef BOOST_CC_SPACE
#undef BOOST_SPIRIT_X3_CC_DIGIT
#undef BOOST_SPIRIT_X3_CC_XDIGIT
#undef BOOST_SPIRIT_X3_CC_ALPHA
#undef BOOST_SPIRIT_X3_CC_CTRL
#undef BOOST_SPIRIT_X3_CC_LOWER
#undef BOOST_SPIRIT_X3_CC_UPPER
#undef BOOST_SPIRIT_X3_CC_PUNCT
#undef BOOST_SPIRIT_X3_CC_SPACE
#endif

21
include/boost/spirit/home/x3/char_encoding/detail/encoding_warning.hpp Normal file
View File

@@ -0,0 +1,21 @@
/*=============================================================================
Copyright (c) 2025 Nana Sakisaka
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef BOOST_SPIRIT_X3_CHAR_ENCODING_DETAIL_ENCODING_WARNING_HPP
#define BOOST_SPIRIT_X3_CHAR_ENCODING_DETAIL_ENCODING_WARNING_HPP
#define BOOST_SPIRIT_X3_WRONG_ENCODING_ASSUMPTION_WARNING \
"Hard-coding ASCII or Latin-1 assumptions is almost always wrong " \
"in modern applications and can introduce security vulnerabilities. " \
"Unless the input is provably ASCII-only (e.g., fixed-format data from " \
"the 1980s), the only correct interpretation uses the data's *original* " \
"encoding. Prefer transcoding to Unicode or to the implementation-defined " \
"execution character set before passing text to general-purpose parsers. " \
"For more information, refer to authoritative sources on C++ character " \
"encodings and Unicode fundamentals."
#endif

1198
include/boost/spirit/home/x3/char_encoding/iso8859_1.hpp
View File

File diff suppressed because it is too large Load Diff

132
include/boost/spirit/home/x3/char_encoding/standard.hpp
View File

@@ -1,40 +1,36 @@
/*=============================================================================
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2025 Nana Sakisaka
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#if !defined(BOOST_SPIRIT_STANDARD_APRIL_26_2006_1106PM)
#define BOOST_SPIRIT_STANDARD_APRIL_26_2006_1106PM
#ifndef BOOST_SPIRIT_X3_CHAR_ENCODING_STANDARD_HPP
#define BOOST_SPIRIT_X3_CHAR_ENCODING_STANDARD_HPP
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/assert.hpp>
#include <cstdint>
#include <cctype>
#include <climits>
#include <boost/assert.hpp>
#include <boost/cstdint.hpp>
namespace boost { namespace spirit { namespace char_encoding
namespace boost::spirit::x3::char_encoding
{
///////////////////////////////////////////////////////////////////////////
// Test characters for specified conditions (using std functions)
///////////////////////////////////////////////////////////////////////////
// Test characters for specified conditions (using std functions)
struct standard
{
typedef char char_type;
typedef unsigned char classify_type;
using char_type = char;
using classify_type = unsigned char;
static bool
isascii_(int ch)
[[nodiscard]] static constexpr bool
isascii_(int ch) noexcept
{
return 0 == (ch & ~0x7f);
}
static bool
ischar(int ch)
[[nodiscard]] static constexpr bool
ischar(int ch) noexcept
{
// uses all 8 bits
// we have to watch out for sign extensions
@@ -47,122 +43,120 @@ namespace boost { namespace spirit { namespace char_encoding
// responsibility of the caller to make sure this precondition is not
// violated.
static bool
strict_ischar(int ch)
[[nodiscard]] static constexpr bool
strict_ischar(int ch) noexcept
{
// ch should be representable as an unsigned char
return ch >= 0 && ch <= UCHAR_MAX;
}
static bool
isalnum(int ch)
[[nodiscard]] static bool // TODO: constexpr
isalnum(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::isalnum(ch) != 0;
}
static bool
isalpha(int ch)
[[nodiscard]] static bool // TODO: constexpr
isalpha(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::isalpha(ch) != 0;
}
static bool
isdigit(int ch)
[[nodiscard]] static bool // TODO: constexpr
isdigit(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::isdigit(ch) != 0;
}
static bool
isxdigit(int ch)
[[nodiscard]] static bool // TODO: constexpr
isxdigit(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::isxdigit(ch) != 0;
}
static bool
iscntrl(int ch)
[[nodiscard]] static bool // TODO: constexpr
iscntrl(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::iscntrl(ch) != 0;
}
static bool
isgraph(int ch)
[[nodiscard]] static bool // TODO: constexpr
isgraph(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::isgraph(ch) != 0;
}
static bool
islower(int ch)
[[nodiscard]] static bool // TODO: constexpr
islower(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::islower(ch) != 0;
}
static bool
isprint(int ch)
[[nodiscard]] static bool // TODO: constexpr
isprint(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::isprint(ch) != 0;
}
static bool
ispunct(int ch)
[[nodiscard]] static bool // TODO: constexpr
ispunct(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::ispunct(ch) != 0;
}
static bool
isspace(int ch)
[[nodiscard]] static bool // TODO: constexpr
isspace(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::isspace(ch) != 0;
}
static bool
isblank BOOST_PREVENT_MACRO_SUBSTITUTION (int ch)
[[nodiscard]] static constexpr bool
(isblank)(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return (ch == ' ' || ch == '\t');
}
static bool
isupper(int ch)
[[nodiscard]] static bool // TODO: constexpr
isupper(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::isupper(ch) != 0;
}
///////////////////////////////////////////////////////////////////////////////
// Simple character conversions
///////////////////////////////////////////////////////////////////////////////
// Simple character conversions
static int
tolower(int ch)
[[nodiscard]] static int // TODO: constexpr
tolower(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::tolower(ch);
}
static int
toupper(int ch)
[[nodiscard]] static int // TODO: constexpr
toupper(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
BOOST_ASSERT(standard::strict_ischar(ch));
return std::toupper(ch);
}
static ::boost::uint32_t
toucs4(int ch)
[[nodiscard]] static constexpr std::uint32_t
toucs4(int ch) noexcept
{
BOOST_ASSERT(strict_ischar(ch));
return ch;
BOOST_ASSERT(standard::strict_ischar(ch));
return static_cast<std::uint32_t>(ch);
}
};
}}}
} // boost::spirit::x3::char_encoding
#endif

181
include/boost/spirit/home/x3/char_encoding/standard_wide.hpp
View File

@@ -1,189 +1,162 @@
/*=============================================================================
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2025 Nana Sakisaka
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#if !defined(BOOST_SPIRIT_STANDARD_WIDE_NOVEMBER_10_2006_0913AM)
#define BOOST_SPIRIT_STANDARD_WIDE_NOVEMBER_10_2006_0913AM
#if defined(_MSC_VER)
#pragma once
#endif
#include <cwctype>
#include <string>
#ifndef BOOST_SPIRIT_X3_CHAR_ENCODING_STANDARD_WIDE_HPP
#define BOOST_SPIRIT_X3_CHAR_ENCODING_STANDARD_WIDE_HPP
#include <boost/assert.hpp>
#include <boost/cstdint.hpp>
#include <boost/spirit/home/support/assert_msg.hpp>
#include <boost/type_traits/make_unsigned.hpp>
#include <string>
#include <type_traits>
namespace boost { namespace spirit { namespace traits
#include <cstdint>
#include <cwctype>
namespace boost::spirit::x3::char_encoding
{
template <std::size_t N>
struct wchar_t_size
{
BOOST_SPIRIT_ASSERT_MSG(N == 1 || N == 2 || N == 4,
not_supported_size_of_wchar_t, ());
};
template <> struct wchar_t_size<1> { enum { mask = 0xff }; };
template <> struct wchar_t_size<2> { enum { mask = 0xffff }; };
template <> struct wchar_t_size<4> { enum { mask = 0xffffffff }; };
}}}
namespace boost { namespace spirit { namespace char_encoding
{
///////////////////////////////////////////////////////////////////////////
// Test characters for specified conditions (using std wchar_t functions)
///////////////////////////////////////////////////////////////////////////
// Test characters for specified conditions (using std wchar_t functions)
struct standard_wide
{
typedef wchar_t char_type;
typedef wchar_t classify_type;
using char_type = wchar_t;
using classify_type = wchar_t;
template <typename Char>
static typename std::char_traits<Char>::int_type
to_int_type(Char ch)
[[nodiscard]] static constexpr typename std::char_traits<Char>::int_type
to_int_type(Char ch) noexcept
{
return std::char_traits<Char>::to_int_type(ch);
}
template <typename Char>
static Char
to_char_type(typename std::char_traits<Char>::int_type ch)
[[nodiscard]] static constexpr Char
to_char_type(typename std::char_traits<Char>::int_type ch) noexcept
{
return std::char_traits<Char>::to_char_type(ch);
}
static bool
ischar(int ch)
[[nodiscard]] static constexpr bool
ischar(int ch) noexcept
{
static_assert(
sizeof(wchar_t) == 1 || sizeof(wchar_t) == 2 || sizeof(wchar_t) == 4,
"Unsupported wchar_t size"
);
constexpr unsigned mask =
sizeof(wchar_t) == 4 ? 0xffffffffu :
sizeof(wchar_t) == 2 ? 0xffffu :
0xffu;
// we have to watch out for sign extensions (casting is there to
// silence certain compilers complaining about signed/unsigned
// mismatch)
return (
std::size_t(0) ==
std::size_t(ch & ~traits::wchar_t_size<sizeof(wchar_t)>::mask) ||
std::size_t(ch & ~mask) ||
std::size_t(~0) ==
std::size_t(ch | traits::wchar_t_size<sizeof(wchar_t)>::mask)
std::size_t(ch | mask)
) != 0; // any wchar_t, but no other bits set
}
static bool
isalnum(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
isalnum(wchar_t ch) noexcept
{
using namespace std;
return iswalnum(to_int_type(ch)) != 0;
return std::iswalnum(standard_wide::to_int_type(ch)) != 0;
}
static bool
isalpha(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
isalpha(wchar_t ch) noexcept
{
using namespace std;
return iswalpha(to_int_type(ch)) != 0;
return std::iswalpha(standard_wide::to_int_type(ch)) != 0;
}
static bool
iscntrl(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
iscntrl(wchar_t ch) noexcept
{
using namespace std;
return iswcntrl(to_int_type(ch)) != 0;
return std::iswcntrl(standard_wide::to_int_type(ch)) != 0;
}
static bool
isdigit(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
isdigit(wchar_t ch) noexcept
{
using namespace std;
return iswdigit(to_int_type(ch)) != 0;
return std::iswdigit(standard_wide::to_int_type(ch)) != 0;
}
static bool
isgraph(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
isgraph(wchar_t ch) noexcept
{
using namespace std;
return iswgraph(to_int_type(ch)) != 0;
return std::iswgraph(standard_wide::to_int_type(ch)) != 0;
}
static bool
islower(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
islower(wchar_t ch) noexcept
{
using namespace std;
return iswlower(to_int_type(ch)) != 0;
return std::iswlower(standard_wide::to_int_type(ch)) != 0;
}
static bool
isprint(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
isprint(wchar_t ch) noexcept
{
using namespace std;
return iswprint(to_int_type(ch)) != 0;
return std::iswprint(standard_wide::to_int_type(ch)) != 0;
}
static bool
ispunct(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
ispunct(wchar_t ch) noexcept
{
using namespace std;
return iswpunct(to_int_type(ch)) != 0;
return std::iswpunct(standard_wide::to_int_type(ch)) != 0;
}
static bool
isspace(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
isspace(wchar_t ch) noexcept
{
using namespace std;
return iswspace(to_int_type(ch)) != 0;
return std::iswspace(standard_wide::to_int_type(ch)) != 0;
}
static bool
isupper(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
isupper(wchar_t ch) noexcept
{
using namespace std;
return iswupper(to_int_type(ch)) != 0;
return std::iswupper(standard_wide::to_int_type(ch)) != 0;
}
static bool
isxdigit(wchar_t ch)
[[nodiscard]] static bool // TODO: constexpr
isxdigit(wchar_t ch) noexcept
{
using namespace std;
return iswxdigit(to_int_type(ch)) != 0;
return std::iswxdigit(standard_wide::to_int_type(ch)) != 0;
}
static bool
isblank BOOST_PREVENT_MACRO_SUBSTITUTION (wchar_t ch)
[[nodiscard]] static constexpr bool
(isblank)(wchar_t ch) noexcept
{
return (ch == L' ' || ch == L'\t');
}
///////////////////////////////////////////////////////////////////////
// Simple character conversions
///////////////////////////////////////////////////////////////////////
// Simple character conversions
static wchar_t
tolower(wchar_t ch)
[[nodiscard]] static wchar_t // TODO: constexpr
tolower(wchar_t ch) noexcept
{
using namespace std;
return isupper(ch) ?
to_char_type<wchar_t>(towlower(to_int_type(ch))) : ch;
return standard_wide::isupper(ch) ?
standard_wide::to_char_type<wchar_t>(std::towlower(standard_wide::to_int_type(ch))) : ch;
}
static wchar_t
toupper(wchar_t ch)
[[nodiscard]] static wchar_t // TODO: constexpr
toupper(wchar_t ch) noexcept
{
using namespace std;
return islower(ch) ?
to_char_type<wchar_t>(towupper(to_int_type(ch))) : ch;
return std::islower(ch) ?
standard_wide::to_char_type<wchar_t>(std::towupper(standard_wide::to_int_type(ch))) : ch;
}
static ::boost::uint32_t
toucs4(wchar_t ch)
[[nodiscard]] static constexpr std::uint32_t
toucs4(wchar_t ch) noexcept
{
return static_cast<make_unsigned<wchar_t>::type>(ch);
return static_cast<std::make_unsigned_t<wchar_t>>(ch);
}
};
}}}
} // boost::spirit::x3::char_encoding
#endif

658
include/boost/spirit/home/x3/char_encoding/unicode.hpp
View File

@@ -1,415 +1,435 @@
/*=============================================================================
Copyright (c) 2001-2011 Hartmut Kaiser
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2025 Nana Sakisaka
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#if !defined(BOOST_SPIRIT_UNICODE_1_JANUARY_12_2010_0728PM)
#define BOOST_SPIRIT_UNICODE_1_JANUARY_12_2010_0728PM
#ifndef BOOST_SPIRIT_X3_CHAR_ENCODING_UNICODE_HPP
#define BOOST_SPIRIT_X3_CHAR_ENCODING_UNICODE_HPP
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/spirit/home/x3/char_encoding/unicode/classification.hpp>
#include <boost/cstdint.hpp>
#include <boost/spirit/home/support/char_encoding/unicode/query.hpp>
#include <cstdint>
namespace boost { namespace spirit { namespace char_encoding
namespace boost::spirit::x3::char_encoding
{
///////////////////////////////////////////////////////////////////////////
// Test characters for specified conditions (using iso8859-1)
///////////////////////////////////////////////////////////////////////////
struct unicode
{
#ifdef BOOST_NO_CXX11_CHAR32_T
typedef ::boost::uint32_t char_type;
#else
typedef char32_t char_type;
#endif
typedef ::boost::uint32_t classify_type;
using char_type = char32_t;
using classify_type = std::uint32_t;
///////////////////////////////////////////////////////////////////////////
// Posix stuff
///////////////////////////////////////////////////////////////////////////
static bool
isascii_(char_type ch)
[[nodiscard]] static constexpr bool
isascii_(char_type ch) noexcept
{
return 0 == (ch & ~0x7f);
}
static bool
ischar(char_type ch)
[[nodiscard]] static constexpr bool
ischar(char_type ch) noexcept
{
// unicode code points in the range 0x00 to 0x10FFFF
return ch <= 0x10FFFF;
}
static bool
isalnum(char_type ch)
[[nodiscard]] static constexpr bool
isalnum(char_type ch) noexcept
{
return ucd::is_alphanumeric(ch);
return x3::unicode::is_alphanumeric(ch);
}
static bool
isalpha(char_type ch)
[[nodiscard]] static constexpr bool
isalpha(char_type ch) noexcept
{
return ucd::is_alphabetic(ch);
return x3::unicode::is_alphabetic(ch);
}
static bool
isdigit(char_type ch)
[[nodiscard]] static constexpr bool
isdigit(char_type ch) noexcept
{
return ucd::is_decimal_number(ch);
return x3::unicode::is_decimal_number(ch);
}
static bool
isxdigit(char_type ch)
[[nodiscard]] static constexpr bool
isxdigit(char_type ch) noexcept
{
return ucd::is_hex_digit(ch);
return x3::unicode::is_hex_digit(ch);
}
static bool
iscntrl(char_type ch)
[[nodiscard]] static constexpr bool
iscntrl(char_type ch) noexcept
{
return ucd::is_control(ch);
return x3::unicode::is_control(ch);
}
static bool
isgraph(char_type ch)
[[nodiscard]] static constexpr bool
isgraph(char_type ch) noexcept
{
return ucd::is_graph(ch);
return x3::unicode::is_graph(ch);
}
static bool
islower(char_type ch)
[[nodiscard]] static constexpr bool
islower(char_type ch) noexcept
{
return ucd::is_lowercase(ch);
return x3::unicode::is_lowercase(ch);
}
static bool
isprint(char_type ch)
[[nodiscard]] static constexpr bool
isprint(char_type ch) noexcept
{
return ucd::is_print(ch);
return x3::unicode::is_print(ch);
}
static bool
ispunct(char_type ch)
[[nodiscard]] static constexpr bool
ispunct(char_type ch) noexcept
{
return ucd::is_punctuation(ch);
return x3::unicode::is_punctuation(ch);
}
static bool
isspace(char_type ch)
[[nodiscard]] static constexpr bool
isspace(char_type ch) noexcept
{
return ucd::is_white_space(ch);
return x3::unicode::is_white_space(ch);
}
static bool
isblank BOOST_PREVENT_MACRO_SUBSTITUTION (char_type ch)
[[nodiscard]] static constexpr bool
(isblank)(char_type ch) noexcept
{
return ucd::is_blank(ch);
return x3::unicode::is_blank(ch);
}
static bool
isupper(char_type ch)
[[nodiscard]] static constexpr bool
isupper(char_type ch) noexcept
{
return ucd::is_uppercase(ch);
return x3::unicode::is_uppercase(ch);
}
///////////////////////////////////////////////////////////////////////////
// Simple character conversions
///////////////////////////////////////////////////////////////////////////
// Mixing character encodings is semantically wrong
static constexpr void isascii_(char) = delete;
static constexpr void isascii_(wchar_t) = delete;
static constexpr void ischar(char) = delete;
static constexpr void ischar(wchar_t) = delete;
static constexpr void isalnum(char) = delete;
static constexpr void isalnum(wchar_t) = delete;
static constexpr void isalpha(char) = delete;
static constexpr void isalpha(wchar_t) = delete;
static constexpr void isdigit(char) = delete;
static constexpr void isdigit(wchar_t) = delete;
static constexpr void isxdigit(char) = delete;
static constexpr void isxdigit(wchar_t) = delete;
static constexpr void iscntrl(char) = delete;
static constexpr void iscntrl(wchar_t) = delete;
static constexpr void isgraph(char) = delete;
static constexpr void isgraph(wchar_t) = delete;
static constexpr void islower(char) = delete;
static constexpr void islower(wchar_t) = delete;
static constexpr void isprint(char) = delete;
static constexpr void isprint(wchar_t) = delete;
static constexpr void ispunct(char) = delete;
static constexpr void ispunct(wchar_t) = delete;
static constexpr void isspace(char) = delete;
static constexpr void isspace(wchar_t) = delete;
static constexpr void isblank(char) = delete;
static constexpr void isblank(wchar_t) = delete;
static constexpr void isupper(char) = delete;
static constexpr void isupper(wchar_t) = delete;
static char_type
tolower(char_type ch)
// Simple character conversions
[[nodiscard]] static constexpr char_type
tolower(char_type ch) noexcept
{
return ucd::to_lowercase(ch);
return x3::unicode::to_lowercase(ch);
}
static char_type
toupper(char_type ch)
[[nodiscard]] static constexpr char_type
toupper(char_type ch) noexcept
{
return ucd::to_uppercase(ch);
return x3::unicode::to_uppercase(ch);
}
static ::boost::uint32_t
toucs4(char_type ch)
[[nodiscard]] static constexpr std::uint32_t
toucs4(char_type ch) noexcept
{
return ch;
}
///////////////////////////////////////////////////////////////////////////
// Major Categories
///////////////////////////////////////////////////////////////////////////
#define BOOST_SPIRIT_MAJOR_CATEGORY(name) \
static bool \
is_##name(char_type ch) \
static constexpr void tolower(char) = delete;
static constexpr void tolower(wchar_t) = delete;
static constexpr void toupper(char) = delete;
static constexpr void toupper(wchar_t) = delete;
static constexpr void toucs4(char) = delete;
static constexpr void toucs4(wchar_t) = delete;
// Major Categories
#define BOOST_SPIRIT_X3_MAJOR_CATEGORY(name) \
[[nodiscard]] static constexpr bool \
is_##name(char_type ch) noexcept \
{ \
return ucd::get_major_category(ch) == ucd::properties::name; \
return x3::unicode::get_major_category(ch) == x3::unicode::properties::name; \
} \
/***/
static constexpr void is_##name(char) = delete; \
static constexpr void is_##name(wchar_t) = delete;
BOOST_SPIRIT_MAJOR_CATEGORY(letter)
BOOST_SPIRIT_MAJOR_CATEGORY(mark)
BOOST_SPIRIT_MAJOR_CATEGORY(number)
BOOST_SPIRIT_MAJOR_CATEGORY(separator)
BOOST_SPIRIT_MAJOR_CATEGORY(other)
BOOST_SPIRIT_MAJOR_CATEGORY(punctuation)
BOOST_SPIRIT_MAJOR_CATEGORY(symbol)
BOOST_SPIRIT_X3_MAJOR_CATEGORY(letter)
BOOST_SPIRIT_X3_MAJOR_CATEGORY(mark)
BOOST_SPIRIT_X3_MAJOR_CATEGORY(number)
BOOST_SPIRIT_X3_MAJOR_CATEGORY(separator)
BOOST_SPIRIT_X3_MAJOR_CATEGORY(other)
BOOST_SPIRIT_X3_MAJOR_CATEGORY(punctuation)
BOOST_SPIRIT_X3_MAJOR_CATEGORY(symbol)
///////////////////////////////////////////////////////////////////////////
// General Categories
///////////////////////////////////////////////////////////////////////////
#define BOOST_SPIRIT_CATEGORY(name) \
static bool \
is_##name(char_type ch) \
#undef BOOST_SPIRIT_X3_MAJOR_CATEGORY
// General Categories
#define BOOST_SPIRIT_X3_CATEGORY(name) \
[[nodiscard]] static constexpr bool \
is_##name(char_type ch) noexcept \
{ \
return ucd::get_category(ch) == ucd::properties::name; \
return x3::unicode::get_category(ch) == x3::unicode::properties::name; \
} \
/***/
static constexpr void is_##name(char) = delete; \
static constexpr void is_##name(wchar_t) = delete;
BOOST_SPIRIT_CATEGORY(uppercase_letter)
BOOST_SPIRIT_CATEGORY(lowercase_letter)
BOOST_SPIRIT_CATEGORY(titlecase_letter)
BOOST_SPIRIT_CATEGORY(modifier_letter)
BOOST_SPIRIT_CATEGORY(other_letter)
BOOST_SPIRIT_X3_CATEGORY(uppercase_letter)
BOOST_SPIRIT_X3_CATEGORY(lowercase_letter)
BOOST_SPIRIT_X3_CATEGORY(titlecase_letter)
BOOST_SPIRIT_X3_CATEGORY(modifier_letter)
BOOST_SPIRIT_X3_CATEGORY(other_letter)
BOOST_SPIRIT_CATEGORY(nonspacing_mark)
BOOST_SPIRIT_CATEGORY(enclosing_mark)
BOOST_SPIRIT_CATEGORY(spacing_mark)
BOOST_SPIRIT_X3_CATEGORY(nonspacing_mark)
BOOST_SPIRIT_X3_CATEGORY(enclosing_mark)
BOOST_SPIRIT_X3_CATEGORY(spacing_mark)
BOOST_SPIRIT_CATEGORY(decimal_number)
BOOST_SPIRIT_CATEGORY(letter_number)
BOOST_SPIRIT_CATEGORY(other_number)
BOOST_SPIRIT_X3_CATEGORY(decimal_number)
BOOST_SPIRIT_X3_CATEGORY(letter_number)
BOOST_SPIRIT_X3_CATEGORY(other_number)
BOOST_SPIRIT_CATEGORY(space_separator)
BOOST_SPIRIT_CATEGORY(line_separator)
BOOST_SPIRIT_CATEGORY(paragraph_separator)
BOOST_SPIRIT_X3_CATEGORY(space_separator)
BOOST_SPIRIT_X3_CATEGORY(line_separator)
BOOST_SPIRIT_X3_CATEGORY(paragraph_separator)
BOOST_SPIRIT_CATEGORY(control)
BOOST_SPIRIT_CATEGORY(format)
BOOST_SPIRIT_CATEGORY(private_use)
BOOST_SPIRIT_CATEGORY(surrogate)
BOOST_SPIRIT_CATEGORY(unassigned)
BOOST_SPIRIT_X3_CATEGORY(control)
BOOST_SPIRIT_X3_CATEGORY(format)
BOOST_SPIRIT_X3_CATEGORY(private_use)
BOOST_SPIRIT_X3_CATEGORY(surrogate)
BOOST_SPIRIT_X3_CATEGORY(unassigned)
BOOST_SPIRIT_CATEGORY(dash_punctuation)
BOOST_SPIRIT_CATEGORY(open_punctuation)
BOOST_SPIRIT_CATEGORY(close_punctuation)
BOOST_SPIRIT_CATEGORY(connector_punctuation)
BOOST_SPIRIT_CATEGORY(other_punctuation)
BOOST_SPIRIT_CATEGORY(initial_punctuation)
BOOST_SPIRIT_CATEGORY(final_punctuation)
BOOST_SPIRIT_X3_CATEGORY(dash_punctuation)
BOOST_SPIRIT_X3_CATEGORY(open_punctuation)
BOOST_SPIRIT_X3_CATEGORY(close_punctuation)
BOOST_SPIRIT_X3_CATEGORY(connector_punctuation)
BOOST_SPIRIT_X3_CATEGORY(other_punctuation)
BOOST_SPIRIT_X3_CATEGORY(initial_punctuation)
BOOST_SPIRIT_X3_CATEGORY(final_punctuation)
BOOST_SPIRIT_CATEGORY(math_symbol)
BOOST_SPIRIT_CATEGORY(currency_symbol)
BOOST_SPIRIT_CATEGORY(modifier_symbol)
BOOST_SPIRIT_CATEGORY(other_symbol)
BOOST_SPIRIT_X3_CATEGORY(math_symbol)
BOOST_SPIRIT_X3_CATEGORY(currency_symbol)
BOOST_SPIRIT_X3_CATEGORY(modifier_symbol)
BOOST_SPIRIT_X3_CATEGORY(other_symbol)
///////////////////////////////////////////////////////////////////////////
// Derived Categories
///////////////////////////////////////////////////////////////////////////
#define BOOST_SPIRIT_DERIVED_CATEGORY(name) \
static bool \
is_##name(char_type ch) \
#undef BOOST_SPIRIT_X3_CATEGORY
// Derived Categories
#define BOOST_SPIRIT_X3_DERIVED_CATEGORY(name) \
[[nodiscard]] static constexpr bool \
is_##name(char_type ch) noexcept \
{ \
return ucd::is_##name(ch); \
return x3::unicode::is_##name(ch); \
} \
/***/
static constexpr void is_##name(char) = delete; \
static constexpr void is_##name(wchar_t) = delete;
BOOST_SPIRIT_DERIVED_CATEGORY(alphabetic)
BOOST_SPIRIT_DERIVED_CATEGORY(uppercase)
BOOST_SPIRIT_DERIVED_CATEGORY(lowercase)
BOOST_SPIRIT_DERIVED_CATEGORY(white_space)
BOOST_SPIRIT_DERIVED_CATEGORY(hex_digit)
BOOST_SPIRIT_DERIVED_CATEGORY(noncharacter_code_point)
BOOST_SPIRIT_DERIVED_CATEGORY(default_ignorable_code_point)
BOOST_SPIRIT_X3_DERIVED_CATEGORY(alphabetic)
BOOST_SPIRIT_X3_DERIVED_CATEGORY(uppercase)
BOOST_SPIRIT_X3_DERIVED_CATEGORY(lowercase)
BOOST_SPIRIT_X3_DERIVED_CATEGORY(white_space)
BOOST_SPIRIT_X3_DERIVED_CATEGORY(hex_digit)
BOOST_SPIRIT_X3_DERIVED_CATEGORY(noncharacter_code_point)
BOOST_SPIRIT_X3_DERIVED_CATEGORY(default_ignorable_code_point)
///////////////////////////////////////////////////////////////////////////
// Scripts
///////////////////////////////////////////////////////////////////////////
#define BOOST_SPIRIT_SCRIPT(name) \
static bool \
is_##name(char_type ch) \
#undef BOOST_SPIRIT_X3_DERIVED_CATEGORY
// Scripts
#define BOOST_SPIRIT_X3_SCRIPT(name) \
[[nodiscard]] static constexpr bool \
is_##name(char_type ch) noexcept \
{ \
return ucd::get_script(ch) == ucd::properties::name; \
return x3::unicode::get_script(ch) == x3::unicode::properties::name; \
} \
/***/
static constexpr void is_##name(char) = delete; \
static constexpr void is_##name(wchar_t) = delete;
BOOST_SPIRIT_SCRIPT(adlam)
BOOST_SPIRIT_SCRIPT(caucasian_albanian)
BOOST_SPIRIT_SCRIPT(ahom)
BOOST_SPIRIT_SCRIPT(arabic)
BOOST_SPIRIT_SCRIPT(imperial_aramaic)
BOOST_SPIRIT_SCRIPT(armenian)
BOOST_SPIRIT_SCRIPT(avestan)
BOOST_SPIRIT_SCRIPT(balinese)
BOOST_SPIRIT_SCRIPT(bamum)
BOOST_SPIRIT_SCRIPT(bassa_vah)
BOOST_SPIRIT_SCRIPT(batak)
BOOST_SPIRIT_SCRIPT(bengali)
BOOST_SPIRIT_SCRIPT(bhaiksuki)
BOOST_SPIRIT_SCRIPT(bopomofo)
BOOST_SPIRIT_SCRIPT(brahmi)
BOOST_SPIRIT_SCRIPT(braille)
BOOST_SPIRIT_SCRIPT(buginese)
BOOST_SPIRIT_SCRIPT(buhid)
BOOST_SPIRIT_SCRIPT(chakma)
BOOST_SPIRIT_SCRIPT(canadian_aboriginal)
BOOST_SPIRIT_SCRIPT(carian)
BOOST_SPIRIT_SCRIPT(cham)
BOOST_SPIRIT_SCRIPT(cherokee)
BOOST_SPIRIT_SCRIPT(chorasmian)
BOOST_SPIRIT_SCRIPT(coptic)
BOOST_SPIRIT_SCRIPT(cypro_minoan)
BOOST_SPIRIT_SCRIPT(cypriot)
BOOST_SPIRIT_SCRIPT(cyrillic)
BOOST_SPIRIT_SCRIPT(devanagari)
BOOST_SPIRIT_SCRIPT(dives_akuru)
BOOST_SPIRIT_SCRIPT(dogra)
BOOST_SPIRIT_SCRIPT(deseret)
BOOST_SPIRIT_SCRIPT(duployan)
BOOST_SPIRIT_SCRIPT(egyptian_hieroglyphs)
BOOST_SPIRIT_SCRIPT(elbasan)
BOOST_SPIRIT_SCRIPT(elymaic)
BOOST_SPIRIT_SCRIPT(ethiopic)
BOOST_SPIRIT_SCRIPT(georgian)
BOOST_SPIRIT_SCRIPT(glagolitic)
BOOST_SPIRIT_SCRIPT(gunjala_gondi)
BOOST_SPIRIT_SCRIPT(masaram_gondi)
BOOST_SPIRIT_SCRIPT(gothic)
BOOST_SPIRIT_SCRIPT(grantha)
BOOST_SPIRIT_SCRIPT(greek)
BOOST_SPIRIT_SCRIPT(gujarati)
BOOST_SPIRIT_SCRIPT(gurmukhi)
BOOST_SPIRIT_SCRIPT(hangul)
BOOST_SPIRIT_SCRIPT(han)
BOOST_SPIRIT_SCRIPT(hanunoo)
BOOST_SPIRIT_SCRIPT(hatran)
BOOST_SPIRIT_SCRIPT(hebrew)
BOOST_SPIRIT_SCRIPT(hiragana)
BOOST_SPIRIT_SCRIPT(anatolian_hieroglyphs)
BOOST_SPIRIT_SCRIPT(pahawh_hmong)
BOOST_SPIRIT_SCRIPT(nyiakeng_puachue_hmong)
BOOST_SPIRIT_SCRIPT(katakana_or_hiragana)
BOOST_SPIRIT_SCRIPT(old_hungarian)
BOOST_SPIRIT_SCRIPT(old_italic)
BOOST_SPIRIT_SCRIPT(javanese)
BOOST_SPIRIT_SCRIPT(kayah_li)
BOOST_SPIRIT_SCRIPT(katakana)
BOOST_SPIRIT_SCRIPT(kawi)
BOOST_SPIRIT_SCRIPT(kharoshthi)
BOOST_SPIRIT_SCRIPT(khmer)
BOOST_SPIRIT_SCRIPT(khojki)
BOOST_SPIRIT_SCRIPT(khitan_small_script)
BOOST_SPIRIT_SCRIPT(kannada)
BOOST_SPIRIT_SCRIPT(kaithi)
BOOST_SPIRIT_SCRIPT(tai_tham)
BOOST_SPIRIT_SCRIPT(lao)
BOOST_SPIRIT_SCRIPT(latin)
BOOST_SPIRIT_SCRIPT(lepcha)
BOOST_SPIRIT_SCRIPT(limbu)
BOOST_SPIRIT_SCRIPT(linear_a)
BOOST_SPIRIT_SCRIPT(linear_b)
BOOST_SPIRIT_SCRIPT(lisu)
BOOST_SPIRIT_SCRIPT(lycian)
BOOST_SPIRIT_SCRIPT(lydian)
BOOST_SPIRIT_SCRIPT(mahajani)
BOOST_SPIRIT_SCRIPT(makasar)
BOOST_SPIRIT_SCRIPT(mandaic)
BOOST_SPIRIT_SCRIPT(manichaean)
BOOST_SPIRIT_SCRIPT(marchen)
BOOST_SPIRIT_SCRIPT(medefaidrin)
BOOST_SPIRIT_SCRIPT(mende_kikakui)
BOOST_SPIRIT_SCRIPT(meroitic_cursive)
BOOST_SPIRIT_SCRIPT(meroitic_hieroglyphs)
BOOST_SPIRIT_SCRIPT(malayalam)
BOOST_SPIRIT_SCRIPT(modi)
BOOST_SPIRIT_SCRIPT(mongolian)
BOOST_SPIRIT_SCRIPT(mro)
BOOST_SPIRIT_SCRIPT(meetei_mayek)
BOOST_SPIRIT_SCRIPT(multani)
BOOST_SPIRIT_SCRIPT(myanmar)
BOOST_SPIRIT_SCRIPT(nag_mundari)
BOOST_SPIRIT_SCRIPT(nandinagari)
BOOST_SPIRIT_SCRIPT(old_north_arabian)
BOOST_SPIRIT_SCRIPT(nabataean)
BOOST_SPIRIT_SCRIPT(newa)
BOOST_SPIRIT_SCRIPT(nko)
BOOST_SPIRIT_SCRIPT(nushu)
BOOST_SPIRIT_SCRIPT(ogham)
BOOST_SPIRIT_SCRIPT(ol_chiki)
BOOST_SPIRIT_SCRIPT(old_turkic)
BOOST_SPIRIT_SCRIPT(oriya)
BOOST_SPIRIT_SCRIPT(osage)
BOOST_SPIRIT_SCRIPT(osmanya)
BOOST_SPIRIT_SCRIPT(old_uyghur)
BOOST_SPIRIT_SCRIPT(palmyrene)
BOOST_SPIRIT_SCRIPT(pau_cin_hau)
BOOST_SPIRIT_SCRIPT(old_permic)
BOOST_SPIRIT_SCRIPT(phags_pa)
BOOST_SPIRIT_SCRIPT(inscriptional_pahlavi)
BOOST_SPIRIT_SCRIPT(psalter_pahlavi)
BOOST_SPIRIT_SCRIPT(phoenician)
BOOST_SPIRIT_SCRIPT(miao)
BOOST_SPIRIT_SCRIPT(inscriptional_parthian)
BOOST_SPIRIT_SCRIPT(rejang)
BOOST_SPIRIT_SCRIPT(hanifi_rohingya)
BOOST_SPIRIT_SCRIPT(runic)
BOOST_SPIRIT_SCRIPT(samaritan)
BOOST_SPIRIT_SCRIPT(old_south_arabian)
BOOST_SPIRIT_SCRIPT(saurashtra)
BOOST_SPIRIT_SCRIPT(signwriting)
BOOST_SPIRIT_SCRIPT(shavian)
BOOST_SPIRIT_SCRIPT(sharada)
BOOST_SPIRIT_SCRIPT(siddham)
BOOST_SPIRIT_SCRIPT(khudawadi)
BOOST_SPIRIT_SCRIPT(sinhala)
BOOST_SPIRIT_SCRIPT(sogdian)
BOOST_SPIRIT_SCRIPT(old_sogdian)
BOOST_SPIRIT_SCRIPT(sora_sompeng)
BOOST_SPIRIT_SCRIPT(soyombo)
BOOST_SPIRIT_SCRIPT(sundanese)
BOOST_SPIRIT_SCRIPT(syloti_nagri)
BOOST_SPIRIT_SCRIPT(syriac)
BOOST_SPIRIT_SCRIPT(tagbanwa)
BOOST_SPIRIT_SCRIPT(takri)
BOOST_SPIRIT_SCRIPT(tai_le)
BOOST_SPIRIT_SCRIPT(new_tai_lue)
BOOST_SPIRIT_SCRIPT(tamil)
BOOST_SPIRIT_SCRIPT(tangut)
BOOST_SPIRIT_SCRIPT(tai_viet)
BOOST_SPIRIT_SCRIPT(telugu)
BOOST_SPIRIT_SCRIPT(tifinagh)
BOOST_SPIRIT_SCRIPT(tagalog)
BOOST_SPIRIT_SCRIPT(thaana)
BOOST_SPIRIT_SCRIPT(thai)
BOOST_SPIRIT_SCRIPT(tibetan)
BOOST_SPIRIT_SCRIPT(tirhuta)
BOOST_SPIRIT_SCRIPT(tangsa)
BOOST_SPIRIT_SCRIPT(toto)
BOOST_SPIRIT_SCRIPT(ugaritic)
BOOST_SPIRIT_SCRIPT(vai)
BOOST_SPIRIT_SCRIPT(vithkuqi)
BOOST_SPIRIT_SCRIPT(warang_citi)
BOOST_SPIRIT_SCRIPT(wancho)
BOOST_SPIRIT_SCRIPT(old_persian)
BOOST_SPIRIT_SCRIPT(cuneiform)
BOOST_SPIRIT_SCRIPT(yezidi)
BOOST_SPIRIT_SCRIPT(yi)
BOOST_SPIRIT_SCRIPT(zanabazar_square)
BOOST_SPIRIT_SCRIPT(inherited)
BOOST_SPIRIT_SCRIPT(common)
BOOST_SPIRIT_SCRIPT(unknown)
#undef BOOST_SPIRIT_MAJOR_CATEGORY
#undef BOOST_SPIRIT_CATEGORY
#undef BOOST_SPIRIT_DERIVED_CATEGORY
#undef BOOST_SPIRIT_SCRIPT
BOOST_SPIRIT_X3_SCRIPT(adlam)
BOOST_SPIRIT_X3_SCRIPT(caucasian_albanian)
BOOST_SPIRIT_X3_SCRIPT(ahom)
BOOST_SPIRIT_X3_SCRIPT(arabic)
BOOST_SPIRIT_X3_SCRIPT(imperial_aramaic)
BOOST_SPIRIT_X3_SCRIPT(armenian)
BOOST_SPIRIT_X3_SCRIPT(avestan)
BOOST_SPIRIT_X3_SCRIPT(balinese)
BOOST_SPIRIT_X3_SCRIPT(bamum)
BOOST_SPIRIT_X3_SCRIPT(bassa_vah)
BOOST_SPIRIT_X3_SCRIPT(batak)
BOOST_SPIRIT_X3_SCRIPT(bengali)
BOOST_SPIRIT_X3_SCRIPT(bhaiksuki)
BOOST_SPIRIT_X3_SCRIPT(bopomofo)
BOOST_SPIRIT_X3_SCRIPT(brahmi)
BOOST_SPIRIT_X3_SCRIPT(braille)
BOOST_SPIRIT_X3_SCRIPT(buginese)
BOOST_SPIRIT_X3_SCRIPT(buhid)
BOOST_SPIRIT_X3_SCRIPT(chakma)
BOOST_SPIRIT_X3_SCRIPT(canadian_aboriginal)
BOOST_SPIRIT_X3_SCRIPT(carian)
BOOST_SPIRIT_X3_SCRIPT(cham)
BOOST_SPIRIT_X3_SCRIPT(cherokee)
BOOST_SPIRIT_X3_SCRIPT(chorasmian)
BOOST_SPIRIT_X3_SCRIPT(coptic)
BOOST_SPIRIT_X3_SCRIPT(cypro_minoan)
BOOST_SPIRIT_X3_SCRIPT(cypriot)
BOOST_SPIRIT_X3_SCRIPT(cyrillic)
BOOST_SPIRIT_X3_SCRIPT(devanagari)
BOOST_SPIRIT_X3_SCRIPT(dives_akuru)
BOOST_SPIRIT_X3_SCRIPT(dogra)
BOOST_SPIRIT_X3_SCRIPT(deseret)
BOOST_SPIRIT_X3_SCRIPT(duployan)
BOOST_SPIRIT_X3_SCRIPT(egyptian_hieroglyphs)
BOOST_SPIRIT_X3_SCRIPT(elbasan)
BOOST_SPIRIT_X3_SCRIPT(elymaic)
BOOST_SPIRIT_X3_SCRIPT(ethiopic)
BOOST_SPIRIT_X3_SCRIPT(georgian)
BOOST_SPIRIT_X3_SCRIPT(glagolitic)
BOOST_SPIRIT_X3_SCRIPT(gunjala_gondi)
BOOST_SPIRIT_X3_SCRIPT(masaram_gondi)
BOOST_SPIRIT_X3_SCRIPT(gothic)
BOOST_SPIRIT_X3_SCRIPT(grantha)
BOOST_SPIRIT_X3_SCRIPT(greek)
BOOST_SPIRIT_X3_SCRIPT(gujarati)
BOOST_SPIRIT_X3_SCRIPT(gurmukhi)
BOOST_SPIRIT_X3_SCRIPT(hangul)
BOOST_SPIRIT_X3_SCRIPT(han)
BOOST_SPIRIT_X3_SCRIPT(hanunoo)
BOOST_SPIRIT_X3_SCRIPT(hatran)
BOOST_SPIRIT_X3_SCRIPT(hebrew)
BOOST_SPIRIT_X3_SCRIPT(hiragana)
BOOST_SPIRIT_X3_SCRIPT(anatolian_hieroglyphs)
BOOST_SPIRIT_X3_SCRIPT(pahawh_hmong)
BOOST_SPIRIT_X3_SCRIPT(nyiakeng_puachue_hmong)
BOOST_SPIRIT_X3_SCRIPT(katakana_or_hiragana)
BOOST_SPIRIT_X3_SCRIPT(old_hungarian)
BOOST_SPIRIT_X3_SCRIPT(old_italic)
BOOST_SPIRIT_X3_SCRIPT(javanese)
BOOST_SPIRIT_X3_SCRIPT(kayah_li)
BOOST_SPIRIT_X3_SCRIPT(katakana)
BOOST_SPIRIT_X3_SCRIPT(kawi)
BOOST_SPIRIT_X3_SCRIPT(kharoshthi)
BOOST_SPIRIT_X3_SCRIPT(khmer)
BOOST_SPIRIT_X3_SCRIPT(khojki)
BOOST_SPIRIT_X3_SCRIPT(khitan_small_script)
BOOST_SPIRIT_X3_SCRIPT(kannada)
BOOST_SPIRIT_X3_SCRIPT(kaithi)
BOOST_SPIRIT_X3_SCRIPT(tai_tham)
BOOST_SPIRIT_X3_SCRIPT(lao)
BOOST_SPIRIT_X3_SCRIPT(latin)
BOOST_SPIRIT_X3_SCRIPT(lepcha)
BOOST_SPIRIT_X3_SCRIPT(limbu)
BOOST_SPIRIT_X3_SCRIPT(linear_a)
BOOST_SPIRIT_X3_SCRIPT(linear_b)
BOOST_SPIRIT_X3_SCRIPT(lisu)
BOOST_SPIRIT_X3_SCRIPT(lycian)
BOOST_SPIRIT_X3_SCRIPT(lydian)
BOOST_SPIRIT_X3_SCRIPT(mahajani)
BOOST_SPIRIT_X3_SCRIPT(makasar)
BOOST_SPIRIT_X3_SCRIPT(mandaic)
BOOST_SPIRIT_X3_SCRIPT(manichaean)
BOOST_SPIRIT_X3_SCRIPT(marchen)
BOOST_SPIRIT_X3_SCRIPT(medefaidrin)
BOOST_SPIRIT_X3_SCRIPT(mende_kikakui)
BOOST_SPIRIT_X3_SCRIPT(meroitic_cursive)
BOOST_SPIRIT_X3_SCRIPT(meroitic_hieroglyphs)
BOOST_SPIRIT_X3_SCRIPT(malayalam)
BOOST_SPIRIT_X3_SCRIPT(modi)
BOOST_SPIRIT_X3_SCRIPT(mongolian)
BOOST_SPIRIT_X3_SCRIPT(mro)
BOOST_SPIRIT_X3_SCRIPT(meetei_mayek)
BOOST_SPIRIT_X3_SCRIPT(multani)
BOOST_SPIRIT_X3_SCRIPT(myanmar)
BOOST_SPIRIT_X3_SCRIPT(nag_mundari)
BOOST_SPIRIT_X3_SCRIPT(nandinagari)
BOOST_SPIRIT_X3_SCRIPT(old_north_arabian)
BOOST_SPIRIT_X3_SCRIPT(nabataean)
BOOST_SPIRIT_X3_SCRIPT(newa)
BOOST_SPIRIT_X3_SCRIPT(nko)
BOOST_SPIRIT_X3_SCRIPT(nushu)
BOOST_SPIRIT_X3_SCRIPT(ogham)
BOOST_SPIRIT_X3_SCRIPT(ol_chiki)
BOOST_SPIRIT_X3_SCRIPT(old_turkic)
BOOST_SPIRIT_X3_SCRIPT(oriya)
BOOST_SPIRIT_X3_SCRIPT(osage)
BOOST_SPIRIT_X3_SCRIPT(osmanya)
BOOST_SPIRIT_X3_SCRIPT(old_uyghur)
BOOST_SPIRIT_X3_SCRIPT(palmyrene)
BOOST_SPIRIT_X3_SCRIPT(pau_cin_hau)
BOOST_SPIRIT_X3_SCRIPT(old_permic)
BOOST_SPIRIT_X3_SCRIPT(phags_pa)
BOOST_SPIRIT_X3_SCRIPT(inscriptional_pahlavi)
BOOST_SPIRIT_X3_SCRIPT(psalter_pahlavi)
BOOST_SPIRIT_X3_SCRIPT(phoenician)
BOOST_SPIRIT_X3_SCRIPT(miao)
BOOST_SPIRIT_X3_SCRIPT(inscriptional_parthian)
BOOST_SPIRIT_X3_SCRIPT(rejang)
BOOST_SPIRIT_X3_SCRIPT(hanifi_rohingya)
BOOST_SPIRIT_X3_SCRIPT(runic)
BOOST_SPIRIT_X3_SCRIPT(samaritan)
BOOST_SPIRIT_X3_SCRIPT(old_south_arabian)
BOOST_SPIRIT_X3_SCRIPT(saurashtra)
BOOST_SPIRIT_X3_SCRIPT(signwriting)
BOOST_SPIRIT_X3_SCRIPT(shavian)
BOOST_SPIRIT_X3_SCRIPT(sharada)
BOOST_SPIRIT_X3_SCRIPT(siddham)
BOOST_SPIRIT_X3_SCRIPT(khudawadi)
BOOST_SPIRIT_X3_SCRIPT(sinhala)
BOOST_SPIRIT_X3_SCRIPT(sogdian)
BOOST_SPIRIT_X3_SCRIPT(old_sogdian)
BOOST_SPIRIT_X3_SCRIPT(sora_sompeng)
BOOST_SPIRIT_X3_SCRIPT(soyombo)
BOOST_SPIRIT_X3_SCRIPT(sundanese)
BOOST_SPIRIT_X3_SCRIPT(syloti_nagri)
BOOST_SPIRIT_X3_SCRIPT(syriac)
BOOST_SPIRIT_X3_SCRIPT(tagbanwa)
BOOST_SPIRIT_X3_SCRIPT(takri)
BOOST_SPIRIT_X3_SCRIPT(tai_le)
BOOST_SPIRIT_X3_SCRIPT(new_tai_lue)
BOOST_SPIRIT_X3_SCRIPT(tamil)
BOOST_SPIRIT_X3_SCRIPT(tangut)
BOOST_SPIRIT_X3_SCRIPT(tai_viet)
BOOST_SPIRIT_X3_SCRIPT(telugu)
BOOST_SPIRIT_X3_SCRIPT(tifinagh)
BOOST_SPIRIT_X3_SCRIPT(tagalog)
BOOST_SPIRIT_X3_SCRIPT(thaana)
BOOST_SPIRIT_X3_SCRIPT(thai)
BOOST_SPIRIT_X3_SCRIPT(tibetan)
BOOST_SPIRIT_X3_SCRIPT(tirhuta)
BOOST_SPIRIT_X3_SCRIPT(tangsa)
BOOST_SPIRIT_X3_SCRIPT(toto)
BOOST_SPIRIT_X3_SCRIPT(ugaritic)
BOOST_SPIRIT_X3_SCRIPT(vai)
BOOST_SPIRIT_X3_SCRIPT(vithkuqi)
BOOST_SPIRIT_X3_SCRIPT(warang_citi)
BOOST_SPIRIT_X3_SCRIPT(wancho)
BOOST_SPIRIT_X3_SCRIPT(old_persian)
BOOST_SPIRIT_X3_SCRIPT(cuneiform)
BOOST_SPIRIT_X3_SCRIPT(yezidi)
BOOST_SPIRIT_X3_SCRIPT(yi)
BOOST_SPIRIT_X3_SCRIPT(zanabazar_square)
BOOST_SPIRIT_X3_SCRIPT(inherited)
BOOST_SPIRIT_X3_SCRIPT(common)
BOOST_SPIRIT_X3_SCRIPT(unknown)
#undef BOOST_SPIRIT_X3_SCRIPT
};
}}}
} // boost::spirit::x3::char_encoding
#endif

91
include/boost/spirit/home/x3/char_encoding/unicode/query.hpp → include/boost/spirit/home/x3/char_encoding/unicode/classification.hpp
View File

@@ -1,5 +1,6 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2025 Nana Sakisaka
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -7,22 +8,22 @@
Autogenerated by MultiStageTable.py (Unicode multi-stage
table builder) (c) Peter Kankowski, 2008
==============================================================================*/
#if !defined(BOOST_SPIRIT_UNICODE_QUERY_FEBRUARY_2_2010)
#define BOOST_SPIRIT_UNICODE_QUERY_FEBRUARY_2_2010
#ifndef BOOST_SPIRIT_X3_CHAR_ENCODING_UNICODE_CLASSIFICATION_HPP
#define BOOST_SPIRIT_X3_CHAR_ENCODING_UNICODE_CLASSIFICATION_HPP
#include <boost/cstdint.hpp>
#include <boost/spirit/home/x3/char_encoding/unicode/detail/category_table.hpp>
#include <boost/spirit/home/x3/char_encoding/unicode/detail/script_table.hpp>
#include <boost/spirit/home/x3/char_encoding/unicode/detail/lowercase_table.hpp>
#include <boost/spirit/home/x3/char_encoding/unicode/detail/uppercase_table.hpp>
# include "category_table.hpp"
# include "script_table.hpp"
# include "lowercase_table.hpp"
# include "uppercase_table.hpp"
#include <cstdint>
namespace boost { namespace spirit { namespace ucd
namespace boost::spirit::x3::unicode
{
// This header provides Basic (Level 1) Unicode Support
// See http://unicode.org/reports/tr18/ for details
struct properties
namespace properties
{
// bit pattern: xxMMMCCC
// MMM: major_category
@@ -258,119 +259,119 @@ namespace boost { namespace spirit { namespace ucd
common,
unknown
};
};
} // properties
inline properties::category get_category(::boost::uint32_t ch)
[[nodiscard]] constexpr properties::category get_category(std::uint32_t ch) noexcept
{
return static_cast<properties::category>(detail::category_lookup(ch) & 0x3F);
}
inline properties::major_category get_major_category(::boost::uint32_t ch)
[[nodiscard]] constexpr properties::major_category get_major_category(std::uint32_t ch) noexcept
{
return static_cast<properties::major_category>(get_category(ch) >> 3);
return static_cast<properties::major_category>(unicode::get_category(ch) >> 3);
}
inline bool is_punctuation(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_punctuation(std::uint32_t ch) noexcept
{
return get_major_category(ch) == properties::punctuation;
return unicode::get_major_category(ch) == properties::punctuation;
}
inline bool is_decimal_number(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_decimal_number(std::uint32_t ch) noexcept
{
return get_category(ch) == properties::decimal_number;
return unicode::get_category(ch) == properties::decimal_number;
}
inline bool is_hex_digit(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_hex_digit(std::uint32_t ch) noexcept
{
return (detail::category_lookup(ch) & properties::hex_digit) != 0;
}
inline bool is_control(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_control(std::uint32_t ch) noexcept
{
return get_category(ch) == properties::control;
return unicode::get_category(ch) == properties::control;
}
inline bool is_alphabetic(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_alphabetic(std::uint32_t ch) noexcept
{
return (detail::category_lookup(ch) & properties::alphabetic) != 0;
}
inline bool is_alphanumeric(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_alphanumeric(std::uint32_t ch) noexcept
{
return is_decimal_number(ch) || is_alphabetic(ch);
return unicode::is_decimal_number(ch) || unicode::is_alphabetic(ch);
}
inline bool is_uppercase(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_uppercase(std::uint32_t ch) noexcept
{
return (detail::category_lookup(ch) & properties::uppercase) != 0;
}
inline bool is_lowercase(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_lowercase(std::uint32_t ch) noexcept
{
return (detail::category_lookup(ch) & properties::lowercase) != 0;
}
inline bool is_white_space(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_white_space(std::uint32_t ch) noexcept
{
return (detail::category_lookup(ch) & properties::white_space) != 0;
}
inline bool is_blank(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_blank(std::uint32_t ch) noexcept
{
switch (ch)
{
case '\n': case '\v': case '\f': case '\r':
return false;
default:
return is_white_space(ch)
&& !( get_category(ch) == properties::line_separator
|| get_category(ch) == properties::paragraph_separator
return unicode::is_white_space(ch)
&& !( unicode::get_category(ch) == properties::line_separator
|| unicode::get_category(ch) == properties::paragraph_separator
);
}
}
inline bool is_graph(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_graph(std::uint32_t ch) noexcept
{
return !( is_white_space(ch)
|| get_category(ch) == properties::control
|| get_category(ch) == properties::surrogate
|| get_category(ch) == properties::unassigned
return !( unicode::is_white_space(ch)
|| unicode::get_category(ch) == properties::control
|| unicode::get_category(ch) == properties::surrogate
|| unicode::get_category(ch) == properties::unassigned
);
}
inline bool is_print(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_print(std::uint32_t ch) noexcept
{
return (is_graph(ch) || is_blank(ch)) && !is_control(ch);
return (unicode::is_graph(ch) || unicode::is_blank(ch)) && !unicode::is_control(ch);
}
inline bool is_noncharacter_code_point(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_noncharacter_code_point(std::uint32_t ch) noexcept
{
return (detail::category_lookup(ch) & properties::noncharacter_code_point) != 0;
}
inline bool is_default_ignorable_code_point(::boost::uint32_t ch)
[[nodiscard]] constexpr bool is_default_ignorable_code_point(std::uint32_t ch) noexcept
{
return (detail::category_lookup(ch) & properties::default_ignorable_code_point) != 0;
}
inline properties::script get_script(::boost::uint32_t ch)
[[nodiscard]] constexpr properties::script get_script(std::uint32_t ch) noexcept
{
return static_cast<properties::script>(detail::script_lookup(ch));
}
inline ::boost::uint32_t to_lowercase(::boost::uint32_t ch)
[[nodiscard]] constexpr std::uint32_t to_lowercase(std::uint32_t ch) noexcept
{
// The table returns 0 to signal that this code maps to itself
::boost::uint32_t r = detail::lowercase_lookup(ch);
std::uint32_t r = detail::lowercase_lookup(ch);
return (r == 0)? ch : r;
}
inline ::boost::uint32_t to_uppercase(::boost::uint32_t ch)
[[nodiscard]] constexpr std::uint32_t to_uppercase(std::uint32_t ch) noexcept
{
// The table returns 0 to signal that this code maps to itself
::boost::uint32_t r = detail::uppercase_lookup(ch);
std::uint32_t r = detail::uppercase_lookup(ch);
return (r == 0)? ch : r;
}
}}}
} // boost::spirit::x3::unicode
#endif

5643
include/boost/spirit/home/x3/char_encoding/unicode/category_table.hpp → include/boost/spirit/home/x3/char_encoding/unicode/detail/category_table.hpp
View File

File diff suppressed because it is too large Load Diff

1323
include/boost/spirit/home/x3/char_encoding/unicode/lowercase_table.hpp → include/boost/spirit/home/x3/char_encoding/unicode/detail/lowercase_table.hpp
View File

File diff suppressed because it is too large Load Diff

5643
include/boost/spirit/home/x3/char_encoding/unicode/script_table.hpp → include/boost/spirit/home/x3/char_encoding/unicode/detail/script_table.hpp
View File

File diff suppressed because it is too large Load Diff

1419
include/boost/spirit/home/x3/char_encoding/unicode/uppercase_table.hpp → include/boost/spirit/home/x3/char_encoding/unicode/detail/uppercase_table.hpp
View File

File diff suppressed because it is too large Load Diff