1 /* 2 * ***************************************************************************** 3 * 4 * SPDX-License-Identifier: BSD-2-Clause 5 * 6 * Copyright (c) 2018-2021 Gavin D. Howard and contributors. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 11 * * Redistributions of source code must retain the above copyright notice, this 12 * list of conditions and the following disclaimer. 13 * 14 * * Redistributions in binary form must reproduce the above copyright notice, 15 * this list of conditions and the following disclaimer in the documentation 16 * and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 * 30 * ***************************************************************************** 31 * 32 * Constant data for bc. 33 * 34 */ 35 36 #include <assert.h> 37 38 #include <opt.h> 39 #include <args.h> 40 #include <lex.h> 41 #include <parse.h> 42 #include <bc.h> 43 #include <dc.h> 44 #include <num.h> 45 #include <rand.h> 46 #include <program.h> 47 #include <history.h> 48 #include <library.h> 49 #include <vm.h> 50 51 #if !BC_ENABLE_LIBRARY 52 53 #if BC_ENABLED 54 55 /// The bc signal message and its length. 56 const char bc_sig_msg[] = "\ninterrupt (type \"quit\" to exit)\n"; 57 const uchar bc_sig_msg_len = (uchar) (sizeof(bc_sig_msg) - 1); 58 59 #endif // BC_ENABLED 60 61 #if DC_ENABLED 62 63 /// The dc signal message and its length. 64 const char dc_sig_msg[] = "\ninterrupt (type \"q\" to exit)\n"; 65 const uchar dc_sig_msg_len = (uchar) (sizeof(dc_sig_msg) - 1); 66 67 #endif // DC_ENABLED 68 69 // clang-format off 70 71 /// The copyright banner. 72 const char bc_copyright[] = 73 "Copyright (c) 2018-2022 Gavin D. Howard and contributors\n" 74 "Report bugs at: https://git.yzena.com/gavin/bc\n\n" 75 "This is free software with ABSOLUTELY NO WARRANTY.\n"; 76 77 // clang-format on 78 79 #ifdef __OpenBSD__ 80 81 #if BC_ENABLE_EXTRA_MATH 82 83 #if BC_ENABLE_HISTORY 84 85 /// The pledges for starting bc. 86 const char bc_pledge_start[] = "rpath stdio tty unveil"; 87 88 /// The final pledges with history enabled. 89 const char bc_pledge_end_history[] = "rpath stdio tty"; 90 91 #else // BC_ENABLE_HISTORY 92 93 /// The pledges for starting bc. 94 const char bc_pledge_start[] = "rpath stdio unveil"; 95 96 #endif // BC_ENABLE_HISTORY 97 98 /// The final pledges with history history disabled. 99 const char bc_pledge_end[] = "rpath stdio"; 100 101 #else // BC_ENABLE_EXTRA_MATH 102 103 #if BC_ENABLE_HISTORY 104 105 /// The pledges for starting bc. 106 const char bc_pledge_start[] = "rpath stdio tty"; 107 108 /// The final pledges with history enabled. 109 const char bc_pledge_end_history[] = "stdio tty"; 110 111 #else // BC_ENABLE_HISTORY 112 113 /// The pledges for starting bc. 114 const char bc_pledge_start[] = "rpath stdio"; 115 116 #endif // BC_ENABLE_HISTORY 117 118 /// The final pledges with history history disabled. 119 const char bc_pledge_end[] = "stdio"; 120 121 #endif // BC_ENABLE_EXTRA_MATH 122 123 #else // __OpenBSD__ 124 125 /// The pledges for starting bc. 126 const char bc_pledge_start[] = ""; 127 128 #if BC_ENABLE_HISTORY 129 130 /// The final pledges with history enabled. 131 const char bc_pledge_end_history[] = ""; 132 133 #endif // BC_ENABLE_HISTORY 134 135 /// The final pledges with history history disabled. 136 const char bc_pledge_end[] = ""; 137 138 #endif // __OpenBSD__ 139 140 /// The list of long options. There is a zero set at the end for detecting the 141 /// end. 142 const BcOptLong bc_args_lopt[] = { 143 144 { "expression", BC_OPT_REQUIRED, 'e' }, 145 { "file", BC_OPT_REQUIRED, 'f' }, 146 { "help", BC_OPT_NONE, 'h' }, 147 { "interactive", BC_OPT_NONE, 'i' }, 148 { "ibase", BC_OPT_REQUIRED, 'I' }, 149 { "leading-zeroes", BC_OPT_NONE, 'z' }, 150 { "no-line-length", BC_OPT_NONE, 'L' }, 151 { "obase", BC_OPT_REQUIRED, 'O' }, 152 { "no-prompt", BC_OPT_NONE, 'P' }, 153 { "no-read-prompt", BC_OPT_NONE, 'R' }, 154 { "scale", BC_OPT_REQUIRED, 'S' }, 155 #if BC_ENABLE_EXTRA_MATH 156 { "seed", BC_OPT_REQUIRED, 'E' }, 157 #endif // BC_ENABLE_EXTRA_MATH 158 #if BC_ENABLED 159 { "global-stacks", BC_OPT_BC_ONLY, 'g' }, 160 { "mathlib", BC_OPT_BC_ONLY, 'l' }, 161 { "quiet", BC_OPT_BC_ONLY, 'q' }, 162 { "redefine", BC_OPT_REQUIRED_BC_ONLY, 'r' }, 163 { "standard", BC_OPT_BC_ONLY, 's' }, 164 { "warn", BC_OPT_BC_ONLY, 'w' }, 165 #endif // BC_ENABLED 166 { "version", BC_OPT_NONE, 'v' }, 167 { "version", BC_OPT_NONE, 'V' }, 168 #if DC_ENABLED 169 { "extended-register", BC_OPT_DC_ONLY, 'x' }, 170 #endif // DC_ENABLED 171 { NULL, 0, 0 }, 172 173 }; 174 175 /// The function header for error messages. 176 const char* const bc_err_func_header = "Function:"; 177 178 /// The line format string for error messages. 179 const char* const bc_err_line = ":%zu"; 180 181 // clang-format off 182 183 /// The default error category strings. 184 const char *bc_errs[] = { 185 "Math error:", 186 "Parse error:", 187 "Runtime error:", 188 "Fatal error:", 189 #if BC_ENABLED 190 "Warning:", 191 #endif // BC_ENABLED 192 }; 193 194 // clang-format on 195 196 /// The error category for each error. 197 const uchar bc_err_ids[] = { 198 199 BC_ERR_IDX_MATH, BC_ERR_IDX_MATH, BC_ERR_IDX_MATH, BC_ERR_IDX_MATH, 200 201 BC_ERR_IDX_FATAL, BC_ERR_IDX_FATAL, BC_ERR_IDX_FATAL, BC_ERR_IDX_FATAL, 202 BC_ERR_IDX_FATAL, BC_ERR_IDX_FATAL, BC_ERR_IDX_FATAL, BC_ERR_IDX_FATAL, 203 BC_ERR_IDX_FATAL, 204 205 BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, 206 BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, 207 BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, BC_ERR_IDX_EXEC, 208 209 BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, 210 BC_ERR_IDX_PARSE, 211 #if BC_ENABLED 212 BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, 213 BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, 214 BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, 215 216 BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, 217 BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, 218 BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, 219 BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, BC_ERR_IDX_PARSE, 220 #endif // BC_ENABLED 221 222 }; 223 224 /// The default error messages. There are NULL pointers because the positions 225 /// must be preserved for the locales. 226 const char* const bc_err_msgs[] = { 227 228 "negative number", 229 "non-integer number", 230 "overflow: number cannot fit", 231 "divide by 0", 232 233 "memory allocation failed", 234 "I/O error", 235 "cannot open file: %s", 236 "file is not text: %s", 237 "path is a directory: %s", 238 "bad command-line option: \"%s\"", 239 "option requires an argument: '%c' (\"%s\")", 240 "option takes no arguments: '%c' (\"%s\")", 241 "bad option argument: \"%s\"", 242 243 "bad ibase: must be [%lu, %lu]", 244 "bad obase: must be [%lu, %lu]", 245 "bad scale: must be [%lu, %lu]", 246 "bad read() expression", 247 "read() call inside of a read() call", 248 "variable or array element is the wrong type", 249 #if DC_ENABLED 250 "stack has too few elements", 251 "stack for register \"%s\" has too few elements", 252 #else // DC_ENABLED 253 NULL, 254 NULL, 255 #endif // DC_ENABLED 256 #if BC_ENABLED 257 "wrong number of parameters; need %zu, have %zu", 258 "undefined function: %s()", 259 "cannot use a void value in an expression", 260 #else 261 NULL, 262 NULL, 263 NULL, 264 #endif // BC_ENABLED 265 266 "end of file", 267 "bad character '%c'", 268 "string end cannot be found", 269 "comment end cannot be found", 270 "bad token", 271 #if BC_ENABLED 272 "bad expression", 273 "empty expression", 274 "bad print or stream statement", 275 "bad function definition", 276 ("bad assignment: left side must be scale, ibase, " 277 "obase, seed, last, var, or array element"), 278 "no auto variable found", 279 "function parameter or auto \"%s%s\" already exists", 280 "block end cannot be found", 281 "cannot return a value from void function: %s()", 282 "var cannot be a reference: %s", 283 284 "POSIX does not allow names longer than 1 character: %s", 285 "POSIX does not allow '#' script comments", 286 "POSIX does not allow the following keyword: %s", 287 "POSIX does not allow a period ('.') as a shortcut for the last result", 288 "POSIX requires parentheses around return expressions", 289 "POSIX does not allow the following operator: %s", 290 "POSIX does not allow comparison operators outside if statements or loops", 291 "POSIX requires 0 or 1 comparison operators per condition", 292 "POSIX requires all 3 parts of a for loop to be non-empty", 293 "POSIX requires a newline between a semicolon and a function definition", 294 #if BC_ENABLE_EXTRA_MATH 295 "POSIX does not allow exponential notation", 296 #else 297 NULL, 298 #endif // BC_ENABLE_EXTRA_MATH 299 "POSIX does not allow array references as function parameters", 300 "POSIX does not allow void functions", 301 "POSIX requires the left brace be on the same line as the function header", 302 "POSIX does not allow strings to be assigned to variables or arrays", 303 #endif // BC_ENABLED 304 305 }; 306 307 #endif // !BC_ENABLE_LIBRARY 308 309 /// The destructors corresponding to BcDtorType enum items. 310 const BcVecFree bc_vec_dtors[] = { 311 NULL, 312 bc_vec_free, 313 bc_num_free, 314 #if !BC_ENABLE_LIBRARY 315 #ifndef NDEBUG 316 bc_func_free, 317 #endif // NDEBUG 318 bc_slab_free, 319 bc_const_free, 320 bc_result_free, 321 #if BC_ENABLE_HISTORY && !BC_ENABLE_LINE_LIB 322 bc_history_string_free, 323 #endif // BC_ENABLE_HISTORY && !BC_ENABLE_LINE_LIB 324 #else // !BC_ENABLE_LIBRARY 325 bcl_num_destruct, 326 #endif // !BC_ENABLE_LIBRARY 327 }; 328 329 #if !BC_ENABLE_LIBRARY 330 331 #if BC_ENABLE_EDITLINE 332 333 /// The normal path to the editrc. 334 const char bc_history_editrc[] = "/.editrc"; 335 336 /// The length of the normal path to the editrc. 337 const size_t bc_history_editrc_len = sizeof(bc_history_editrc) - 1; 338 339 #endif // BC_ENABLE_EDITLINE 340 341 #if BC_ENABLE_HISTORY && !BC_ENABLE_LINE_LIB 342 343 /// A flush type for not clearing current extras but not saving new ones either. 344 const BcFlushType bc_flush_none = BC_FLUSH_NO_EXTRAS_NO_CLEAR; 345 346 /// A flush type for clearing extras and not saving new ones. 347 const BcFlushType bc_flush_err = BC_FLUSH_NO_EXTRAS_CLEAR; 348 349 /// A flush type for clearing previous extras and saving new ones. 350 const BcFlushType bc_flush_save = BC_FLUSH_SAVE_EXTRAS_CLEAR; 351 352 /// A list of known bad terminals. 353 const char* bc_history_bad_terms[] = { "dumb", "cons25", "emacs", NULL }; 354 355 /// A constant for tabs and its length. My tab handling is dumb and always 356 /// outputs the entire thing. 357 const char bc_history_tab[] = "\t"; 358 const size_t bc_history_tab_len = sizeof(bc_history_tab) - 1; 359 360 /// A list of wide chars. These are listed in ascending order for efficiency. 361 const uint32_t bc_history_wchars[][2] = { 362 { 0x1100, 0x115F }, { 0x231A, 0x231B }, { 0x2329, 0x232A }, 363 { 0x23E9, 0x23EC }, { 0x23F0, 0x23F0 }, { 0x23F3, 0x23F3 }, 364 { 0x25FD, 0x25FE }, { 0x2614, 0x2615 }, { 0x2648, 0x2653 }, 365 { 0x267F, 0x267F }, { 0x2693, 0x2693 }, { 0x26A1, 0x26A1 }, 366 { 0x26AA, 0x26AB }, { 0x26BD, 0x26BE }, { 0x26C4, 0x26C5 }, 367 { 0x26CE, 0x26CE }, { 0x26D4, 0x26D4 }, { 0x26EA, 0x26EA }, 368 { 0x26F2, 0x26F3 }, { 0x26F5, 0x26F5 }, { 0x26FA, 0x26FA }, 369 { 0x26FD, 0x26FD }, { 0x2705, 0x2705 }, { 0x270A, 0x270B }, 370 { 0x2728, 0x2728 }, { 0x274C, 0x274C }, { 0x274E, 0x274E }, 371 { 0x2753, 0x2755 }, { 0x2757, 0x2757 }, { 0x2795, 0x2797 }, 372 { 0x27B0, 0x27B0 }, { 0x27BF, 0x27BF }, { 0x2B1B, 0x2B1C }, 373 { 0x2B50, 0x2B50 }, { 0x2B55, 0x2B55 }, { 0x2E80, 0x2E99 }, 374 { 0x2E9B, 0x2EF3 }, { 0x2F00, 0x2FD5 }, { 0x2FF0, 0x2FFB }, 375 { 0x3001, 0x303E }, { 0x3041, 0x3096 }, { 0x3099, 0x30FF }, 376 { 0x3105, 0x312D }, { 0x3131, 0x318E }, { 0x3190, 0x31BA }, 377 { 0x31C0, 0x31E3 }, { 0x31F0, 0x321E }, { 0x3220, 0x3247 }, 378 { 0x3250, 0x32FE }, { 0x3300, 0x4DBF }, { 0x4E00, 0xA48C }, 379 { 0xA490, 0xA4C6 }, { 0xA960, 0xA97C }, { 0xAC00, 0xD7A3 }, 380 { 0xF900, 0xFAFF }, { 0xFE10, 0xFE19 }, { 0xFE30, 0xFE52 }, 381 { 0xFE54, 0xFE66 }, { 0xFE68, 0xFE6B }, { 0x16FE0, 0x16FE0 }, 382 { 0x17000, 0x187EC }, { 0x18800, 0x18AF2 }, { 0x1B000, 0x1B001 }, 383 { 0x1F004, 0x1F004 }, { 0x1F0CF, 0x1F0CF }, { 0x1F18E, 0x1F18E }, 384 { 0x1F191, 0x1F19A }, { 0x1F200, 0x1F202 }, { 0x1F210, 0x1F23B }, 385 { 0x1F240, 0x1F248 }, { 0x1F250, 0x1F251 }, { 0x1F300, 0x1F320 }, 386 { 0x1F32D, 0x1F335 }, { 0x1F337, 0x1F37C }, { 0x1F37E, 0x1F393 }, 387 { 0x1F3A0, 0x1F3CA }, { 0x1F3CF, 0x1F3D3 }, { 0x1F3E0, 0x1F3F0 }, 388 { 0x1F3F4, 0x1F3F4 }, { 0x1F3F8, 0x1F43E }, { 0x1F440, 0x1F440 }, 389 { 0x1F442, 0x1F4FC }, { 0x1F4FF, 0x1F53D }, { 0x1F54B, 0x1F54E }, 390 { 0x1F550, 0x1F567 }, { 0x1F57A, 0x1F57A }, { 0x1F595, 0x1F596 }, 391 { 0x1F5A4, 0x1F5A4 }, { 0x1F5FB, 0x1F64F }, { 0x1F680, 0x1F6C5 }, 392 { 0x1F6CC, 0x1F6CC }, { 0x1F6D0, 0x1F6D2 }, { 0x1F6EB, 0x1F6EC }, 393 { 0x1F6F4, 0x1F6F6 }, { 0x1F910, 0x1F91E }, { 0x1F920, 0x1F927 }, 394 { 0x1F930, 0x1F930 }, { 0x1F933, 0x1F93E }, { 0x1F940, 0x1F94B }, 395 { 0x1F950, 0x1F95E }, { 0x1F980, 0x1F991 }, { 0x1F9C0, 0x1F9C0 }, 396 { 0x20000, 0x2FFFD }, { 0x30000, 0x3FFFD }, 397 }; 398 399 /// The length of the wide chars list. 400 const size_t bc_history_wchars_len = sizeof(bc_history_wchars) / 401 sizeof(bc_history_wchars[0]); 402 403 /// A list of combining characters in Unicode. These are listed in ascending 404 /// order for efficiency. 405 const uint32_t bc_history_combo_chars[] = { 406 0x0300, 0x0301, 0x0302, 0x0303, 0x0304, 0x0305, 0x0306, 0x0307, 407 0x0308, 0x0309, 0x030A, 0x030B, 0x030C, 0x030D, 0x030E, 0x030F, 408 0x0310, 0x0311, 0x0312, 0x0313, 0x0314, 0x0315, 0x0316, 0x0317, 409 0x0318, 0x0319, 0x031A, 0x031B, 0x031C, 0x031D, 0x031E, 0x031F, 410 0x0320, 0x0321, 0x0322, 0x0323, 0x0324, 0x0325, 0x0326, 0x0327, 411 0x0328, 0x0329, 0x032A, 0x032B, 0x032C, 0x032D, 0x032E, 0x032F, 412 0x0330, 0x0331, 0x0332, 0x0333, 0x0334, 0x0335, 0x0336, 0x0337, 413 0x0338, 0x0339, 0x033A, 0x033B, 0x033C, 0x033D, 0x033E, 0x033F, 414 0x0340, 0x0341, 0x0342, 0x0343, 0x0344, 0x0345, 0x0346, 0x0347, 415 0x0348, 0x0349, 0x034A, 0x034B, 0x034C, 0x034D, 0x034E, 0x034F, 416 0x0350, 0x0351, 0x0352, 0x0353, 0x0354, 0x0355, 0x0356, 0x0357, 417 0x0358, 0x0359, 0x035A, 0x035B, 0x035C, 0x035D, 0x035E, 0x035F, 418 0x0360, 0x0361, 0x0362, 0x0363, 0x0364, 0x0365, 0x0366, 0x0367, 419 0x0368, 0x0369, 0x036A, 0x036B, 0x036C, 0x036D, 0x036E, 0x036F, 420 0x0483, 0x0484, 0x0485, 0x0486, 0x0487, 0x0591, 0x0592, 0x0593, 421 0x0594, 0x0595, 0x0596, 0x0597, 0x0598, 0x0599, 0x059A, 0x059B, 422 0x059C, 0x059D, 0x059E, 0x059F, 0x05A0, 0x05A1, 0x05A2, 0x05A3, 423 0x05A4, 0x05A5, 0x05A6, 0x05A7, 0x05A8, 0x05A9, 0x05AA, 0x05AB, 424 0x05AC, 0x05AD, 0x05AE, 0x05AF, 0x05B0, 0x05B1, 0x05B2, 0x05B3, 425 0x05B4, 0x05B5, 0x05B6, 0x05B7, 0x05B8, 0x05B9, 0x05BA, 0x05BB, 426 0x05BC, 0x05BD, 0x05BF, 0x05C1, 0x05C2, 0x05C4, 0x05C5, 0x05C7, 427 0x0610, 0x0611, 0x0612, 0x0613, 0x0614, 0x0615, 0x0616, 0x0617, 428 0x0618, 0x0619, 0x061A, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F, 429 0x0650, 0x0651, 0x0652, 0x0653, 0x0654, 0x0655, 0x0656, 0x0657, 430 0x0658, 0x0659, 0x065A, 0x065B, 0x065C, 0x065D, 0x065E, 0x065F, 431 0x0670, 0x06D6, 0x06D7, 0x06D8, 0x06D9, 0x06DA, 0x06DB, 0x06DC, 432 0x06DF, 0x06E0, 0x06E1, 0x06E2, 0x06E3, 0x06E4, 0x06E7, 0x06E8, 433 0x06EA, 0x06EB, 0x06EC, 0x06ED, 0x0711, 0x0730, 0x0731, 0x0732, 434 0x0733, 0x0734, 0x0735, 0x0736, 0x0737, 0x0738, 0x0739, 0x073A, 435 0x073B, 0x073C, 0x073D, 0x073E, 0x073F, 0x0740, 0x0741, 0x0742, 436 0x0743, 0x0744, 0x0745, 0x0746, 0x0747, 0x0748, 0x0749, 0x074A, 437 0x07A6, 0x07A7, 0x07A8, 0x07A9, 0x07AA, 0x07AB, 0x07AC, 0x07AD, 438 0x07AE, 0x07AF, 0x07B0, 0x07EB, 0x07EC, 0x07ED, 0x07EE, 0x07EF, 439 0x07F0, 0x07F1, 0x07F2, 0x07F3, 0x0816, 0x0817, 0x0818, 0x0819, 440 0x081B, 0x081C, 0x081D, 0x081E, 0x081F, 0x0820, 0x0821, 0x0822, 441 0x0823, 0x0825, 0x0826, 0x0827, 0x0829, 0x082A, 0x082B, 0x082C, 442 0x082D, 0x0859, 0x085A, 0x085B, 0x08D4, 0x08D5, 0x08D6, 0x08D7, 443 0x08D8, 0x08D9, 0x08DA, 0x08DB, 0x08DC, 0x08DD, 0x08DE, 0x08DF, 444 0x08E0, 0x08E1, 0x08E3, 0x08E4, 0x08E5, 0x08E6, 0x08E7, 0x08E8, 445 0x08E9, 0x08EA, 0x08EB, 0x08EC, 0x08ED, 0x08EE, 0x08EF, 0x08F0, 446 0x08F1, 0x08F2, 0x08F3, 0x08F4, 0x08F5, 0x08F6, 0x08F7, 0x08F8, 447 0x08F9, 0x08FA, 0x08FB, 0x08FC, 0x08FD, 0x08FE, 0x08FF, 0x0900, 448 0x0901, 0x0902, 0x093A, 0x093C, 0x0941, 0x0942, 0x0943, 0x0944, 449 0x0945, 0x0946, 0x0947, 0x0948, 0x094D, 0x0951, 0x0952, 0x0953, 450 0x0954, 0x0955, 0x0956, 0x0957, 0x0962, 0x0963, 0x0981, 0x09BC, 451 0x09C1, 0x09C2, 0x09C3, 0x09C4, 0x09CD, 0x09E2, 0x09E3, 0x0A01, 452 0x0A02, 0x0A3C, 0x0A41, 0x0A42, 0x0A47, 0x0A48, 0x0A4B, 0x0A4C, 453 0x0A4D, 0x0A51, 0x0A70, 0x0A71, 0x0A75, 0x0A81, 0x0A82, 0x0ABC, 454 0x0AC1, 0x0AC2, 0x0AC3, 0x0AC4, 0x0AC5, 0x0AC7, 0x0AC8, 0x0ACD, 455 0x0AE2, 0x0AE3, 0x0B01, 0x0B3C, 0x0B3F, 0x0B41, 0x0B42, 0x0B43, 456 0x0B44, 0x0B4D, 0x0B56, 0x0B62, 0x0B63, 0x0B82, 0x0BC0, 0x0BCD, 457 0x0C00, 0x0C3E, 0x0C3F, 0x0C40, 0x0C46, 0x0C47, 0x0C48, 0x0C4A, 458 0x0C4B, 0x0C4C, 0x0C4D, 0x0C55, 0x0C56, 0x0C62, 0x0C63, 0x0C81, 459 0x0CBC, 0x0CBF, 0x0CC6, 0x0CCC, 0x0CCD, 0x0CE2, 0x0CE3, 0x0D01, 460 0x0D41, 0x0D42, 0x0D43, 0x0D44, 0x0D4D, 0x0D62, 0x0D63, 0x0DCA, 461 0x0DD2, 0x0DD3, 0x0DD4, 0x0DD6, 0x0E31, 0x0E34, 0x0E35, 0x0E36, 462 0x0E37, 0x0E38, 0x0E39, 0x0E3A, 0x0E47, 0x0E48, 0x0E49, 0x0E4A, 463 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0EB1, 0x0EB4, 0x0EB5, 0x0EB6, 464 0x0EB7, 0x0EB8, 0x0EB9, 0x0EBB, 0x0EBC, 0x0EC8, 0x0EC9, 0x0ECA, 465 0x0ECB, 0x0ECC, 0x0ECD, 0x0F18, 0x0F19, 0x0F35, 0x0F37, 0x0F39, 466 0x0F71, 0x0F72, 0x0F73, 0x0F74, 0x0F75, 0x0F76, 0x0F77, 0x0F78, 467 0x0F79, 0x0F7A, 0x0F7B, 0x0F7C, 0x0F7D, 0x0F7E, 0x0F80, 0x0F81, 468 0x0F82, 0x0F83, 0x0F84, 0x0F86, 0x0F87, 0x0F8D, 0x0F8E, 0x0F8F, 469 0x0F90, 0x0F91, 0x0F92, 0x0F93, 0x0F94, 0x0F95, 0x0F96, 0x0F97, 470 0x0F99, 0x0F9A, 0x0F9B, 0x0F9C, 0x0F9D, 0x0F9E, 0x0F9F, 0x0FA0, 471 0x0FA1, 0x0FA2, 0x0FA3, 0x0FA4, 0x0FA5, 0x0FA6, 0x0FA7, 0x0FA8, 472 0x0FA9, 0x0FAA, 0x0FAB, 0x0FAC, 0x0FAD, 0x0FAE, 0x0FAF, 0x0FB0, 473 0x0FB1, 0x0FB2, 0x0FB3, 0x0FB4, 0x0FB5, 0x0FB6, 0x0FB7, 0x0FB8, 474 0x0FB9, 0x0FBA, 0x0FBB, 0x0FBC, 0x0FC6, 0x102D, 0x102E, 0x102F, 475 0x1030, 0x1032, 0x1033, 0x1034, 0x1035, 0x1036, 0x1037, 0x1039, 476 0x103A, 0x103D, 0x103E, 0x1058, 0x1059, 0x105E, 0x105F, 0x1060, 477 0x1071, 0x1072, 0x1073, 0x1074, 0x1082, 0x1085, 0x1086, 0x108D, 478 0x109D, 0x135D, 0x135E, 0x135F, 0x1712, 0x1713, 0x1714, 0x1732, 479 0x1733, 0x1734, 0x1752, 0x1753, 0x1772, 0x1773, 0x17B4, 0x17B5, 480 0x17B7, 0x17B8, 0x17B9, 0x17BA, 0x17BB, 0x17BC, 0x17BD, 0x17C6, 481 0x17C9, 0x17CA, 0x17CB, 0x17CC, 0x17CD, 0x17CE, 0x17CF, 0x17D0, 482 0x17D1, 0x17D2, 0x17D3, 0x17DD, 0x180B, 0x180C, 0x180D, 0x1885, 483 0x1886, 0x18A9, 0x1920, 0x1921, 0x1922, 0x1927, 0x1928, 0x1932, 484 0x1939, 0x193A, 0x193B, 0x1A17, 0x1A18, 0x1A1B, 0x1A56, 0x1A58, 485 0x1A59, 0x1A5A, 0x1A5B, 0x1A5C, 0x1A5D, 0x1A5E, 0x1A60, 0x1A62, 486 0x1A65, 0x1A66, 0x1A67, 0x1A68, 0x1A69, 0x1A6A, 0x1A6B, 0x1A6C, 487 0x1A73, 0x1A74, 0x1A75, 0x1A76, 0x1A77, 0x1A78, 0x1A79, 0x1A7A, 488 0x1A7B, 0x1A7C, 0x1A7F, 0x1AB0, 0x1AB1, 0x1AB2, 0x1AB3, 0x1AB4, 489 0x1AB5, 0x1AB6, 0x1AB7, 0x1AB8, 0x1AB9, 0x1ABA, 0x1ABB, 0x1ABC, 490 0x1ABD, 0x1B00, 0x1B01, 0x1B02, 0x1B03, 0x1B34, 0x1B36, 0x1B37, 491 0x1B38, 0x1B39, 0x1B3A, 0x1B3C, 0x1B42, 0x1B6B, 0x1B6C, 0x1B6D, 492 0x1B6E, 0x1B6F, 0x1B70, 0x1B71, 0x1B72, 0x1B73, 0x1B80, 0x1B81, 493 0x1BA2, 0x1BA3, 0x1BA4, 0x1BA5, 0x1BA8, 0x1BA9, 0x1BAB, 0x1BAC, 494 0x1BAD, 0x1BE6, 0x1BE8, 0x1BE9, 0x1BED, 0x1BEF, 0x1BF0, 0x1BF1, 495 0x1C2C, 0x1C2D, 0x1C2E, 0x1C2F, 0x1C30, 0x1C31, 0x1C32, 0x1C33, 496 0x1C36, 0x1C37, 0x1CD0, 0x1CD1, 0x1CD2, 0x1CD4, 0x1CD5, 0x1CD6, 497 0x1CD7, 0x1CD8, 0x1CD9, 0x1CDA, 0x1CDB, 0x1CDC, 0x1CDD, 0x1CDE, 498 0x1CDF, 0x1CE0, 0x1CE2, 0x1CE3, 0x1CE4, 0x1CE5, 0x1CE6, 0x1CE7, 499 0x1CE8, 0x1CED, 0x1CF4, 0x1CF8, 0x1CF9, 0x1DC0, 0x1DC1, 0x1DC2, 500 0x1DC3, 0x1DC4, 0x1DC5, 0x1DC6, 0x1DC7, 0x1DC8, 0x1DC9, 0x1DCA, 501 0x1DCB, 0x1DCC, 0x1DCD, 0x1DCE, 0x1DCF, 0x1DD0, 0x1DD1, 0x1DD2, 502 0x1DD3, 0x1DD4, 0x1DD5, 0x1DD6, 0x1DD7, 0x1DD8, 0x1DD9, 0x1DDA, 503 0x1DDB, 0x1DDC, 0x1DDD, 0x1DDE, 0x1DDF, 0x1DE0, 0x1DE1, 0x1DE2, 504 0x1DE3, 0x1DE4, 0x1DE5, 0x1DE6, 0x1DE7, 0x1DE8, 0x1DE9, 0x1DEA, 505 0x1DEB, 0x1DEC, 0x1DED, 0x1DEE, 0x1DEF, 0x1DF0, 0x1DF1, 0x1DF2, 506 0x1DF3, 0x1DF4, 0x1DF5, 0x1DFB, 0x1DFC, 0x1DFD, 0x1DFE, 0x1DFF, 507 0x20D0, 0x20D1, 0x20D2, 0x20D3, 0x20D4, 0x20D5, 0x20D6, 0x20D7, 508 0x20D8, 0x20D9, 0x20DA, 0x20DB, 0x20DC, 0x20E1, 0x20E5, 0x20E6, 509 0x20E7, 0x20E8, 0x20E9, 0x20EA, 0x20EB, 0x20EC, 0x20ED, 0x20EE, 510 0x20EF, 0x20F0, 0x2CEF, 0x2CF0, 0x2CF1, 0x2D7F, 0x2DE0, 0x2DE1, 511 0x2DE2, 0x2DE3, 0x2DE4, 0x2DE5, 0x2DE6, 0x2DE7, 0x2DE8, 0x2DE9, 512 0x2DEA, 0x2DEB, 0x2DEC, 0x2DED, 0x2DEE, 0x2DEF, 0x2DF0, 0x2DF1, 513 0x2DF2, 0x2DF3, 0x2DF4, 0x2DF5, 0x2DF6, 0x2DF7, 0x2DF8, 0x2DF9, 514 0x2DFA, 0x2DFB, 0x2DFC, 0x2DFD, 0x2DFE, 0x2DFF, 0x302A, 0x302B, 515 0x302C, 0x302D, 0x3099, 0x309A, 0xA66F, 0xA674, 0xA675, 0xA676, 516 0xA677, 0xA678, 0xA679, 0xA67A, 0xA67B, 0xA67C, 0xA67D, 0xA69E, 517 0xA69F, 0xA6F0, 0xA6F1, 0xA802, 0xA806, 0xA80B, 0xA825, 0xA826, 518 0xA8C4, 0xA8C5, 0xA8E0, 0xA8E1, 0xA8E2, 0xA8E3, 0xA8E4, 0xA8E5, 519 0xA8E6, 0xA8E7, 0xA8E8, 0xA8E9, 0xA8EA, 0xA8EB, 0xA8EC, 0xA8ED, 520 0xA8EE, 0xA8EF, 0xA8F0, 0xA8F1, 0xA926, 0xA927, 0xA928, 0xA929, 521 0xA92A, 0xA92B, 0xA92C, 0xA92D, 0xA947, 0xA948, 0xA949, 0xA94A, 522 0xA94B, 0xA94C, 0xA94D, 0xA94E, 0xA94F, 0xA950, 0xA951, 0xA980, 523 0xA981, 0xA982, 0xA9B3, 0xA9B6, 0xA9B7, 0xA9B8, 0xA9B9, 0xA9BC, 524 0xA9E5, 0xAA29, 0xAA2A, 0xAA2B, 0xAA2C, 0xAA2D, 0xAA2E, 0xAA31, 525 0xAA32, 0xAA35, 0xAA36, 0xAA43, 0xAA4C, 0xAA7C, 0xAAB0, 0xAAB2, 526 0xAAB3, 0xAAB4, 0xAAB7, 0xAAB8, 0xAABE, 0xAABF, 0xAAC1, 0xAAEC, 527 0xAAED, 0xAAF6, 0xABE5, 0xABE8, 0xABED, 0xFB1E, 0xFE00, 0xFE01, 528 0xFE02, 0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07, 0xFE08, 0xFE09, 529 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F, 0xFE20, 0xFE21, 530 0xFE22, 0xFE23, 0xFE24, 0xFE25, 0xFE26, 0xFE27, 0xFE28, 0xFE29, 531 0xFE2A, 0xFE2B, 0xFE2C, 0xFE2D, 0xFE2E, 0xFE2F, 0x101FD, 0x102E0, 532 0x10376, 0x10377, 0x10378, 0x10379, 0x1037A, 0x10A01, 0x10A02, 0x10A03, 533 0x10A05, 0x10A06, 0x10A0C, 0x10A0D, 0x10A0E, 0x10A0F, 0x10A38, 0x10A39, 534 0x10A3A, 0x10A3F, 0x10AE5, 0x10AE6, 0x11001, 0x11038, 0x11039, 0x1103A, 535 0x1103B, 0x1103C, 0x1103D, 0x1103E, 0x1103F, 0x11040, 0x11041, 0x11042, 536 0x11043, 0x11044, 0x11045, 0x11046, 0x1107F, 0x11080, 0x11081, 0x110B3, 537 0x110B4, 0x110B5, 0x110B6, 0x110B9, 0x110BA, 0x11100, 0x11101, 0x11102, 538 0x11127, 0x11128, 0x11129, 0x1112A, 0x1112B, 0x1112D, 0x1112E, 0x1112F, 539 0x11130, 0x11131, 0x11132, 0x11133, 0x11134, 0x11173, 0x11180, 0x11181, 540 0x111B6, 0x111B7, 0x111B8, 0x111B9, 0x111BA, 0x111BB, 0x111BC, 0x111BD, 541 0x111BE, 0x111CA, 0x111CB, 0x111CC, 0x1122F, 0x11230, 0x11231, 0x11234, 542 0x11236, 0x11237, 0x1123E, 0x112DF, 0x112E3, 0x112E4, 0x112E5, 0x112E6, 543 0x112E7, 0x112E8, 0x112E9, 0x112EA, 0x11300, 0x11301, 0x1133C, 0x11340, 544 0x11366, 0x11367, 0x11368, 0x11369, 0x1136A, 0x1136B, 0x1136C, 0x11370, 545 0x11371, 0x11372, 0x11373, 0x11374, 0x11438, 0x11439, 0x1143A, 0x1143B, 546 0x1143C, 0x1143D, 0x1143E, 0x1143F, 0x11442, 0x11443, 0x11444, 0x11446, 547 0x114B3, 0x114B4, 0x114B5, 0x114B6, 0x114B7, 0x114B8, 0x114BA, 0x114BF, 548 0x114C0, 0x114C2, 0x114C3, 0x115B2, 0x115B3, 0x115B4, 0x115B5, 0x115BC, 549 0x115BD, 0x115BF, 0x115C0, 0x115DC, 0x115DD, 0x11633, 0x11634, 0x11635, 550 0x11636, 0x11637, 0x11638, 0x11639, 0x1163A, 0x1163D, 0x1163F, 0x11640, 551 0x116AB, 0x116AD, 0x116B0, 0x116B1, 0x116B2, 0x116B3, 0x116B4, 0x116B5, 552 0x116B7, 0x1171D, 0x1171E, 0x1171F, 0x11722, 0x11723, 0x11724, 0x11725, 553 0x11727, 0x11728, 0x11729, 0x1172A, 0x1172B, 0x11C30, 0x11C31, 0x11C32, 554 0x11C33, 0x11C34, 0x11C35, 0x11C36, 0x11C38, 0x11C39, 0x11C3A, 0x11C3B, 555 0x11C3C, 0x11C3D, 0x11C3F, 0x11C92, 0x11C93, 0x11C94, 0x11C95, 0x11C96, 556 0x11C97, 0x11C98, 0x11C99, 0x11C9A, 0x11C9B, 0x11C9C, 0x11C9D, 0x11C9E, 557 0x11C9F, 0x11CA0, 0x11CA1, 0x11CA2, 0x11CA3, 0x11CA4, 0x11CA5, 0x11CA6, 558 0x11CA7, 0x11CAA, 0x11CAB, 0x11CAC, 0x11CAD, 0x11CAE, 0x11CAF, 0x11CB0, 559 0x11CB2, 0x11CB3, 0x11CB5, 0x11CB6, 0x16AF0, 0x16AF1, 0x16AF2, 0x16AF3, 560 0x16AF4, 0x16B30, 0x16B31, 0x16B32, 0x16B33, 0x16B34, 0x16B35, 0x16B36, 561 0x16F8F, 0x16F90, 0x16F91, 0x16F92, 0x1BC9D, 0x1BC9E, 0x1D167, 0x1D168, 562 0x1D169, 0x1D17B, 0x1D17C, 0x1D17D, 0x1D17E, 0x1D17F, 0x1D180, 0x1D181, 563 0x1D182, 0x1D185, 0x1D186, 0x1D187, 0x1D188, 0x1D189, 0x1D18A, 0x1D18B, 564 0x1D1AA, 0x1D1AB, 0x1D1AC, 0x1D1AD, 0x1D242, 0x1D243, 0x1D244, 0x1DA00, 565 0x1DA01, 0x1DA02, 0x1DA03, 0x1DA04, 0x1DA05, 0x1DA06, 0x1DA07, 0x1DA08, 566 0x1DA09, 0x1DA0A, 0x1DA0B, 0x1DA0C, 0x1DA0D, 0x1DA0E, 0x1DA0F, 0x1DA10, 567 0x1DA11, 0x1DA12, 0x1DA13, 0x1DA14, 0x1DA15, 0x1DA16, 0x1DA17, 0x1DA18, 568 0x1DA19, 0x1DA1A, 0x1DA1B, 0x1DA1C, 0x1DA1D, 0x1DA1E, 0x1DA1F, 0x1DA20, 569 0x1DA21, 0x1DA22, 0x1DA23, 0x1DA24, 0x1DA25, 0x1DA26, 0x1DA27, 0x1DA28, 570 0x1DA29, 0x1DA2A, 0x1DA2B, 0x1DA2C, 0x1DA2D, 0x1DA2E, 0x1DA2F, 0x1DA30, 571 0x1DA31, 0x1DA32, 0x1DA33, 0x1DA34, 0x1DA35, 0x1DA36, 0x1DA3B, 0x1DA3C, 572 0x1DA3D, 0x1DA3E, 0x1DA3F, 0x1DA40, 0x1DA41, 0x1DA42, 0x1DA43, 0x1DA44, 573 0x1DA45, 0x1DA46, 0x1DA47, 0x1DA48, 0x1DA49, 0x1DA4A, 0x1DA4B, 0x1DA4C, 574 0x1DA4D, 0x1DA4E, 0x1DA4F, 0x1DA50, 0x1DA51, 0x1DA52, 0x1DA53, 0x1DA54, 575 0x1DA55, 0x1DA56, 0x1DA57, 0x1DA58, 0x1DA59, 0x1DA5A, 0x1DA5B, 0x1DA5C, 576 0x1DA5D, 0x1DA5E, 0x1DA5F, 0x1DA60, 0x1DA61, 0x1DA62, 0x1DA63, 0x1DA64, 577 0x1DA65, 0x1DA66, 0x1DA67, 0x1DA68, 0x1DA69, 0x1DA6A, 0x1DA6B, 0x1DA6C, 578 0x1DA75, 0x1DA84, 0x1DA9B, 0x1DA9C, 0x1DA9D, 0x1DA9E, 0x1DA9F, 0x1DAA1, 579 0x1DAA2, 0x1DAA3, 0x1DAA4, 0x1DAA5, 0x1DAA6, 0x1DAA7, 0x1DAA8, 0x1DAA9, 580 0x1DAAA, 0x1DAAB, 0x1DAAC, 0x1DAAD, 0x1DAAE, 0x1DAAF, 0x1E000, 0x1E001, 581 0x1E002, 0x1E003, 0x1E004, 0x1E005, 0x1E006, 0x1E008, 0x1E009, 0x1E00A, 582 0x1E00B, 0x1E00C, 0x1E00D, 0x1E00E, 0x1E00F, 0x1E010, 0x1E011, 0x1E012, 583 0x1E013, 0x1E014, 0x1E015, 0x1E016, 0x1E017, 0x1E018, 0x1E01B, 0x1E01C, 584 0x1E01D, 0x1E01E, 0x1E01F, 0x1E020, 0x1E021, 0x1E023, 0x1E024, 0x1E026, 585 0x1E027, 0x1E028, 0x1E029, 0x1E02A, 0x1E8D0, 0x1E8D1, 0x1E8D2, 0x1E8D3, 586 0x1E8D4, 0x1E8D5, 0x1E8D6, 0x1E944, 0x1E945, 0x1E946, 0x1E947, 0x1E948, 587 0x1E949, 0x1E94A, 0xE0100, 0xE0101, 0xE0102, 0xE0103, 0xE0104, 0xE0105, 588 0xE0106, 0xE0107, 0xE0108, 0xE0109, 0xE010A, 0xE010B, 0xE010C, 0xE010D, 589 0xE010E, 0xE010F, 0xE0110, 0xE0111, 0xE0112, 0xE0113, 0xE0114, 0xE0115, 590 0xE0116, 0xE0117, 0xE0118, 0xE0119, 0xE011A, 0xE011B, 0xE011C, 0xE011D, 591 0xE011E, 0xE011F, 0xE0120, 0xE0121, 0xE0122, 0xE0123, 0xE0124, 0xE0125, 592 0xE0126, 0xE0127, 0xE0128, 0xE0129, 0xE012A, 0xE012B, 0xE012C, 0xE012D, 593 0xE012E, 0xE012F, 0xE0130, 0xE0131, 0xE0132, 0xE0133, 0xE0134, 0xE0135, 594 0xE0136, 0xE0137, 0xE0138, 0xE0139, 0xE013A, 0xE013B, 0xE013C, 0xE013D, 595 0xE013E, 0xE013F, 0xE0140, 0xE0141, 0xE0142, 0xE0143, 0xE0144, 0xE0145, 596 0xE0146, 0xE0147, 0xE0148, 0xE0149, 0xE014A, 0xE014B, 0xE014C, 0xE014D, 597 0xE014E, 0xE014F, 0xE0150, 0xE0151, 0xE0152, 0xE0153, 0xE0154, 0xE0155, 598 0xE0156, 0xE0157, 0xE0158, 0xE0159, 0xE015A, 0xE015B, 0xE015C, 0xE015D, 599 0xE015E, 0xE015F, 0xE0160, 0xE0161, 0xE0162, 0xE0163, 0xE0164, 0xE0165, 600 0xE0166, 0xE0167, 0xE0168, 0xE0169, 0xE016A, 0xE016B, 0xE016C, 0xE016D, 601 0xE016E, 0xE016F, 0xE0170, 0xE0171, 0xE0172, 0xE0173, 0xE0174, 0xE0175, 602 0xE0176, 0xE0177, 0xE0178, 0xE0179, 0xE017A, 0xE017B, 0xE017C, 0xE017D, 603 0xE017E, 0xE017F, 0xE0180, 0xE0181, 0xE0182, 0xE0183, 0xE0184, 0xE0185, 604 0xE0186, 0xE0187, 0xE0188, 0xE0189, 0xE018A, 0xE018B, 0xE018C, 0xE018D, 605 0xE018E, 0xE018F, 0xE0190, 0xE0191, 0xE0192, 0xE0193, 0xE0194, 0xE0195, 606 0xE0196, 0xE0197, 0xE0198, 0xE0199, 0xE019A, 0xE019B, 0xE019C, 0xE019D, 607 0xE019E, 0xE019F, 0xE01A0, 0xE01A1, 0xE01A2, 0xE01A3, 0xE01A4, 0xE01A5, 608 0xE01A6, 0xE01A7, 0xE01A8, 0xE01A9, 0xE01AA, 0xE01AB, 0xE01AC, 0xE01AD, 609 0xE01AE, 0xE01AF, 0xE01B0, 0xE01B1, 0xE01B2, 0xE01B3, 0xE01B4, 0xE01B5, 610 0xE01B6, 0xE01B7, 0xE01B8, 0xE01B9, 0xE01BA, 0xE01BB, 0xE01BC, 0xE01BD, 611 0xE01BE, 0xE01BF, 0xE01C0, 0xE01C1, 0xE01C2, 0xE01C3, 0xE01C4, 0xE01C5, 612 0xE01C6, 0xE01C7, 0xE01C8, 0xE01C9, 0xE01CA, 0xE01CB, 0xE01CC, 0xE01CD, 613 0xE01CE, 0xE01CF, 0xE01D0, 0xE01D1, 0xE01D2, 0xE01D3, 0xE01D4, 0xE01D5, 614 0xE01D6, 0xE01D7, 0xE01D8, 0xE01D9, 0xE01DA, 0xE01DB, 0xE01DC, 0xE01DD, 615 0xE01DE, 0xE01DF, 0xE01E0, 0xE01E1, 0xE01E2, 0xE01E3, 0xE01E4, 0xE01E5, 616 0xE01E6, 0xE01E7, 0xE01E8, 0xE01E9, 0xE01EA, 0xE01EB, 0xE01EC, 0xE01ED, 617 0xE01EE, 0xE01EF, 618 }; 619 620 /// The length of the combining characters list. 621 const size_t bc_history_combo_chars_len = sizeof(bc_history_combo_chars) / 622 sizeof(bc_history_combo_chars[0]); 623 #endif // BC_ENABLE_HISTORY && !BC_ENABLE_LINE_LIB 624 625 /// The human-readable name of the main function in bc source code. 626 const char bc_func_main[] = "(main)"; 627 628 /// The human-readable name of the read function in bc source code. 629 const char bc_func_read[] = "(read)"; 630 631 #if BC_DEBUG_CODE 632 633 /// A list of names of instructions for easy debugging output. 634 const char* bc_inst_names[] = { 635 636 #if BC_ENABLED 637 "BC_INST_INC", 638 "BC_INST_DEC", 639 #endif // BC_ENABLED 640 641 "BC_INST_NEG", 642 "BC_INST_BOOL_NOT", 643 #if BC_ENABLE_EXTRA_MATH 644 "BC_INST_TRUNC", 645 #endif // BC_ENABLE_EXTRA_MATH 646 647 "BC_INST_POWER", 648 "BC_INST_MULTIPLY", 649 "BC_INST_DIVIDE", 650 "BC_INST_MODULUS", 651 "BC_INST_PLUS", 652 "BC_INST_MINUS", 653 654 #if BC_ENABLE_EXTRA_MATH 655 "BC_INST_PLACES", 656 657 "BC_INST_LSHIFT", 658 "BC_INST_RSHIFT", 659 #endif // BC_ENABLE_EXTRA_MATH 660 661 "BC_INST_REL_EQ", 662 "BC_INST_REL_LE", 663 "BC_INST_REL_GE", 664 "BC_INST_REL_NE", 665 "BC_INST_REL_LT", 666 "BC_INST_REL_GT", 667 668 "BC_INST_BOOL_OR", 669 "BC_INST_BOOL_AND", 670 671 #if BC_ENABLED 672 "BC_INST_ASSIGN_POWER", 673 "BC_INST_ASSIGN_MULTIPLY", 674 "BC_INST_ASSIGN_DIVIDE", 675 "BC_INST_ASSIGN_MODULUS", 676 "BC_INST_ASSIGN_PLUS", 677 "BC_INST_ASSIGN_MINUS", 678 #if BC_ENABLE_EXTRA_MATH 679 "BC_INST_ASSIGN_PLACES", 680 "BC_INST_ASSIGN_LSHIFT", 681 "BC_INST_ASSIGN_RSHIFT", 682 #endif // BC_ENABLE_EXTRA_MATH 683 "BC_INST_ASSIGN", 684 685 "BC_INST_ASSIGN_POWER_NO_VAL", 686 "BC_INST_ASSIGN_MULTIPLY_NO_VAL", 687 "BC_INST_ASSIGN_DIVIDE_NO_VAL", 688 "BC_INST_ASSIGN_MODULUS_NO_VAL", 689 "BC_INST_ASSIGN_PLUS_NO_VAL", 690 "BC_INST_ASSIGN_MINUS_NO_VAL", 691 #if BC_ENABLE_EXTRA_MATH 692 "BC_INST_ASSIGN_PLACES_NO_VAL", 693 "BC_INST_ASSIGN_LSHIFT_NO_VAL", 694 "BC_INST_ASSIGN_RSHIFT_NO_VAL", 695 #endif // BC_ENABLE_EXTRA_MATH 696 #endif // BC_ENABLED 697 "BC_INST_ASSIGN_NO_VAL", 698 699 "BC_INST_NUM", 700 "BC_INST_VAR", 701 "BC_INST_ARRAY_ELEM", 702 "BC_INST_ARRAY", 703 704 "BC_INST_ZERO", 705 "BC_INST_ONE", 706 707 #if BC_ENABLED 708 "BC_INST_LAST", 709 #endif // BC_ENABLED 710 "BC_INST_IBASE", 711 "BC_INST_OBASE", 712 "BC_INST_SCALE", 713 #if BC_ENABLE_EXTRA_MATH 714 "BC_INST_SEED", 715 #endif // BC_ENABLE_EXTRA_MATH 716 "BC_INST_LENGTH", 717 "BC_INST_SCALE_FUNC", 718 "BC_INST_SQRT", 719 "BC_INST_ABS", 720 #if BC_ENABLE_EXTRA_MATH 721 "BC_INST_IRAND", 722 #endif // BC_ENABLE_EXTRA_MATH 723 "BC_INST_ASCIIFY", 724 "BC_INST_READ", 725 #if BC_ENABLE_EXTRA_MATH 726 "BC_INST_RAND", 727 #endif // BC_ENABLE_EXTRA_MATH 728 "BC_INST_MAXIBASE", 729 "BC_INST_MAXOBASE", 730 "BC_INST_MAXSCALE", 731 #if BC_ENABLE_EXTRA_MATH 732 "BC_INST_MAXRAND", 733 #endif // BC_ENABLE_EXTRA_MATH 734 735 "BC_INST_PRINT", 736 "BC_INST_PRINT_POP", 737 "BC_INST_STR", 738 #if BC_ENABLED 739 "BC_INST_PRINT_STR", 740 741 "BC_INST_JUMP", 742 "BC_INST_JUMP_ZERO", 743 744 "BC_INST_CALL", 745 746 "BC_INST_RET", 747 "BC_INST_RET0", 748 "BC_INST_RET_VOID", 749 750 "BC_INST_HALT", 751 #endif // BC_ENABLED 752 753 "BC_INST_POP", 754 "BC_INST_SWAP", 755 "BC_INST_MODEXP", 756 "BC_INST_DIVMOD", 757 "BC_INST_PRINT_STREAM", 758 759 #if DC_ENABLED 760 "BC_INST_POP_EXEC", 761 762 "BC_INST_EXECUTE", 763 "BC_INST_EXEC_COND", 764 765 "BC_INST_PRINT_STACK", 766 "BC_INST_CLEAR_STACK", 767 "BC_INST_REG_STACK_LEN", 768 "BC_INST_STACK_LEN", 769 "BC_INST_DUPLICATE", 770 771 "BC_INST_LOAD", 772 "BC_INST_PUSH_VAR", 773 "BC_INST_PUSH_TO_VAR", 774 775 "BC_INST_QUIT", 776 "BC_INST_NQUIT", 777 778 "BC_INST_EXEC_STACK_LEN", 779 #endif // DC_ENABLED 780 781 "BC_INST_INVALID", 782 }; 783 784 #endif // BC_DEBUG_CODE 785 786 /// A constant string for 0. 787 const char bc_parse_zero[2] = "0"; 788 789 /// A constant string for 1. 790 const char bc_parse_one[2] = "1"; 791 792 #if BC_ENABLED 793 794 /// A list of keywords for bc. This needs to be updated if keywords change. 795 const BcLexKeyword bc_lex_kws[] = { 796 BC_LEX_KW_ENTRY("auto", 4, true), 797 BC_LEX_KW_ENTRY("break", 5, true), 798 BC_LEX_KW_ENTRY("continue", 8, false), 799 BC_LEX_KW_ENTRY("define", 6, true), 800 BC_LEX_KW_ENTRY("for", 3, true), 801 BC_LEX_KW_ENTRY("if", 2, true), 802 BC_LEX_KW_ENTRY("limits", 6, false), 803 BC_LEX_KW_ENTRY("return", 6, true), 804 BC_LEX_KW_ENTRY("while", 5, true), 805 BC_LEX_KW_ENTRY("halt", 4, false), 806 BC_LEX_KW_ENTRY("last", 4, false), 807 BC_LEX_KW_ENTRY("ibase", 5, true), 808 BC_LEX_KW_ENTRY("obase", 5, true), 809 BC_LEX_KW_ENTRY("scale", 5, true), 810 #if BC_ENABLE_EXTRA_MATH 811 BC_LEX_KW_ENTRY("seed", 4, false), 812 #endif // BC_ENABLE_EXTRA_MATH 813 BC_LEX_KW_ENTRY("length", 6, true), 814 BC_LEX_KW_ENTRY("print", 5, false), 815 BC_LEX_KW_ENTRY("sqrt", 4, true), 816 BC_LEX_KW_ENTRY("abs", 3, false), 817 #if BC_ENABLE_EXTRA_MATH 818 BC_LEX_KW_ENTRY("irand", 5, false), 819 #endif // BC_ENABLE_EXTRA_MATH 820 BC_LEX_KW_ENTRY("asciify", 7, false), 821 BC_LEX_KW_ENTRY("modexp", 6, false), 822 BC_LEX_KW_ENTRY("divmod", 6, false), 823 BC_LEX_KW_ENTRY("quit", 4, true), 824 BC_LEX_KW_ENTRY("read", 4, false), 825 #if BC_ENABLE_EXTRA_MATH 826 BC_LEX_KW_ENTRY("rand", 4, false), 827 #endif // BC_ENABLE_EXTRA_MATH 828 BC_LEX_KW_ENTRY("maxibase", 8, false), 829 BC_LEX_KW_ENTRY("maxobase", 8, false), 830 BC_LEX_KW_ENTRY("maxscale", 8, false), 831 #if BC_ENABLE_EXTRA_MATH 832 BC_LEX_KW_ENTRY("maxrand", 7, false), 833 #endif // BC_ENABLE_EXTRA_MATH 834 BC_LEX_KW_ENTRY("line_length", 11, false), 835 BC_LEX_KW_ENTRY("global_stacks", 13, false), 836 BC_LEX_KW_ENTRY("leading_zero", 12, false), 837 BC_LEX_KW_ENTRY("stream", 6, false), 838 BC_LEX_KW_ENTRY("else", 4, false), 839 }; 840 841 /// The length of the list of bc keywords. 842 const size_t bc_lex_kws_len = sizeof(bc_lex_kws) / sizeof(BcLexKeyword); 843 844 #if BC_C11 845 846 // This is here to ensure that BC_LEX_NKWS, which is needed for the 847 // redefined_kws in BcVm, is correct. If it's correct under C11, it will be 848 // correct under C99, and I did not know any other way of ensuring they remained 849 // synchronized. 850 _Static_assert(sizeof(bc_lex_kws) / sizeof(BcLexKeyword) == BC_LEX_NKWS, 851 "BC_LEX_NKWS is wrong."); 852 853 #endif // BC_C11 854 855 /// An array of booleans that correspond to token types. An entry is true if the 856 /// token is valid in an expression, false otherwise. This will need to change 857 /// if tokens change. 858 const uint8_t bc_parse_exprs[] = { 859 860 // Starts with BC_LEX_EOF. 861 BC_PARSE_EXPR_ENTRY(false, false, true, true, true, true, true, true), 862 863 // Starts with BC_LEX_OP_MULTIPLY if extra math is enabled, BC_LEX_OP_DIVIDE 864 // otherwise. 865 BC_PARSE_EXPR_ENTRY(true, true, true, true, true, true, true, true), 866 867 // Starts with BC_LEX_OP_REL_EQ if extra math is enabled, BC_LEX_OP_REL_LT 868 // otherwise. 869 BC_PARSE_EXPR_ENTRY(true, true, true, true, true, true, true, true), 870 871 #if BC_ENABLE_EXTRA_MATH 872 873 // Starts with BC_LEX_OP_ASSIGN_POWER. 874 BC_PARSE_EXPR_ENTRY(true, true, true, true, true, true, true, true), 875 876 // Starts with BC_LEX_OP_ASSIGN_RSHIFT. 877 BC_PARSE_EXPR_ENTRY(true, true, false, false, true, true, false, false), 878 879 // Starts with BC_LEX_RBRACKET. 880 BC_PARSE_EXPR_ENTRY(false, false, false, false, true, true, true, false), 881 882 // Starts with BC_LEX_KW_BREAK. 883 BC_PARSE_EXPR_ENTRY(false, false, false, false, false, false, false, false), 884 885 // Starts with BC_LEX_KW_HALT. 886 BC_PARSE_EXPR_ENTRY(false, true, true, true, true, true, true, false), 887 888 // Starts with BC_LEX_KW_SQRT. 889 BC_PARSE_EXPR_ENTRY(true, true, true, true, true, true, false, true), 890 891 // Starts with BC_LEX_KW_MAXIBASE. 892 BC_PARSE_EXPR_ENTRY(true, true, true, true, true, true, true, true), 893 894 // Starts with BC_LEX_KW_STREAM. 895 BC_PARSE_EXPR_ENTRY(false, false, 0, 0, 0, 0, 0, 0) 896 897 #else // BC_ENABLE_EXTRA_MATH 898 899 // Starts with BC_LEX_OP_ASSIGN_PLUS. 900 BC_PARSE_EXPR_ENTRY(true, true, true, false, false, true, true, false), 901 902 // Starts with BC_LEX_COMMA. 903 BC_PARSE_EXPR_ENTRY(false, false, false, false, false, true, true, true), 904 905 // Starts with BC_LEX_KW_AUTO. 906 BC_PARSE_EXPR_ENTRY(false, false, false, false, false, false, false, false), 907 908 // Starts with BC_LEX_KW_WHILE. 909 BC_PARSE_EXPR_ENTRY(false, false, true, true, true, true, true, false), 910 911 // Starts with BC_LEX_KW_SQRT. 912 BC_PARSE_EXPR_ENTRY(true, true, true, true, true, false, true, true), 913 914 // Starts with BC_LEX_KW_MAXSCALE, 915 BC_PARSE_EXPR_ENTRY(true, true, true, true, true, false, false, 0) 916 917 #endif // BC_ENABLE_EXTRA_MATH 918 }; 919 920 /// An array of data for operators that correspond to token types. 921 const uchar bc_parse_ops[] = { 922 BC_PARSE_OP(0, false), BC_PARSE_OP(0, false), BC_PARSE_OP(1, false), 923 BC_PARSE_OP(1, false), 924 #if BC_ENABLE_EXTRA_MATH 925 BC_PARSE_OP(2, false), 926 #endif // BC_ENABLE_EXTRA_MATH 927 BC_PARSE_OP(4, false), BC_PARSE_OP(5, true), BC_PARSE_OP(5, true), 928 BC_PARSE_OP(5, true), BC_PARSE_OP(6, true), BC_PARSE_OP(6, true), 929 #if BC_ENABLE_EXTRA_MATH 930 BC_PARSE_OP(3, false), BC_PARSE_OP(7, true), BC_PARSE_OP(7, true), 931 #endif // BC_ENABLE_EXTRA_MATH 932 BC_PARSE_OP(9, true), BC_PARSE_OP(9, true), BC_PARSE_OP(9, true), 933 BC_PARSE_OP(9, true), BC_PARSE_OP(9, true), BC_PARSE_OP(9, true), 934 BC_PARSE_OP(11, true), BC_PARSE_OP(10, true), BC_PARSE_OP(8, false), 935 BC_PARSE_OP(8, false), BC_PARSE_OP(8, false), BC_PARSE_OP(8, false), 936 BC_PARSE_OP(8, false), BC_PARSE_OP(8, false), 937 #if BC_ENABLE_EXTRA_MATH 938 BC_PARSE_OP(8, false), BC_PARSE_OP(8, false), BC_PARSE_OP(8, false), 939 #endif // BC_ENABLE_EXTRA_MATH 940 BC_PARSE_OP(8, false), 941 }; 942 943 // These identify what tokens can come after expressions in certain cases. 944 945 /// The valid next tokens for normal expressions. 946 const BcParseNext bc_parse_next_expr = BC_PARSE_NEXT(4, BC_LEX_NLINE, 947 BC_LEX_SCOLON, 948 BC_LEX_RBRACE, BC_LEX_EOF); 949 950 /// The valid next tokens for function argument expressions. 951 const BcParseNext bc_parse_next_arg = BC_PARSE_NEXT(2, BC_LEX_RPAREN, 952 BC_LEX_COMMA); 953 954 /// The valid next tokens for expressions in print statements. 955 const BcParseNext bc_parse_next_print = BC_PARSE_NEXT(4, BC_LEX_COMMA, 956 BC_LEX_NLINE, 957 BC_LEX_SCOLON, 958 BC_LEX_EOF); 959 960 /// The valid next tokens for if statement conditions or loop conditions. This 961 /// is used in for loops for the update expression and for builtin function. 962 /// 963 /// The name is an artifact of history, and is related to @a BC_PARSE_REL (see 964 /// include/parse.h). It refers to how POSIX only allows some operators as part 965 /// of the conditional of for loops, while loops, and if statements. 966 const BcParseNext bc_parse_next_rel = BC_PARSE_NEXT(1, BC_LEX_RPAREN); 967 968 /// The valid next tokens for array element expressions. 969 const BcParseNext bc_parse_next_elem = BC_PARSE_NEXT(1, BC_LEX_RBRACKET); 970 971 /// The valid next tokens for for loop initialization expressions and condition 972 /// expressions. 973 const BcParseNext bc_parse_next_for = BC_PARSE_NEXT(1, BC_LEX_SCOLON); 974 975 /// The valid next tokens for read expressions. 976 const BcParseNext bc_parse_next_read = BC_PARSE_NEXT(2, BC_LEX_NLINE, 977 BC_LEX_EOF); 978 979 /// The valid next tokens for the arguments of a builtin function with multiple 980 /// arguments. 981 const BcParseNext bc_parse_next_builtin = BC_PARSE_NEXT(1, BC_LEX_COMMA); 982 983 #endif // BC_ENABLED 984 985 #if DC_ENABLED 986 987 /// A list of instructions that need register arguments in dc. 988 const uint8_t dc_lex_regs[] = { 989 BC_LEX_OP_REL_EQ, BC_LEX_OP_REL_LE, BC_LEX_OP_REL_GE, 990 BC_LEX_OP_REL_NE, BC_LEX_OP_REL_LT, BC_LEX_OP_REL_GT, 991 BC_LEX_SCOLON, BC_LEX_COLON, BC_LEX_KW_ELSE, 992 BC_LEX_LOAD, BC_LEX_LOAD_POP, BC_LEX_OP_ASSIGN, 993 BC_LEX_STORE_PUSH, BC_LEX_REG_STACK_LEVEL, BC_LEX_ARRAY_LENGTH, 994 }; 995 996 /// The length of the list of register instructions. 997 const size_t dc_lex_regs_len = sizeof(dc_lex_regs) / sizeof(uint8_t); 998 999 /// A list corresponding to characters starting at double quote ("). If an entry 1000 /// is BC_LEX_INVALID, then that character needs extra lexing in dc. If it does 1001 /// not, the character can trivially be replaced by the entry. Positions are 1002 /// kept because it corresponds to the ASCII table. This may need to be changed 1003 /// if tokens change. 1004 const uchar dc_lex_tokens[] = { 1005 #if BC_ENABLE_EXTRA_MATH 1006 BC_LEX_KW_IRAND, 1007 #else // BC_ENABLE_EXTRA_MATH 1008 BC_LEX_INVALID, 1009 #endif // BC_ENABLE_EXTRA_MATH 1010 BC_LEX_INVALID, 1011 #if BC_ENABLE_EXTRA_MATH 1012 BC_LEX_OP_TRUNC, 1013 #else // BC_ENABLE_EXTRA_MATH 1014 BC_LEX_INVALID, 1015 #endif // BC_ENABLE_EXTRA_MATH 1016 BC_LEX_OP_MODULUS, 1017 BC_LEX_INVALID, 1018 #if BC_ENABLE_EXTRA_MATH 1019 BC_LEX_KW_RAND, 1020 #else // BC_ENABLE_EXTRA_MATH 1021 BC_LEX_INVALID, 1022 #endif // BC_ENABLE_EXTRA_MATH 1023 BC_LEX_LPAREN, 1024 BC_LEX_RPAREN, 1025 BC_LEX_OP_MULTIPLY, 1026 BC_LEX_OP_PLUS, 1027 BC_LEX_EXEC_STACK_LENGTH, 1028 BC_LEX_OP_MINUS, 1029 BC_LEX_INVALID, 1030 BC_LEX_OP_DIVIDE, 1031 BC_LEX_INVALID, 1032 BC_LEX_INVALID, 1033 BC_LEX_INVALID, 1034 BC_LEX_INVALID, 1035 BC_LEX_INVALID, 1036 BC_LEX_INVALID, 1037 BC_LEX_INVALID, 1038 BC_LEX_INVALID, 1039 BC_LEX_INVALID, 1040 BC_LEX_INVALID, 1041 BC_LEX_COLON, 1042 BC_LEX_SCOLON, 1043 BC_LEX_OP_REL_GT, 1044 BC_LEX_OP_REL_EQ, 1045 BC_LEX_OP_REL_LT, 1046 BC_LEX_KW_READ, 1047 #if BC_ENABLE_EXTRA_MATH 1048 BC_LEX_OP_PLACES, 1049 #else // BC_ENABLE_EXTRA_MATH 1050 BC_LEX_INVALID, 1051 #endif // BC_ENABLE_EXTRA_MATH 1052 BC_LEX_INVALID, 1053 BC_LEX_INVALID, 1054 BC_LEX_INVALID, 1055 BC_LEX_INVALID, 1056 BC_LEX_INVALID, 1057 BC_LEX_INVALID, 1058 BC_LEX_EQ_NO_REG, 1059 #if BC_ENABLE_EXTRA_MATH 1060 BC_LEX_OP_LSHIFT, 1061 #else // BC_ENABLE_EXTRA_MATH 1062 BC_LEX_INVALID, 1063 #endif // BC_ENABLE_EXTRA_MATH 1064 BC_LEX_KW_IBASE, 1065 #if BC_ENABLE_EXTRA_MATH 1066 BC_LEX_KW_SEED, 1067 #else // BC_ENABLE_EXTRA_MATH 1068 BC_LEX_INVALID, 1069 #endif // BC_ENABLE_EXTRA_MATH 1070 BC_LEX_KW_SCALE, 1071 BC_LEX_LOAD_POP, 1072 BC_LEX_OP_BOOL_AND, 1073 BC_LEX_OP_BOOL_NOT, 1074 BC_LEX_KW_OBASE, 1075 BC_LEX_KW_STREAM, 1076 BC_LEX_NQUIT, 1077 BC_LEX_POP, 1078 BC_LEX_STORE_PUSH, 1079 BC_LEX_KW_MAXIBASE, 1080 BC_LEX_KW_MAXOBASE, 1081 BC_LEX_KW_MAXSCALE, 1082 #if BC_ENABLE_EXTRA_MATH 1083 BC_LEX_KW_MAXRAND, 1084 #else // BC_ENABLE_EXTRA_MATH 1085 BC_LEX_INVALID, 1086 #endif // BC_ENABLE_EXTRA_MATH 1087 BC_LEX_SCALE_FACTOR, 1088 BC_LEX_ARRAY_LENGTH, 1089 BC_LEX_KW_LENGTH, 1090 BC_LEX_INVALID, 1091 BC_LEX_INVALID, 1092 BC_LEX_INVALID, 1093 BC_LEX_OP_POWER, 1094 BC_LEX_NEG, 1095 BC_LEX_INVALID, 1096 BC_LEX_KW_ASCIIFY, 1097 BC_LEX_KW_ABS, 1098 BC_LEX_CLEAR_STACK, 1099 BC_LEX_DUPLICATE, 1100 BC_LEX_KW_ELSE, 1101 BC_LEX_PRINT_STACK, 1102 BC_LEX_INVALID, 1103 #if BC_ENABLE_EXTRA_MATH 1104 BC_LEX_OP_RSHIFT, 1105 #else // BC_ENABLE_EXTRA_MATH 1106 BC_LEX_INVALID, 1107 #endif // BC_ENABLE_EXTRA_MATH 1108 BC_LEX_STORE_IBASE, 1109 #if BC_ENABLE_EXTRA_MATH 1110 BC_LEX_STORE_SEED, 1111 #else // BC_ENABLE_EXTRA_MATH 1112 BC_LEX_INVALID, 1113 #endif // BC_ENABLE_EXTRA_MATH 1114 BC_LEX_STORE_SCALE, 1115 BC_LEX_LOAD, 1116 BC_LEX_OP_BOOL_OR, 1117 BC_LEX_PRINT_POP, 1118 BC_LEX_STORE_OBASE, 1119 BC_LEX_KW_PRINT, 1120 BC_LEX_KW_QUIT, 1121 BC_LEX_SWAP, 1122 BC_LEX_OP_ASSIGN, 1123 BC_LEX_INVALID, 1124 BC_LEX_INVALID, 1125 BC_LEX_KW_SQRT, 1126 BC_LEX_INVALID, 1127 BC_LEX_EXECUTE, 1128 BC_LEX_REG_STACK_LEVEL, 1129 BC_LEX_STACK_LEVEL, 1130 BC_LEX_LBRACE, 1131 BC_LEX_KW_MODEXP, 1132 BC_LEX_RBRACE, 1133 BC_LEX_KW_DIVMOD, 1134 BC_LEX_INVALID 1135 }; 1136 1137 /// A list of instructions that correspond to lex tokens. If an entry is 1138 /// BC_INST_INVALID, that lex token needs extra parsing in the dc parser. 1139 /// Otherwise, the token can trivially be replaced by the entry. This needs to 1140 /// be updated if the tokens change. 1141 const uchar dc_parse_insts[] = { 1142 BC_INST_INVALID, BC_INST_INVALID, 1143 #if BC_ENABLED 1144 BC_INST_INVALID, BC_INST_INVALID, 1145 #endif // BC_ENABLED 1146 BC_INST_INVALID, BC_INST_BOOL_NOT, 1147 #if BC_ENABLE_EXTRA_MATH 1148 BC_INST_TRUNC, 1149 #endif // BC_ENABLE_EXTRA_MATH 1150 BC_INST_POWER, BC_INST_MULTIPLY, BC_INST_DIVIDE, 1151 BC_INST_MODULUS, BC_INST_PLUS, BC_INST_MINUS, 1152 #if BC_ENABLE_EXTRA_MATH 1153 BC_INST_PLACES, BC_INST_LSHIFT, BC_INST_RSHIFT, 1154 #endif // BC_ENABLE_EXTRA_MATH 1155 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1156 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1157 BC_INST_BOOL_OR, BC_INST_BOOL_AND, 1158 #if BC_ENABLED 1159 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1160 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1161 #if BC_ENABLE_EXTRA_MATH 1162 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1163 #endif // BC_ENABLE_EXTRA_MATH 1164 #endif // BC_ENABLED 1165 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1166 BC_INST_REL_GT, BC_INST_REL_LT, BC_INST_INVALID, 1167 BC_INST_INVALID, BC_INST_INVALID, BC_INST_REL_GE, 1168 BC_INST_INVALID, BC_INST_REL_LE, BC_INST_INVALID, 1169 BC_INST_INVALID, BC_INST_INVALID, 1170 #if BC_ENABLED 1171 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1172 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1173 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1174 BC_INST_INVALID, BC_INST_INVALID, 1175 #endif // BC_ENABLED 1176 BC_INST_IBASE, BC_INST_OBASE, BC_INST_SCALE, 1177 #if BC_ENABLE_EXTRA_MATH 1178 BC_INST_SEED, 1179 #endif // BC_ENABLE_EXTRA_MATH 1180 BC_INST_LENGTH, BC_INST_PRINT, BC_INST_SQRT, 1181 BC_INST_ABS, 1182 #if BC_ENABLE_EXTRA_MATH 1183 BC_INST_IRAND, 1184 #endif // BC_ENABLE_EXTRA_MATH 1185 BC_INST_ASCIIFY, BC_INST_MODEXP, BC_INST_DIVMOD, 1186 BC_INST_QUIT, BC_INST_INVALID, 1187 #if BC_ENABLE_EXTRA_MATH 1188 BC_INST_RAND, 1189 #endif // BC_ENABLE_EXTRA_MATH 1190 BC_INST_MAXIBASE, BC_INST_MAXOBASE, BC_INST_MAXSCALE, 1191 #if BC_ENABLE_EXTRA_MATH 1192 BC_INST_MAXRAND, 1193 #endif // BC_ENABLE_EXTRA_MATH 1194 BC_INST_LINE_LENGTH, 1195 #if BC_ENABLED 1196 BC_INST_INVALID, 1197 #endif // BC_ENABLED 1198 BC_INST_LEADING_ZERO, BC_INST_PRINT_STREAM, BC_INST_INVALID, 1199 BC_INST_REL_EQ, BC_INST_INVALID, BC_INST_EXECUTE, 1200 BC_INST_PRINT_STACK, BC_INST_CLEAR_STACK, BC_INST_INVALID, 1201 BC_INST_STACK_LEN, BC_INST_DUPLICATE, BC_INST_SWAP, 1202 BC_INST_POP, BC_INST_INVALID, BC_INST_INVALID, 1203 BC_INST_INVALID, 1204 #if BC_ENABLE_EXTRA_MATH 1205 BC_INST_INVALID, 1206 #endif // BC_ENABLE_EXTRA_MATH 1207 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, 1208 BC_INST_PRINT_POP, BC_INST_NQUIT, BC_INST_EXEC_STACK_LEN, 1209 BC_INST_SCALE_FUNC, BC_INST_INVALID, 1210 }; 1211 #endif // DC_ENABLED 1212 1213 #endif // !BC_ENABLE_LIBRARY 1214 1215 #if BC_ENABLE_EXTRA_MATH 1216 1217 /// A constant for the rand multiplier. 1218 const BcRandState bc_rand_multiplier = BC_RAND_MULTIPLIER; 1219 1220 #endif // BC_ENABLE_EXTRA_MATH 1221 1222 // clang-format off 1223 1224 #if BC_LONG_BIT >= 64 1225 1226 /// A constant array for the max of a bigdig number as a BcDig array. 1227 const BcDig bc_num_bigdigMax[] = { 1228 709551616U, 1229 446744073U, 1230 18U, 1231 }; 1232 1233 /// A constant array for the max of 2 times a bigdig number as a BcDig array. 1234 const BcDig bc_num_bigdigMax2[] = { 1235 768211456U, 1236 374607431U, 1237 938463463U, 1238 282366920U, 1239 340U, 1240 }; 1241 1242 #else // BC_LONG_BIT >= 64 1243 1244 /// A constant array for the max of a bigdig number as a BcDig array. 1245 const BcDig bc_num_bigdigMax[] = { 1246 7296U, 1247 9496U, 1248 42U, 1249 }; 1250 1251 /// A constant array for the max of 2 times a bigdig number as a BcDig array. 1252 const BcDig bc_num_bigdigMax2[] = { 1253 1616U, 1254 955U, 1255 737U, 1256 6744U, 1257 1844U, 1258 }; 1259 1260 #endif // BC_LONG_BIT >= 64 1261 1262 // clang-format on 1263 1264 /// The size of the bigdig max array. 1265 const size_t bc_num_bigdigMax_size = sizeof(bc_num_bigdigMax) / sizeof(BcDig); 1266 1267 /// The size of the bigdig max times 2 array. 1268 const size_t bc_num_bigdigMax2_size = sizeof(bc_num_bigdigMax2) / sizeof(BcDig); 1269 1270 /// A string of digits for easy conversion from characters to digits. 1271 const char bc_num_hex_digits[] = "0123456789ABCDEF"; 1272 1273 // clang-format off 1274 1275 /// An array for easy conversion from exponent to power of 10. 1276 const BcBigDig bc_num_pow10[BC_BASE_DIGS + 1] = { 1277 1, 1278 10, 1279 100, 1280 1000, 1281 10000, 1282 #if BC_BASE_DIGS > 4 1283 100000, 1284 1000000, 1285 10000000, 1286 100000000, 1287 1000000000, 1288 #endif // BC_BASE_DIGS > 4 1289 }; 1290 1291 // clang-format on 1292 1293 #if !BC_ENABLE_LIBRARY 1294 1295 /// An array of functions for binary operators corresponding to the order of 1296 /// the instructions for the operators. 1297 const BcNumBinaryOp bc_program_ops[] = { 1298 bc_num_pow, bc_num_mul, bc_num_div, 1299 bc_num_mod, bc_num_add, bc_num_sub, 1300 #if BC_ENABLE_EXTRA_MATH 1301 bc_num_places, bc_num_lshift, bc_num_rshift, 1302 #endif // BC_ENABLE_EXTRA_MATH 1303 }; 1304 1305 /// An array of functions for binary operators allocation requests corresponding 1306 /// to the order of the instructions for the operators. 1307 const BcNumBinaryOpReq bc_program_opReqs[] = { 1308 bc_num_powReq, bc_num_mulReq, bc_num_divReq, 1309 bc_num_divReq, bc_num_addReq, bc_num_addReq, 1310 #if BC_ENABLE_EXTRA_MATH 1311 bc_num_placesReq, bc_num_placesReq, bc_num_placesReq, 1312 #endif // BC_ENABLE_EXTRA_MATH 1313 }; 1314 1315 /// An array of unary operator functions corresponding to the order of the 1316 /// instructions. 1317 const BcProgramUnary bc_program_unarys[] = { 1318 bc_program_negate, 1319 bc_program_not, 1320 #if BC_ENABLE_EXTRA_MATH 1321 bc_program_trunc, 1322 #endif // BC_ENABLE_EXTRA_MATH 1323 }; 1324 1325 /// A filename for when parsing expressions. 1326 const char bc_program_exprs_name[] = "<exprs>"; 1327 1328 /// A filename for when parsing stdin.. 1329 const char bc_program_stdin_name[] = "<stdin>"; 1330 1331 /// A ready message for SIGINT catching. 1332 const char bc_program_ready_msg[] = "ready for more input\n"; 1333 1334 /// The length of the ready message. 1335 const size_t bc_program_ready_msg_len = sizeof(bc_program_ready_msg) - 1; 1336 1337 /// A list of escape characters that a print statement should treat specially. 1338 const char bc_program_esc_chars[] = "ab\\efnqrt"; 1339 1340 /// A list of characters corresponding to the escape characters above. 1341 const char bc_program_esc_seqs[] = "\a\b\\\\\f\n\"\r\t"; 1342 1343 #endif // !BC_ENABLE_LIBRARY 1344