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