contrib/bc/src/data.c

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