blob: f85ab1aeac5850e0de2c782c67c6125e5df3cbe4 [file] [log] [blame]
Gavin Howard01055ba2018-11-03 11:00:21 -06001/* vi: set sw=4 ts=4: */
2/*
3 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
4 * Copyright (c) 2018 Gavin D. Howard and contributors.
Gavin Howard01055ba2018-11-03 11:00:21 -06005 */
6//config:config BC
7//config: bool "bc (45 kb; 49 kb when combined with dc)"
8//config: default y
9//config: help
10//config: bc is a command-line, arbitrary-precision calculator with a
11//config: Turing-complete language. See the GNU bc manual
12//config: (https://www.gnu.org/software/bc/manual/bc.html) and bc spec
Denys Vlasenko89e785a2018-12-13 16:35:52 +010013//config: (http://pubs.opengroup.org/onlinepubs/9699919799/utilities/bc.html).
Gavin Howard01055ba2018-11-03 11:00:21 -060014//config:
Denys Vlasenko89e785a2018-12-13 16:35:52 +010015//config: This bc has five differences to the GNU bc:
16//config: 1) The period (.) is a shortcut for "last", as in the BSD bc.
Gavin Howard01055ba2018-11-03 11:00:21 -060017//config: 2) Arrays are copied before being passed as arguments to
18//config: functions. This behavior is required by the bc spec.
19//config: 3) Arrays can be passed to the builtin "length" function to get
Denys Vlasenko89e785a2018-12-13 16:35:52 +010020//config: the number of elements in the array. This prints "1":
21//config: a[0] = 0; length(a[])
Gavin Howard01055ba2018-11-03 11:00:21 -060022//config: 4) The precedence of the boolean "not" operator (!) is equal to
Denys Vlasenko89e785a2018-12-13 16:35:52 +010023//config: that of the unary minus (-) negation operator. This still
Gavin Howard01055ba2018-11-03 11:00:21 -060024//config: allows POSIX-compliant scripts to work while somewhat
25//config: preserving expected behavior (versus C) and making parsing
26//config: easier.
Denys Vlasenko89e785a2018-12-13 16:35:52 +010027//config: 5) "read()" accepts expressions, not only numeric literals.
Gavin Howard01055ba2018-11-03 11:00:21 -060028//config:
29//config: Options:
Gavin Howard01055ba2018-11-03 11:00:21 -060030//config: -i --interactive force interactive mode
Denys Vlasenko89e785a2018-12-13 16:35:52 +010031//config: -q --quiet don't print version and copyright
32//config: -s --standard error if any non-POSIX extensions are used
33//config: -w --warn warn if any non-POSIX extensions are used
Gavin Howard01055ba2018-11-03 11:00:21 -060034//config: -l --mathlib use predefined math routines:
Denys Vlasenko89e785a2018-12-13 16:35:52 +010035//config: s(expr) sine in radians
36//config: c(expr) cosine in radians
37//config: a(expr) arctangent, returning radians
38//config: l(expr) natural log
39//config: e(expr) raises e to the power of expr
40//config: j(n, x) Bessel function of integer order n of x
Gavin Howard01055ba2018-11-03 11:00:21 -060041//config:
42//config:config DC
43//config: bool "dc (38 kb; 49 kb when combined with bc)"
44//config: default y
45//config: help
46//config: dc is a reverse-polish notation command-line calculator which
47//config: supports unlimited precision arithmetic. See the FreeBSD man page
48//config: (https://www.unix.com/man-page/FreeBSD/1/dc/) and GNU dc manual
Denys Vlasenko89e785a2018-12-13 16:35:52 +010049//config: (https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html).
Gavin Howard01055ba2018-11-03 11:00:21 -060050//config:
51//config: This dc has a few differences from the two above:
Denys Vlasenko89e785a2018-12-13 16:35:52 +010052//config: 1) When printing a byte stream (command "P"), this dc follows what
Gavin Howard01055ba2018-11-03 11:00:21 -060053//config: the FreeBSD dc does.
Denys Vlasenko89e785a2018-12-13 16:35:52 +010054//config: 2) Implements the GNU extensions for divmod ("~") and
Gavin Howard01055ba2018-11-03 11:00:21 -060055//config: modular exponentiation ("|").
Denys Vlasenko89e785a2018-12-13 16:35:52 +010056//config: 3) Implements all FreeBSD extensions, except for "J" and "M".
Gavin Howard01055ba2018-11-03 11:00:21 -060057//config: 4) Like the FreeBSD dc, this dc supports extended registers.
58//config: However, they are implemented differently. When it encounters
59//config: whitespace where a register should be, it skips the whitespace.
60//config: If the character following is not a lowercase letter, an error
61//config: is issued. Otherwise, the register name is parsed by the
62//config: following regex:
Denys Vlasenko89e785a2018-12-13 16:35:52 +010063//config: [a-z][a-z0-9_]*
Gavin Howard01055ba2018-11-03 11:00:21 -060064//config: This generally means that register names will be surrounded by
Denys Vlasenko89e785a2018-12-13 16:35:52 +010065//config: whitespace. Examples:
66//config: l idx s temp L index S temp2 < do_thing
Gavin Howard01055ba2018-11-03 11:00:21 -060067//config: Also note that, like the FreeBSD dc, extended registers are not
68//config: allowed unless the "-x" option is given.
69//config:
Denys Vlasenko9ca9ef22018-12-06 11:31:14 +010070//config:config FEATURE_DC_SMALL
71//config: bool "Minimal dc implementation (4.2 kb), not using bc code base"
72//config: depends on DC && !BC
Denys Vlasenko6e7c65f2018-12-08 19:34:35 +010073//config: default n
Denys Vlasenko9ca9ef22018-12-06 11:31:14 +010074//config:
75//config:config FEATURE_DC_LIBM
76//config: bool "Enable power and exp functions (requires libm)"
77//config: default y
78//config: depends on FEATURE_DC_SMALL
79//config: help
80//config: Enable power and exp functions.
81//config: NOTE: This will require libm to be present for linking.
82//config:
Gavin Howard01055ba2018-11-03 11:00:21 -060083//config:config FEATURE_BC_SIGNALS
Denys Vlasenko89e785a2018-12-13 16:35:52 +010084//config: bool "Interactive mode (+4kb)"
Gavin Howard01055ba2018-11-03 11:00:21 -060085//config: default y
Denys Vlasenko9ca9ef22018-12-06 11:31:14 +010086//config: depends on (BC || DC) && !FEATURE_DC_SMALL
Gavin Howard01055ba2018-11-03 11:00:21 -060087//config: help
Denys Vlasenko89e785a2018-12-13 16:35:52 +010088//config: Enable interactive mode: when started on a tty,
89//config: ^C interrupts execution and returns to command line,
90//config: errors also return to command line instead of exiting,
91//config: line editing with history is available.
92//config:
93//config: With this option off, input can still be taken from tty,
94//config: but all errors are fatal, ^C is fatal,
95//config: tty is treated exactly the same as any other
96//config: standard input (IOW: no line editing).
Gavin Howard01055ba2018-11-03 11:00:21 -060097//config:
98//config:config FEATURE_BC_LONG_OPTIONS
99//config: bool "Enable bc/dc long options"
100//config: default y
Denys Vlasenko9ca9ef22018-12-06 11:31:14 +0100101//config: depends on (BC || DC) && !FEATURE_DC_SMALL
Gavin Howard01055ba2018-11-03 11:00:21 -0600102//config: help
103//config: Enable long options for bc and dc.
104
105//applet:IF_BC(APPLET(bc, BB_DIR_USR_BIN, BB_SUID_DROP))
106//applet:IF_DC(APPLET(dc, BB_DIR_USR_BIN, BB_SUID_DROP))
107
108//kbuild:lib-$(CONFIG_BC) += bc.o
109//kbuild:lib-$(CONFIG_DC) += bc.o
110
Denys Vlasenko9721f6c2018-12-02 20:34:03 +0100111//See www.gnu.org/software/bc/manual/bc.html
Gavin Howard01055ba2018-11-03 11:00:21 -0600112//usage:#define bc_trivial_usage
Denys Vlasenko1a6a4822018-12-06 09:20:32 +0100113//usage: "[-sqliw] FILE..."
Gavin Howard01055ba2018-11-03 11:00:21 -0600114//usage:
Denys Vlasenko9721f6c2018-12-02 20:34:03 +0100115//usage:#define bc_full_usage "\n"
116//usage: "\nArbitrary precision calculator"
117//usage: "\n"
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100118///////: "\n -i Interactive" - has no effect for now
119//usage: "\n -q Quiet"
Denys Vlasenko9721f6c2018-12-02 20:34:03 +0100120//usage: "\n -l Load standard math library"
121//usage: "\n -s Be POSIX compatible"
Denys Vlasenko9721f6c2018-12-02 20:34:03 +0100122//usage: "\n -w Warn if extensions are used"
123///////: "\n -v Version"
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100124//usage: "\n"
Denys Vlasenko1a6a4822018-12-06 09:20:32 +0100125//usage: "\n$BC_LINE_LENGTH changes output width"
Gavin Howard01055ba2018-11-03 11:00:21 -0600126//usage:
127//usage:#define bc_example_usage
128//usage: "3 + 4.129\n"
129//usage: "1903 - 2893\n"
130//usage: "-129 * 213.28935\n"
131//usage: "12 / -1932\n"
132//usage: "12 % 12\n"
133//usage: "34 ^ 189\n"
134//usage: "scale = 13\n"
135//usage: "ibase = 2\n"
136//usage: "obase = A\n"
137//usage:
138//usage:#define dc_trivial_usage
Denys Vlasenko6e7c65f2018-12-08 19:34:35 +0100139//usage: IF_NOT_FEATURE_DC_SMALL("[-x] ")"[-eSCRIPT]... [-fFILE]... [FILE]..."
Gavin Howard01055ba2018-11-03 11:00:21 -0600140//usage:
Denys Vlasenko9ca9ef22018-12-06 11:31:14 +0100141//usage:#define dc_full_usage "\n"
142//usage: "\nTiny RPN calculator. Operations:"
Denys Vlasenko6e7c65f2018-12-08 19:34:35 +0100143//usage: "\n+, -, *, /, %, ~, ^," IF_NOT_FEATURE_DC_SMALL(" |,")
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100144//usage: "\np - print top of the stack (without popping)"
145//usage: "\nf - print entire stack"
146//usage: "\nk - pop the value and set the precision"
147//usage: "\ni - pop the value and set input radix"
148//usage: "\no - pop the value and set output radix"
149//usage: "\nExamples: dc -e'2 2 + p' -> 4, dc -e'8 8 * 2 2 + / p' -> 16"
Gavin Howard01055ba2018-11-03 11:00:21 -0600150//usage:
151//usage:#define dc_example_usage
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100152//usage: "$ dc -e'2 2 + p'\n"
Gavin Howard01055ba2018-11-03 11:00:21 -0600153//usage: "4\n"
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100154//usage: "$ dc -e'8 8 \\* 2 2 + / p'\n"
Gavin Howard01055ba2018-11-03 11:00:21 -0600155//usage: "16\n"
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100156//usage: "$ dc -e'0 1 & p'\n"
Gavin Howard01055ba2018-11-03 11:00:21 -0600157//usage: "0\n"
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100158//usage: "$ dc -e'0 1 | p'\n"
Gavin Howard01055ba2018-11-03 11:00:21 -0600159//usage: "1\n"
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100160//usage: "$ echo '72 9 / 8 * p' | dc\n"
Gavin Howard01055ba2018-11-03 11:00:21 -0600161//usage: "64\n"
162
163#include "libbb.h"
Denys Vlasenko95f93bd2018-12-06 10:29:12 +0100164#include "common_bufsiz.h"
Gavin Howard01055ba2018-11-03 11:00:21 -0600165
Denys Vlasenko9ca9ef22018-12-06 11:31:14 +0100166#if ENABLE_FEATURE_DC_SMALL
167# include "dc.c"
168#else
169
Denys Vlasenko2ea53a42018-12-14 17:51:17 +0100170#define DEBUG_LEXER 0
Denys Vlasenko99b37622018-12-15 20:06:59 +0100171#define DEBUG_EXEC 0
Denys Vlasenko2ea53a42018-12-14 17:51:17 +0100172
173#if DEBUG_LEXER
Denys Vlasenkod1d29b42018-12-16 16:03:03 +0100174static uint8_t lex_indent;
Denys Vlasenko2ea53a42018-12-14 17:51:17 +0100175#define dbg_lex(...) \
176 do { \
177 fprintf(stderr, "%*s", lex_indent, ""); \
178 bb_error_msg(__VA_ARGS__); \
179 } while (0)
180#define dbg_lex_enter(...) \
181 do { \
182 dbg_lex(__VA_ARGS__); \
183 lex_indent++; \
184 } while (0)
185#define dbg_lex_done(...) \
186 do { \
187 lex_indent--; \
188 dbg_lex(__VA_ARGS__); \
189 } while (0)
Denys Vlasenko0a238142018-12-14 16:48:34 +0100190#else
Denys Vlasenko2ea53a42018-12-14 17:51:17 +0100191# define dbg_lex(...) ((void)0)
192# define dbg_lex_enter(...) ((void)0)
193# define dbg_lex_done(...) ((void)0)
Denys Vlasenko0a238142018-12-14 16:48:34 +0100194#endif
195
Denys Vlasenko99b37622018-12-15 20:06:59 +0100196#if DEBUG_EXEC
197# define dbg_exec(...) bb_error_msg(__VA_ARGS__)
198#else
199# define dbg_exec(...) ((void)0)
200#endif
201
Gavin Howard01055ba2018-11-03 11:00:21 -0600202typedef enum BcStatus {
Denys Vlasenko60cf7472018-12-04 20:05:28 +0100203 BC_STATUS_SUCCESS = 0,
204 BC_STATUS_FAILURE = 1,
Denys Vlasenkob402ff82018-12-11 15:45:15 +0100205 BC_STATUS_PARSE_EMPTY_EXP = 2, // bc_parse_expr_empty_ok() uses this
Gavin Howard01055ba2018-11-03 11:00:21 -0600206} BcStatus;
207
Gavin Howard01055ba2018-11-03 11:00:21 -0600208#define BC_VEC_INVALID_IDX ((size_t) -1)
209#define BC_VEC_START_CAP (1 << 5)
210
Denys Vlasenko5ba55f12018-12-10 15:37:14 +0100211typedef void (*BcVecFree)(void *) FAST_FUNC;
Gavin Howard01055ba2018-11-03 11:00:21 -0600212
213typedef struct BcVec {
214 char *v;
215 size_t len;
216 size_t cap;
217 size_t size;
218 BcVecFree dtor;
219} BcVec;
220
Gavin Howard01055ba2018-11-03 11:00:21 -0600221typedef signed char BcDig;
222
223typedef struct BcNum {
224 BcDig *restrict num;
225 size_t rdx;
226 size_t len;
227 size_t cap;
228 bool neg;
229} BcNum;
230
Denys Vlasenko2fa11b62018-12-06 12:34:39 +0100231#define BC_NUM_MIN_BASE ((unsigned long) 2)
232#define BC_NUM_MAX_IBASE ((unsigned long) 16)
233// larger value might speed up BIGNUM calculations a bit:
234#define BC_NUM_DEF_SIZE (16)
235#define BC_NUM_PRINT_WIDTH (69)
Gavin Howard01055ba2018-11-03 11:00:21 -0600236
Denys Vlasenko2fa11b62018-12-06 12:34:39 +0100237#define BC_NUM_KARATSUBA_LEN (32)
Gavin Howard01055ba2018-11-03 11:00:21 -0600238
Gavin Howard01055ba2018-11-03 11:00:21 -0600239typedef enum BcInst {
240
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100241#if ENABLE_BC
Gavin Howard01055ba2018-11-03 11:00:21 -0600242 BC_INST_INC_PRE,
243 BC_INST_DEC_PRE,
244 BC_INST_INC_POST,
245 BC_INST_DEC_POST,
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100246#endif
Gavin Howard01055ba2018-11-03 11:00:21 -0600247
248 BC_INST_NEG,
249
250 BC_INST_POWER,
251 BC_INST_MULTIPLY,
252 BC_INST_DIVIDE,
253 BC_INST_MODULUS,
254 BC_INST_PLUS,
255 BC_INST_MINUS,
256
257 BC_INST_REL_EQ,
258 BC_INST_REL_LE,
259 BC_INST_REL_GE,
260 BC_INST_REL_NE,
261 BC_INST_REL_LT,
262 BC_INST_REL_GT,
263
264 BC_INST_BOOL_NOT,
265 BC_INST_BOOL_OR,
266 BC_INST_BOOL_AND,
267
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100268#if ENABLE_BC
Gavin Howard01055ba2018-11-03 11:00:21 -0600269 BC_INST_ASSIGN_POWER,
270 BC_INST_ASSIGN_MULTIPLY,
271 BC_INST_ASSIGN_DIVIDE,
272 BC_INST_ASSIGN_MODULUS,
273 BC_INST_ASSIGN_PLUS,
274 BC_INST_ASSIGN_MINUS,
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100275#endif
Gavin Howard01055ba2018-11-03 11:00:21 -0600276 BC_INST_ASSIGN,
277
278 BC_INST_NUM,
279 BC_INST_VAR,
280 BC_INST_ARRAY_ELEM,
281 BC_INST_ARRAY,
282
283 BC_INST_SCALE_FUNC,
284 BC_INST_IBASE,
285 BC_INST_SCALE,
286 BC_INST_LAST,
287 BC_INST_LENGTH,
288 BC_INST_READ,
289 BC_INST_OBASE,
290 BC_INST_SQRT,
291
292 BC_INST_PRINT,
293 BC_INST_PRINT_POP,
294 BC_INST_STR,
295 BC_INST_PRINT_STR,
296
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100297#if ENABLE_BC
Gavin Howard01055ba2018-11-03 11:00:21 -0600298 BC_INST_JUMP,
299 BC_INST_JUMP_ZERO,
300
301 BC_INST_CALL,
302
303 BC_INST_RET,
304 BC_INST_RET0,
305
306 BC_INST_HALT,
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100307#endif
Gavin Howard01055ba2018-11-03 11:00:21 -0600308
309 BC_INST_POP,
310 BC_INST_POP_EXEC,
311
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100312#if ENABLE_DC
Gavin Howard01055ba2018-11-03 11:00:21 -0600313 BC_INST_MODEXP,
314 BC_INST_DIVMOD,
315
316 BC_INST_EXECUTE,
317 BC_INST_EXEC_COND,
318
319 BC_INST_ASCIIFY,
320 BC_INST_PRINT_STREAM,
321
322 BC_INST_PRINT_STACK,
323 BC_INST_CLEAR_STACK,
324 BC_INST_STACK_LEN,
325 BC_INST_DUPLICATE,
326 BC_INST_SWAP,
327
328 BC_INST_LOAD,
329 BC_INST_PUSH_VAR,
330 BC_INST_PUSH_TO_VAR,
331
332 BC_INST_QUIT,
333 BC_INST_NQUIT,
334
335 BC_INST_INVALID = -1,
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100336#endif
Gavin Howard01055ba2018-11-03 11:00:21 -0600337
338} BcInst;
339
340typedef struct BcId {
341 char *name;
342 size_t idx;
343} BcId;
344
345typedef struct BcFunc {
346 BcVec code;
347 BcVec labels;
348 size_t nparams;
349 BcVec autos;
350} BcFunc;
351
352typedef enum BcResultType {
353
354 BC_RESULT_TEMP,
355
356 BC_RESULT_VAR,
357 BC_RESULT_ARRAY_ELEM,
358 BC_RESULT_ARRAY,
359
360 BC_RESULT_STR,
361
362 BC_RESULT_IBASE,
363 BC_RESULT_SCALE,
364 BC_RESULT_LAST,
365
366 // These are between to calculate ibase, obase, and last from instructions.
367 BC_RESULT_CONSTANT,
368 BC_RESULT_ONE,
369
370 BC_RESULT_OBASE,
371
372} BcResultType;
373
374typedef union BcResultData {
375 BcNum n;
376 BcVec v;
377 BcId id;
378} BcResultData;
379
380typedef struct BcResult {
381 BcResultType t;
382 BcResultData d;
383} BcResult;
384
385typedef struct BcInstPtr {
386 size_t func;
387 size_t idx;
388 size_t len;
389} BcInstPtr;
390
Gavin Howard01055ba2018-11-03 11:00:21 -0600391// BC_LEX_NEG is not used in lexing; it is only for parsing.
392typedef enum BcLexType {
393
394 BC_LEX_EOF,
395 BC_LEX_INVALID,
396
397 BC_LEX_OP_INC,
398 BC_LEX_OP_DEC,
399
400 BC_LEX_NEG,
401
402 BC_LEX_OP_POWER,
403 BC_LEX_OP_MULTIPLY,
404 BC_LEX_OP_DIVIDE,
405 BC_LEX_OP_MODULUS,
406 BC_LEX_OP_PLUS,
407 BC_LEX_OP_MINUS,
408
409 BC_LEX_OP_REL_EQ,
410 BC_LEX_OP_REL_LE,
411 BC_LEX_OP_REL_GE,
412 BC_LEX_OP_REL_NE,
413 BC_LEX_OP_REL_LT,
414 BC_LEX_OP_REL_GT,
415
416 BC_LEX_OP_BOOL_NOT,
417 BC_LEX_OP_BOOL_OR,
418 BC_LEX_OP_BOOL_AND,
419
420 BC_LEX_OP_ASSIGN_POWER,
421 BC_LEX_OP_ASSIGN_MULTIPLY,
422 BC_LEX_OP_ASSIGN_DIVIDE,
423 BC_LEX_OP_ASSIGN_MODULUS,
424 BC_LEX_OP_ASSIGN_PLUS,
425 BC_LEX_OP_ASSIGN_MINUS,
426 BC_LEX_OP_ASSIGN,
427
428 BC_LEX_NLINE,
429 BC_LEX_WHITESPACE,
430
431 BC_LEX_LPAREN,
432 BC_LEX_RPAREN,
433
434 BC_LEX_LBRACKET,
435 BC_LEX_COMMA,
436 BC_LEX_RBRACKET,
437
Denys Vlasenko9dc5d082018-12-16 18:43:51 +0100438 BC_LEX_LBRACE, // '{' is 0x7B, '}' is 0x7D,
Gavin Howard01055ba2018-11-03 11:00:21 -0600439 BC_LEX_SCOLON,
Denys Vlasenko9dc5d082018-12-16 18:43:51 +0100440 BC_LEX_RBRACE, // should be LBRACE+2: code uses (c - '{' + BC_LEX_LBRACE)
Gavin Howard01055ba2018-11-03 11:00:21 -0600441
442 BC_LEX_STR,
443 BC_LEX_NAME,
444 BC_LEX_NUMBER,
445
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100446 BC_LEX_KEY_1st_keyword,
447 BC_LEX_KEY_AUTO = BC_LEX_KEY_1st_keyword,
Gavin Howard01055ba2018-11-03 11:00:21 -0600448 BC_LEX_KEY_BREAK,
449 BC_LEX_KEY_CONTINUE,
450 BC_LEX_KEY_DEFINE,
451 BC_LEX_KEY_ELSE,
452 BC_LEX_KEY_FOR,
453 BC_LEX_KEY_HALT,
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100454 // code uses "type - BC_LEX_KEY_IBASE + BC_INST_IBASE" construct,
455 BC_LEX_KEY_IBASE, // relative order should match for: BC_INST_IBASE
Gavin Howard01055ba2018-11-03 11:00:21 -0600456 BC_LEX_KEY_IF,
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100457 BC_LEX_KEY_LAST, // relative order should match for: BC_INST_LAST
Gavin Howard01055ba2018-11-03 11:00:21 -0600458 BC_LEX_KEY_LENGTH,
459 BC_LEX_KEY_LIMITS,
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100460 BC_LEX_KEY_OBASE, // relative order should match for: BC_INST_OBASE
Gavin Howard01055ba2018-11-03 11:00:21 -0600461 BC_LEX_KEY_PRINT,
462 BC_LEX_KEY_QUIT,
463 BC_LEX_KEY_READ,
464 BC_LEX_KEY_RETURN,
465 BC_LEX_KEY_SCALE,
466 BC_LEX_KEY_SQRT,
467 BC_LEX_KEY_WHILE,
468
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100469#if ENABLE_DC
Gavin Howard01055ba2018-11-03 11:00:21 -0600470 BC_LEX_EQ_NO_REG,
471 BC_LEX_OP_MODEXP,
472 BC_LEX_OP_DIVMOD,
473
474 BC_LEX_COLON,
475 BC_LEX_ELSE,
476 BC_LEX_EXECUTE,
477 BC_LEX_PRINT_STACK,
478 BC_LEX_CLEAR_STACK,
479 BC_LEX_STACK_LEVEL,
480 BC_LEX_DUPLICATE,
481 BC_LEX_SWAP,
482 BC_LEX_POP,
483
484 BC_LEX_ASCIIFY,
485 BC_LEX_PRINT_STREAM,
486
487 BC_LEX_STORE_IBASE,
488 BC_LEX_STORE_SCALE,
489 BC_LEX_LOAD,
490 BC_LEX_LOAD_POP,
491 BC_LEX_STORE_PUSH,
492 BC_LEX_STORE_OBASE,
493 BC_LEX_PRINT_POP,
494 BC_LEX_NQUIT,
495 BC_LEX_SCALE_FACTOR,
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100496#endif
Gavin Howard01055ba2018-11-03 11:00:21 -0600497} BcLexType;
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100498// must match order of BC_LEX_KEY_foo etc above
499#if ENABLE_BC
500struct BcLexKeyword {
501 char name8[8];
502};
Denys Vlasenkod00d2f92018-12-06 12:59:40 +0100503#define BC_LEX_KW_ENTRY(a, b) \
504 { .name8 = a /*, .posix = b */ }
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100505static const struct BcLexKeyword bc_lex_kws[20] = {
Denys Vlasenkod00d2f92018-12-06 12:59:40 +0100506 BC_LEX_KW_ENTRY("auto" , 1), // 0
507 BC_LEX_KW_ENTRY("break" , 1), // 1
508 BC_LEX_KW_ENTRY("continue", 0), // 2 note: this one has no terminating NUL
509 BC_LEX_KW_ENTRY("define" , 1), // 3
Denys Vlasenkod00d2f92018-12-06 12:59:40 +0100510 BC_LEX_KW_ENTRY("else" , 0), // 4
511 BC_LEX_KW_ENTRY("for" , 1), // 5
512 BC_LEX_KW_ENTRY("halt" , 0), // 6
513 BC_LEX_KW_ENTRY("ibase" , 1), // 7
Denys Vlasenkod00d2f92018-12-06 12:59:40 +0100514 BC_LEX_KW_ENTRY("if" , 1), // 8
515 BC_LEX_KW_ENTRY("last" , 0), // 9
516 BC_LEX_KW_ENTRY("length" , 1), // 10
517 BC_LEX_KW_ENTRY("limits" , 0), // 11
Denys Vlasenkod00d2f92018-12-06 12:59:40 +0100518 BC_LEX_KW_ENTRY("obase" , 1), // 12
519 BC_LEX_KW_ENTRY("print" , 0), // 13
520 BC_LEX_KW_ENTRY("quit" , 1), // 14
521 BC_LEX_KW_ENTRY("read" , 0), // 15
Denys Vlasenkod00d2f92018-12-06 12:59:40 +0100522 BC_LEX_KW_ENTRY("return" , 1), // 16
523 BC_LEX_KW_ENTRY("scale" , 1), // 17
524 BC_LEX_KW_ENTRY("sqrt" , 1), // 18
525 BC_LEX_KW_ENTRY("while" , 1), // 19
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100526};
Denys Vlasenkod00d2f92018-12-06 12:59:40 +0100527#undef BC_LEX_KW_ENTRY
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100528enum {
529 POSIX_KWORD_MASK = 0
Denys Vlasenko82269122018-12-14 16:30:56 +0100530 | (1 << 0) // 0
531 | (1 << 1) // 1
532 | (0 << 2) // 2
533 | (1 << 3) // 3
534 | (0 << 4) // 4
535 | (1 << 5) // 5
536 | (0 << 6) // 6
537 | (1 << 7) // 7
538 | (1 << 8) // 8
539 | (0 << 9) // 9
540 | (1 << 10) // 10
541 | (0 << 11) // 11
542 | (1 << 12) // 12
543 | (0 << 13) // 13
544 | (1 << 14) // 14
545 | (0 << 15) // 15
546 | (1 << 16) // 16
547 | (1 << 17) // 17
548 | (1 << 18) // 18
549 | (1 << 19) // 19
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100550};
Denys Vlasenkod00d2f92018-12-06 12:59:40 +0100551#define bc_lex_kws_POSIX(i) ((1 << (i)) & POSIX_KWORD_MASK)
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +0100552#endif
Gavin Howard01055ba2018-11-03 11:00:21 -0600553
Denys Vlasenko9a34e892018-12-12 13:58:55 +0100554#if ENABLE_FEATURE_BC_SIGNALS || ENABLE_FEATURE_CLEAN_UP
555# define BC_STATUS BcStatus
556#else
557# define BC_STATUS void
558#endif
559
Gavin Howard01055ba2018-11-03 11:00:21 -0600560typedef struct BcLex {
Gavin Howard01055ba2018-11-03 11:00:21 -0600561 const char *buf;
562 size_t i;
563 size_t line;
Gavin Howard01055ba2018-11-03 11:00:21 -0600564 size_t len;
565 bool newline;
Gavin Howard01055ba2018-11-03 11:00:21 -0600566 struct {
567 BcLexType t;
568 BcLexType last;
569 BcVec v;
570 } t;
Gavin Howard01055ba2018-11-03 11:00:21 -0600571} BcLex;
572
Denys Vlasenko0154d782018-12-14 23:32:51 +0100573#define BC_PARSE_STREND ((char) UCHAR_MAX)
Gavin Howard01055ba2018-11-03 11:00:21 -0600574
Denys Vlasenko0154d782018-12-14 23:32:51 +0100575#define BC_PARSE_REL (1 << 0)
576#define BC_PARSE_PRINT (1 << 1)
577#define BC_PARSE_NOCALL (1 << 2)
578#define BC_PARSE_NOREAD (1 << 3)
579#define BC_PARSE_ARRAY (1 << 4)
Gavin Howard01055ba2018-11-03 11:00:21 -0600580
Gavin Howard01055ba2018-11-03 11:00:21 -0600581typedef struct BcParse {
Gavin Howard01055ba2018-11-03 11:00:21 -0600582 BcLex l;
583
Gavin Howard01055ba2018-11-03 11:00:21 -0600584 BcVec exits;
585 BcVec conds;
586
587 BcVec ops;
588
Gavin Howard01055ba2018-11-03 11:00:21 -0600589 BcFunc *func;
590 size_t fidx;
591
Denys Vlasenkoe9519e42018-12-16 17:06:07 +0100592 size_t in_funcdef;
Gavin Howard01055ba2018-11-03 11:00:21 -0600593} BcParse;
594
Gavin Howard01055ba2018-11-03 11:00:21 -0600595typedef struct BcProgram {
596
597 size_t len;
598 size_t scale;
599
600 BcNum ib;
601 size_t ib_t;
602 BcNum ob;
603 size_t ob_t;
604
605 BcNum hexb;
606
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100607#if ENABLE_DC
Gavin Howard01055ba2018-11-03 11:00:21 -0600608 BcNum strmb;
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100609#endif
Gavin Howard01055ba2018-11-03 11:00:21 -0600610
611 BcVec results;
612 BcVec stack;
613
614 BcVec fns;
615 BcVec fn_map;
616
617 BcVec vars;
618 BcVec var_map;
619
620 BcVec arrs;
621 BcVec arr_map;
622
623 BcVec strs;
624 BcVec consts;
625
626 const char *file;
627
628 BcNum last;
629 BcNum zero;
630 BcNum one;
631
632 size_t nchars;
633
Gavin Howard01055ba2018-11-03 11:00:21 -0600634} BcProgram;
635
636#define BC_PROG_STACK(s, n) ((s)->len >= ((size_t) n))
637
638#define BC_PROG_MAIN (0)
639#define BC_PROG_READ (1)
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100640#if ENABLE_DC
Gavin Howard01055ba2018-11-03 11:00:21 -0600641#define BC_PROG_REQ_FUNCS (2)
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100642#endif
Gavin Howard01055ba2018-11-03 11:00:21 -0600643
644#define BC_PROG_STR(n) (!(n)->num && !(n)->cap)
645#define BC_PROG_NUM(r, n) \
646 ((r)->t != BC_RESULT_ARRAY && (r)->t != BC_RESULT_STR && !BC_PROG_STR(n))
647
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100648#define BC_FLAG_W (1 << 0)
649#define BC_FLAG_V (1 << 1)
650#define BC_FLAG_S (1 << 2)
651#define BC_FLAG_Q (1 << 3)
652#define BC_FLAG_L (1 << 4)
653#define BC_FLAG_I (1 << 5)
654#define DC_FLAG_X (1 << 6)
Gavin Howard01055ba2018-11-03 11:00:21 -0600655
656#define BC_MAX(a, b) ((a) > (b) ? (a) : (b))
657#define BC_MIN(a, b) ((a) < (b) ? (a) : (b))
658
Denys Vlasenko64074a12018-12-07 15:50:14 +0100659#define BC_MAX_OBASE ((unsigned) 999)
660#define BC_MAX_DIM ((unsigned) INT_MAX)
661#define BC_MAX_SCALE ((unsigned) UINT_MAX)
662#define BC_MAX_STRING ((unsigned) UINT_MAX - 1)
663#define BC_MAX_NUM BC_MAX_STRING
664// Unused apart from "limits" message. Just show a "biggish number" there.
665//#define BC_MAX_NAME BC_MAX_STRING
666//#define BC_MAX_EXP ((unsigned long) LONG_MAX)
667//#define BC_MAX_VARS ((unsigned long) SIZE_MAX - 1)
668#define BC_MAX_NAME_STR "999999999"
669#define BC_MAX_EXP_STR "999999999"
670#define BC_MAX_VARS_STR "999999999"
671
672#define BC_MAX_OBASE_STR "999"
673
674#if INT_MAX == 2147483647
675# define BC_MAX_DIM_STR "2147483647"
676#elif INT_MAX == 9223372036854775807
677# define BC_MAX_DIM_STR "9223372036854775807"
678#else
679# error Strange INT_MAX
680#endif
681
682#if UINT_MAX == 4294967295
683# define BC_MAX_SCALE_STR "4294967295"
684# define BC_MAX_STRING_STR "4294967294"
685#elif UINT_MAX == 18446744073709551615
686# define BC_MAX_SCALE_STR "18446744073709551615"
687# define BC_MAX_STRING_STR "18446744073709551614"
688#else
689# error Strange UINT_MAX
690#endif
691#define BC_MAX_NUM_STR BC_MAX_STRING_STR
Gavin Howard01055ba2018-11-03 11:00:21 -0600692
Denys Vlasenko6d9146a2018-12-02 15:48:37 +0100693struct globals {
Denys Vlasenko1a6a4822018-12-06 09:20:32 +0100694 IF_FEATURE_BC_SIGNALS(smallint ttyin;)
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +0100695 IF_FEATURE_CLEAN_UP(smallint exiting;)
Denys Vlasenko69171dc2018-12-12 00:29:24 +0100696 smallint in_read;
Denys Vlasenkod1d29b42018-12-16 16:03:03 +0100697 smallint use_stdin;
Gavin Howard01055ba2018-11-03 11:00:21 -0600698
699 BcParse prs;
700 BcProgram prog;
701
Denys Vlasenko5318f812018-12-05 17:48:01 +0100702 // For error messages. Can be set to current parsed line,
703 // or [TODO] to current executing line (can be before last parsed one)
704 unsigned err_line;
705
Gavin Howard01055ba2018-11-03 11:00:21 -0600706 BcVec files;
Denys Vlasenkod1d29b42018-12-16 16:03:03 +0100707 BcVec stdin_buffer;
Gavin Howard01055ba2018-11-03 11:00:21 -0600708
709 char *env_args;
Denys Vlasenko95f93bd2018-12-06 10:29:12 +0100710
711#if ENABLE_FEATURE_EDITING
712 line_input_t *line_input_state;
713#endif
Denys Vlasenko6d9146a2018-12-02 15:48:37 +0100714} FIX_ALIASING;
715#define G (*ptr_to_globals)
716#define INIT_G() do { \
717 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
718} while (0)
Denys Vlasenkoe873ff92018-12-06 00:29:22 +0100719#define FREE_G() do { \
720 FREE_PTR_TO_GLOBALS(); \
721} while (0)
Denys Vlasenkod70d4a02018-12-04 20:58:40 +0100722#define G_posix (ENABLE_BC && (option_mask32 & BC_FLAG_S))
723#define G_warn (ENABLE_BC && (option_mask32 & BC_FLAG_W))
Denys Vlasenko6d0be102018-12-06 18:41:59 +0100724#define G_exreg (ENABLE_DC && (option_mask32 & DC_FLAG_X))
Denys Vlasenko1a6a4822018-12-06 09:20:32 +0100725#if ENABLE_FEATURE_BC_SIGNALS
Denys Vlasenkob9c321d2018-12-07 12:41:42 +0100726# define G_interrupt bb_got_signal
727# define G_ttyin G.ttyin
Denys Vlasenko1a6a4822018-12-06 09:20:32 +0100728#else
Denys Vlasenkob9c321d2018-12-07 12:41:42 +0100729# define G_interrupt 0
730# define G_ttyin 0
Denys Vlasenko1a6a4822018-12-06 09:20:32 +0100731#endif
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +0100732#if ENABLE_FEATURE_CLEAN_UP
733# define G_exiting G.exiting
734#else
735# define G_exiting 0
736#endif
Denys Vlasenko00d77792018-11-30 23:13:42 +0100737#define IS_BC (ENABLE_BC && (!ENABLE_DC || applet_name[0] == 'b'))
Denys Vlasenko40534bb2018-12-13 16:59:24 +0100738#define IS_DC (ENABLE_DC && (!ENABLE_BC || applet_name[0] != 'b'))
Denys Vlasenko00d77792018-11-30 23:13:42 +0100739
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100740#if ENABLE_BC
Gavin Howard01055ba2018-11-03 11:00:21 -0600741
Denys Vlasenkobcb62a72018-12-05 20:17:48 +0100742// This is a bit array that corresponds to token types. An entry is
Gavin Howard01055ba2018-11-03 11:00:21 -0600743// true if the token is valid in an expression, false otherwise.
Denys Vlasenkobcb62a72018-12-05 20:17:48 +0100744enum {
745 BC_PARSE_EXPRS_BITS = 0
746 + ((uint64_t)((0 << 0)+(0 << 1)+(1 << 2)+(1 << 3)+(1 << 4)+(1 << 5)+(1 << 6)+(1 << 7)) << (0*8))
747 + ((uint64_t)((1 << 0)+(1 << 1)+(1 << 2)+(1 << 3)+(1 << 4)+(1 << 5)+(1 << 6)+(1 << 7)) << (1*8))
748 + ((uint64_t)((1 << 0)+(1 << 1)+(1 << 2)+(1 << 3)+(1 << 4)+(1 << 5)+(1 << 6)+(1 << 7)) << (2*8))
749 + ((uint64_t)((1 << 0)+(1 << 1)+(1 << 2)+(0 << 3)+(0 << 4)+(1 << 5)+(1 << 6)+(0 << 7)) << (3*8))
750 + ((uint64_t)((0 << 0)+(0 << 1)+(0 << 2)+(0 << 3)+(0 << 4)+(0 << 5)+(1 << 6)+(1 << 7)) << (4*8))
751 + ((uint64_t)((0 << 0)+(0 << 1)+(0 << 2)+(0 << 3)+(0 << 4)+(0 << 5)+(0 << 6)+(1 << 7)) << (5*8))
752 + ((uint64_t)((0 << 0)+(1 << 1)+(1 << 2)+(1 << 3)+(1 << 4)+(0 << 5)+(0 << 6)+(1 << 7)) << (6*8))
753 + ((uint64_t)((0 << 0)+(1 << 1)+(1 << 2)+(0 << 3) ) << (7*8))
Gavin Howard01055ba2018-11-03 11:00:21 -0600754};
Denys Vlasenkobcb62a72018-12-05 20:17:48 +0100755static ALWAYS_INLINE long bc_parse_exprs(unsigned i)
756{
757#if ULONG_MAX > 0xffffffff
758 // 64-bit version (will not work correctly for 32-bit longs!)
759 return BC_PARSE_EXPRS_BITS & (1UL << i);
760#else
761 // 32-bit version
762 unsigned long m = (uint32_t)BC_PARSE_EXPRS_BITS;
763 if (i >= 32) {
764 m = (uint32_t)(BC_PARSE_EXPRS_BITS >> 32);
765 i &= 31;
766 }
767 return m & (1UL << i);
768#endif
769}
Gavin Howard01055ba2018-11-03 11:00:21 -0600770
771// This is an array of data for operators that correspond to token types.
Denys Vlasenko65437582018-12-05 19:37:19 +0100772static const uint8_t bc_parse_ops[] = {
773#define OP(p,l) ((int)(l) * 0x10 + (p))
Denys Vlasenkobcb62a72018-12-05 20:17:48 +0100774 OP(0, false), OP( 0, false ), // inc dec
775 OP(1, false), // neg
Denys Vlasenko65437582018-12-05 19:37:19 +0100776 OP(2, false),
Denys Vlasenkobcb62a72018-12-05 20:17:48 +0100777 OP(3, true ), OP( 3, true ), OP( 3, true ), // pow mul div
778 OP(4, true ), OP( 4, true ), // mod + -
779 OP(6, true ), OP( 6, true ), OP( 6, true ), OP( 6, true ), OP( 6, true ), OP( 6, true ), // == <= >= != < >
780 OP(1, false), // not
781 OP(7, true ), OP( 7, true ), // or and
782 OP(5, false), OP( 5, false ), OP( 5, false ), OP( 5, false ), OP( 5, false ), // ^= *= /= %= +=
783 OP(5, false), OP( 5, false ), // -= =
Denys Vlasenko65437582018-12-05 19:37:19 +0100784#undef OP
Gavin Howard01055ba2018-11-03 11:00:21 -0600785};
Denys Vlasenko65437582018-12-05 19:37:19 +0100786#define bc_parse_op_PREC(i) (bc_parse_ops[i] & 0x0f)
787#define bc_parse_op_LEFT(i) (bc_parse_ops[i] & 0x10)
Gavin Howard01055ba2018-11-03 11:00:21 -0600788
Denys Vlasenko18c6b542018-12-07 12:57:32 +0100789// Byte array of up to 4 BC_LEX's, packed into 32-bit word
790typedef uint32_t BcParseNext;
791
Gavin Howard01055ba2018-11-03 11:00:21 -0600792// These identify what tokens can come after expressions in certain cases.
Denys Vlasenko18c6b542018-12-07 12:57:32 +0100793enum {
794#define BC_PARSE_NEXT4(a,b,c,d) ( (a) | ((b)<<8) | ((c)<<16) | ((((d)|0x80)<<24)) )
795#define BC_PARSE_NEXT2(a,b) BC_PARSE_NEXT4(a,b,0xff,0xff)
796#define BC_PARSE_NEXT1(a) BC_PARSE_NEXT4(a,0xff,0xff,0xff)
797 bc_parse_next_expr = BC_PARSE_NEXT4(BC_LEX_NLINE, BC_LEX_SCOLON, BC_LEX_RBRACE, BC_LEX_EOF),
798 bc_parse_next_param = BC_PARSE_NEXT2(BC_LEX_RPAREN, BC_LEX_COMMA),
799 bc_parse_next_print = BC_PARSE_NEXT4(BC_LEX_COMMA, BC_LEX_NLINE, BC_LEX_SCOLON, BC_LEX_EOF),
800 bc_parse_next_rel = BC_PARSE_NEXT1(BC_LEX_RPAREN),
801 bc_parse_next_elem = BC_PARSE_NEXT1(BC_LEX_RBRACKET),
802 bc_parse_next_for = BC_PARSE_NEXT1(BC_LEX_SCOLON),
803 bc_parse_next_read = BC_PARSE_NEXT2(BC_LEX_NLINE, BC_LEX_EOF),
804#undef BC_PARSE_NEXT4
805#undef BC_PARSE_NEXT2
806#undef BC_PARSE_NEXT1
807};
Gavin Howard01055ba2018-11-03 11:00:21 -0600808#endif // ENABLE_BC
809
Denys Vlasenkoef869ec2018-12-02 18:49:16 +0100810#if ENABLE_DC
Denys Vlasenko18c6b542018-12-07 12:57:32 +0100811static const //BcLexType - should be this type, but narrower type saves size:
812uint8_t
813dc_lex_regs[] = {
Gavin Howard01055ba2018-11-03 11:00:21 -0600814 BC_LEX_OP_REL_EQ, BC_LEX_OP_REL_LE, BC_LEX_OP_REL_GE, BC_LEX_OP_REL_NE,
815 BC_LEX_OP_REL_LT, BC_LEX_OP_REL_GT, BC_LEX_SCOLON, BC_LEX_COLON,
816 BC_LEX_ELSE, BC_LEX_LOAD, BC_LEX_LOAD_POP, BC_LEX_OP_ASSIGN,
817 BC_LEX_STORE_PUSH,
818};
819
Denys Vlasenko18c6b542018-12-07 12:57:32 +0100820static const //BcLexType - should be this type
821uint8_t
822dc_lex_tokens[] = {
Gavin Howard01055ba2018-11-03 11:00:21 -0600823 BC_LEX_OP_MODULUS, BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_LPAREN,
824 BC_LEX_INVALID, BC_LEX_OP_MULTIPLY, BC_LEX_OP_PLUS, BC_LEX_INVALID,
825 BC_LEX_OP_MINUS, BC_LEX_INVALID, BC_LEX_OP_DIVIDE,
826 BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_INVALID,
827 BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_INVALID,
828 BC_LEX_INVALID, BC_LEX_INVALID,
829 BC_LEX_COLON, BC_LEX_SCOLON, BC_LEX_OP_REL_GT, BC_LEX_OP_REL_EQ,
830 BC_LEX_OP_REL_LT, BC_LEX_KEY_READ, BC_LEX_INVALID,
831 BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_INVALID,
832 BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_EQ_NO_REG, BC_LEX_INVALID,
833 BC_LEX_KEY_IBASE, BC_LEX_INVALID, BC_LEX_KEY_SCALE, BC_LEX_LOAD_POP,
834 BC_LEX_INVALID, BC_LEX_OP_BOOL_NOT, BC_LEX_KEY_OBASE, BC_LEX_PRINT_STREAM,
835 BC_LEX_NQUIT, BC_LEX_POP, BC_LEX_STORE_PUSH, BC_LEX_INVALID, BC_LEX_INVALID,
836 BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_SCALE_FACTOR, BC_LEX_INVALID,
837 BC_LEX_KEY_LENGTH, BC_LEX_INVALID, BC_LEX_INVALID, BC_LEX_INVALID,
838 BC_LEX_OP_POWER, BC_LEX_NEG, BC_LEX_INVALID,
839 BC_LEX_ASCIIFY, BC_LEX_INVALID, BC_LEX_CLEAR_STACK, BC_LEX_DUPLICATE,
840 BC_LEX_ELSE, BC_LEX_PRINT_STACK, BC_LEX_INVALID, BC_LEX_INVALID,
841 BC_LEX_STORE_IBASE, BC_LEX_INVALID, BC_LEX_STORE_SCALE, BC_LEX_LOAD,
842 BC_LEX_INVALID, BC_LEX_PRINT_POP, BC_LEX_STORE_OBASE, BC_LEX_KEY_PRINT,
843 BC_LEX_KEY_QUIT, BC_LEX_SWAP, BC_LEX_OP_ASSIGN, BC_LEX_INVALID,
844 BC_LEX_INVALID, BC_LEX_KEY_SQRT, BC_LEX_INVALID, BC_LEX_EXECUTE,
845 BC_LEX_INVALID, BC_LEX_STACK_LEVEL,
846 BC_LEX_LBRACE, BC_LEX_OP_MODEXP, BC_LEX_INVALID, BC_LEX_OP_DIVMOD,
847 BC_LEX_INVALID
848};
849
Denys Vlasenko18c6b542018-12-07 12:57:32 +0100850static const //BcInst - should be this type. Using signed narrow type since BC_INST_INVALID is -1
851int8_t
852dc_parse_insts[] = {
Gavin Howard01055ba2018-11-03 11:00:21 -0600853 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, BC_INST_REL_GE,
854 BC_INST_INVALID, BC_INST_POWER, BC_INST_MULTIPLY, BC_INST_DIVIDE,
855 BC_INST_MODULUS, BC_INST_PLUS, BC_INST_MINUS,
856 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID,
857 BC_INST_INVALID, BC_INST_INVALID,
858 BC_INST_BOOL_NOT, BC_INST_INVALID, BC_INST_INVALID,
859 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID,
860 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID,
861 BC_INST_INVALID, BC_INST_INVALID, BC_INST_REL_GT, BC_INST_INVALID,
862 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, BC_INST_REL_GE,
863 BC_INST_INVALID, BC_INST_INVALID,
864 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID,
865 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID,
866 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, BC_INST_IBASE,
867 BC_INST_INVALID, BC_INST_INVALID, BC_INST_LENGTH, BC_INST_INVALID,
868 BC_INST_OBASE, BC_INST_PRINT, BC_INST_QUIT, BC_INST_INVALID,
869 BC_INST_INVALID, BC_INST_SCALE, BC_INST_SQRT, BC_INST_INVALID,
870 BC_INST_REL_EQ, BC_INST_MODEXP, BC_INST_DIVMOD, BC_INST_INVALID,
871 BC_INST_INVALID, BC_INST_EXECUTE, BC_INST_PRINT_STACK, BC_INST_CLEAR_STACK,
872 BC_INST_STACK_LEN, BC_INST_DUPLICATE, BC_INST_SWAP, BC_INST_POP,
873 BC_INST_ASCIIFY, BC_INST_PRINT_STREAM, BC_INST_INVALID, BC_INST_INVALID,
874 BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID, BC_INST_INVALID,
875 BC_INST_PRINT, BC_INST_NQUIT, BC_INST_SCALE_FUNC,
876};
877#endif // ENABLE_DC
878
Denys Vlasenkoc2d15df2018-12-11 17:56:09 +0100879// In configurations where errors abort instead of propagating error
880// return code up the call chain, functions returning BC_STATUS
881// actually don't return anything, they always succeed and return "void".
882// A macro wrapper is provided, which makes this statement work:
883// s = zbc_func(...)
884// and makes it visible to the compiler that s is always zero,
885// allowing compiler to optimize dead code after the statement.
886//
887// To make code more readable, each such function has a "z"
888// ("always returning zero") prefix, i.e. zbc_foo or zdc_foo.
889//
890#if ENABLE_FEATURE_BC_SIGNALS || ENABLE_FEATURE_CLEAN_UP
Denys Vlasenko7f4daa42018-12-11 19:04:44 +0100891# define ERRORS_ARE_FATAL 0
Denys Vlasenkoc2d15df2018-12-11 17:56:09 +0100892# define ERRORFUNC /*nothing*/
893# define ERROR_RETURN(a) a
Denys Vlasenko9a34e892018-12-12 13:58:55 +0100894//moved up: # define BC_STATUS BcStatus
Denys Vlasenkoc2d15df2018-12-11 17:56:09 +0100895# define RETURN_STATUS(v) return (v)
896#else
Denys Vlasenko7f4daa42018-12-11 19:04:44 +0100897# define ERRORS_ARE_FATAL 1
Denys Vlasenkoc2d15df2018-12-11 17:56:09 +0100898# define ERRORFUNC NORETURN
899# define ERROR_RETURN(a) /*nothing*/
Denys Vlasenko9a34e892018-12-12 13:58:55 +0100900//moved up: # define BC_STATUS void
Denys Vlasenkoc2d15df2018-12-11 17:56:09 +0100901# define RETURN_STATUS(v) do { ((void)(v)); return; } while (0)
902#endif
903
Denys Vlasenko7f4daa42018-12-11 19:04:44 +0100904#define BC_NUM_NEG(n, neg) ((((ssize_t)(n)) ^ -((ssize_t)(neg))) + (neg))
905#define BC_NUM_ONE(n) ((n)->len == 1 && (n)->rdx == 0 && (n)->num[0] == 1)
906#define BC_NUM_INT(n) ((n)->len - (n)->rdx)
907//#define BC_NUM_AREQ(a, b) (BC_MAX((a)->rdx, (b)->rdx) + BC_MAX(BC_NUM_INT(a), BC_NUM_INT(b)) + 1)
908static /*ALWAYS_INLINE*/ size_t BC_NUM_AREQ(BcNum *a, BcNum *b)
909{
910 return BC_MAX(a->rdx, b->rdx) + BC_MAX(BC_NUM_INT(a), BC_NUM_INT(b)) + 1;
911}
912//#define BC_NUM_MREQ(a, b, scale) (BC_NUM_INT(a) + BC_NUM_INT(b) + BC_MAX((scale), (a)->rdx + (b)->rdx) + 1)
913static /*ALWAYS_INLINE*/ size_t BC_NUM_MREQ(BcNum *a, BcNum *b, size_t scale)
914{
915 return BC_NUM_INT(a) + BC_NUM_INT(b) + BC_MAX(scale, a->rdx + b->rdx) + 1;
916}
917
Denys Vlasenkoc2d15df2018-12-11 17:56:09 +0100918typedef void (*BcNumDigitOp)(size_t, size_t, bool) FAST_FUNC;
919
Denys Vlasenko7f4daa42018-12-11 19:04:44 +0100920typedef BC_STATUS (*BcNumBinaryOp)(BcNum *, BcNum *, BcNum *, size_t) FAST_FUNC;
Denys Vlasenkoc2d15df2018-12-11 17:56:09 +0100921
Denys Vlasenko7f4daa42018-12-11 19:04:44 +0100922static BC_STATUS zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
923 BcNumBinaryOp op, size_t req);
924static FAST_FUNC BC_STATUS zbc_num_a(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
925static FAST_FUNC BC_STATUS zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
926static FAST_FUNC BC_STATUS zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
927static FAST_FUNC BC_STATUS zbc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
928static FAST_FUNC BC_STATUS zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
929static FAST_FUNC BC_STATUS zbc_num_rem(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale);
930
931static FAST_FUNC BC_STATUS zbc_num_add(BcNum *a, BcNum *b, BcNum *c, size_t scale)
932{
933 BcNumBinaryOp op = (!a->neg == !b->neg) ? zbc_num_a : zbc_num_s;
934 (void) scale;
935 RETURN_STATUS(zbc_num_binary(a, b, c, false, op, BC_NUM_AREQ(a, b)));
936}
937
938static FAST_FUNC BC_STATUS zbc_num_sub(BcNum *a, BcNum *b, BcNum *c, size_t scale)
939{
940 BcNumBinaryOp op = (!a->neg == !b->neg) ? zbc_num_s : zbc_num_a;
941 (void) scale;
942 RETURN_STATUS(zbc_num_binary(a, b, c, true, op, BC_NUM_AREQ(a, b)));
943}
944
945static FAST_FUNC BC_STATUS zbc_num_mul(BcNum *a, BcNum *b, BcNum *c, size_t scale)
946{
947 size_t req = BC_NUM_MREQ(a, b, scale);
948 RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_m, req));
949}
950
951static FAST_FUNC BC_STATUS zbc_num_div(BcNum *a, BcNum *b, BcNum *c, size_t scale)
952{
953 size_t req = BC_NUM_MREQ(a, b, scale);
954 RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_d, req));
955}
956
957static FAST_FUNC BC_STATUS zbc_num_mod(BcNum *a, BcNum *b, BcNum *c, size_t scale)
958{
959 size_t req = BC_NUM_MREQ(a, b, scale);
960 RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_rem, req));
961}
962
963static FAST_FUNC BC_STATUS zbc_num_pow(BcNum *a, BcNum *b, BcNum *c, size_t scale)
964{
965 RETURN_STATUS(zbc_num_binary(a, b, c, scale, zbc_num_p, a->len * b->len + 1));
966}
Denys Vlasenkoc2d15df2018-12-11 17:56:09 +0100967
Denys Vlasenko1aeacef2018-12-11 19:12:13 +0100968static const BcNumBinaryOp zbc_program_ops[] = {
969 zbc_num_pow, zbc_num_mul, zbc_num_div, zbc_num_mod, zbc_num_add, zbc_num_sub,
Gavin Howard01055ba2018-11-03 11:00:21 -0600970};
Denys Vlasenko7f4daa42018-12-11 19:04:44 +0100971#if ERRORS_ARE_FATAL
972# define zbc_num_add(...) (zbc_num_add(__VA_ARGS__), BC_STATUS_SUCCESS)
973# define zbc_num_sub(...) (zbc_num_sub(__VA_ARGS__), BC_STATUS_SUCCESS)
974# define zbc_num_mul(...) (zbc_num_mul(__VA_ARGS__), BC_STATUS_SUCCESS)
975# define zbc_num_div(...) (zbc_num_div(__VA_ARGS__), BC_STATUS_SUCCESS)
976# define zbc_num_mod(...) (zbc_num_mod(__VA_ARGS__), BC_STATUS_SUCCESS)
977# define zbc_num_pow(...) (zbc_num_pow(__VA_ARGS__), BC_STATUS_SUCCESS)
978#endif
Gavin Howard01055ba2018-11-03 11:00:21 -0600979
Denys Vlasenkod4744ad2018-12-03 14:28:51 +0100980static void fflush_and_check(void)
981{
982 fflush_all();
983 if (ferror(stdout) || ferror(stderr))
984 bb_perror_msg_and_die("output error");
985}
986
Denys Vlasenkoe873ff92018-12-06 00:29:22 +0100987#if ENABLE_FEATURE_CLEAN_UP
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +0100988#define QUIT_OR_RETURN_TO_MAIN \
Denys Vlasenkoe873ff92018-12-06 00:29:22 +0100989do { \
Denys Vlasenko1a6a4822018-12-06 09:20:32 +0100990 IF_FEATURE_BC_SIGNALS(G_ttyin = 0;) /* do not loop in main loop anymore */ \
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +0100991 G_exiting = 1; \
Denys Vlasenkoe873ff92018-12-06 00:29:22 +0100992 return BC_STATUS_FAILURE; \
993} while (0)
994#else
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +0100995#define QUIT_OR_RETURN_TO_MAIN quit()
Denys Vlasenkoe873ff92018-12-06 00:29:22 +0100996#endif
997
Denys Vlasenkocfdc1332018-12-03 14:02:35 +0100998static void quit(void) NORETURN;
999static void quit(void)
1000{
Denys Vlasenkod4744ad2018-12-03 14:28:51 +01001001 if (ferror(stdin))
1002 bb_perror_msg_and_die("input error");
1003 fflush_and_check();
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01001004 dbg_exec("quit(): exiting with exitcode SUCCESS");
Denys Vlasenkod4744ad2018-12-03 14:28:51 +01001005 exit(0);
Denys Vlasenkocfdc1332018-12-03 14:02:35 +01001006}
1007
Denys Vlasenko5318f812018-12-05 17:48:01 +01001008static void bc_verror_msg(const char *fmt, va_list p)
1009{
Denys Vlasenko82269122018-12-14 16:30:56 +01001010 const char *sv = sv; // for compiler
Denys Vlasenko5318f812018-12-05 17:48:01 +01001011 if (G.prog.file) {
1012 sv = applet_name;
1013 applet_name = xasprintf("%s: %s:%u", applet_name, G.prog.file, G.err_line);
1014 }
1015 bb_verror_msg(fmt, p, NULL);
1016 if (G.prog.file) {
1017 free((char*)applet_name);
1018 applet_name = sv;
1019 }
1020}
1021
Denys Vlasenko86e63cd2018-12-10 19:46:53 +01001022static NOINLINE ERRORFUNC int bc_error_fmt(const char *fmt, ...)
Denys Vlasenkoc1c24702018-12-03 16:06:02 +01001023{
1024 va_list p;
1025
1026 va_start(p, fmt);
Denys Vlasenko5318f812018-12-05 17:48:01 +01001027 bc_verror_msg(fmt, p);
Denys Vlasenkoc1c24702018-12-03 16:06:02 +01001028 va_end(p);
Denys Vlasenko0409ad32018-12-05 16:39:22 +01001029
Denys Vlasenko1a6a4822018-12-06 09:20:32 +01001030 if (!ENABLE_FEATURE_CLEAN_UP && !G_ttyin)
Denys Vlasenkoc1c24702018-12-03 16:06:02 +01001031 exit(1);
Denys Vlasenko86e63cd2018-12-10 19:46:53 +01001032 ERROR_RETURN(return BC_STATUS_FAILURE;)
Denys Vlasenkoc1c24702018-12-03 16:06:02 +01001033}
1034
Denys Vlasenko23c2e9f2018-12-06 11:43:17 +01001035#if ENABLE_BC
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01001036static NOINLINE int bc_posix_error_fmt(const char *fmt, ...)
Denys Vlasenko9b70f192018-12-04 20:51:40 +01001037{
1038 va_list p;
1039
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01001040 // Are non-POSIX constructs totally ok?
Denys Vlasenkod70d4a02018-12-04 20:58:40 +01001041 if (!(option_mask32 & (BC_FLAG_S|BC_FLAG_W)))
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01001042 return BC_STATUS_SUCCESS; // yes
Denys Vlasenko9b70f192018-12-04 20:51:40 +01001043
1044 va_start(p, fmt);
Denys Vlasenko5318f812018-12-05 17:48:01 +01001045 bc_verror_msg(fmt, p);
Denys Vlasenko9b70f192018-12-04 20:51:40 +01001046 va_end(p);
1047
1048 // Do we treat non-POSIX constructs as errors?
Denys Vlasenkod70d4a02018-12-04 20:58:40 +01001049 if (!(option_mask32 & BC_FLAG_S))
Denys Vlasenko9b70f192018-12-04 20:51:40 +01001050 return BC_STATUS_SUCCESS; // no, it's a warning
Denys Vlasenko1a6a4822018-12-06 09:20:32 +01001051 if (!ENABLE_FEATURE_CLEAN_UP && !G_ttyin)
Denys Vlasenko9b70f192018-12-04 20:51:40 +01001052 exit(1);
1053 return BC_STATUS_FAILURE;
1054}
Denys Vlasenko23c2e9f2018-12-06 11:43:17 +01001055#endif
Denys Vlasenko9b70f192018-12-04 20:51:40 +01001056
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01001057// We use error functions with "return bc_error(FMT[, PARAMS])" idiom.
1058// This idiom begs for tail-call optimization, but for it to work,
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001059// function must not have caller-cleaned parameters on stack.
1060// Unfortunately, vararg function API does exactly that on most arches.
1061// Thus, use these shims for the cases when we have no vararg PARAMS:
Denys Vlasenko86e63cd2018-12-10 19:46:53 +01001062static ERRORFUNC int bc_error(const char *msg)
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01001063{
Denys Vlasenko86e63cd2018-12-10 19:46:53 +01001064 ERROR_RETURN(return) bc_error_fmt("%s", msg);
1065}
1066static ERRORFUNC int bc_error_bad_character(char c)
1067{
1068 ERROR_RETURN(return) bc_error_fmt("bad character '%c'", c);
1069}
1070static ERRORFUNC int bc_error_bad_expression(void)
1071{
1072 ERROR_RETURN(return) bc_error("bad expression");
1073}
1074static ERRORFUNC int bc_error_bad_token(void)
1075{
1076 ERROR_RETURN(return) bc_error("bad token");
1077}
1078static ERRORFUNC int bc_error_stack_has_too_few_elements(void)
1079{
1080 ERROR_RETURN(return) bc_error("stack has too few elements");
1081}
1082static ERRORFUNC int bc_error_variable_is_wrong_type(void)
1083{
1084 ERROR_RETURN(return) bc_error("variable is wrong type");
1085}
1086static ERRORFUNC int bc_error_nested_read_call(void)
1087{
1088 ERROR_RETURN(return) bc_error("read() call inside of a read() call");
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01001089}
Denys Vlasenko23c2e9f2018-12-06 11:43:17 +01001090#if ENABLE_BC
Denys Vlasenkoa6f84e12018-12-06 11:10:11 +01001091static int bc_POSIX_requires(const char *msg)
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01001092{
Denys Vlasenkoa6f84e12018-12-06 11:10:11 +01001093 return bc_posix_error_fmt("POSIX requires %s", msg);
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01001094}
Denys Vlasenko00646792018-12-05 18:12:27 +01001095static int bc_POSIX_does_not_allow(const char *msg)
1096{
1097 return bc_posix_error_fmt("%s%s", "POSIX does not allow ", msg);
1098}
1099static int bc_POSIX_does_not_allow_bool_ops_this_is_bad(const char *msg)
1100{
1101 return bc_posix_error_fmt("%s%s %s", "POSIX does not allow ", "boolean operators; the following is bad:", msg);
1102}
1103static int bc_POSIX_does_not_allow_empty_X_expression_in_for(const char *msg)
1104{
1105 return bc_posix_error_fmt("%san empty %s expression in a for loop", "POSIX does not allow ", msg);
1106}
Denys Vlasenko23c2e9f2018-12-06 11:43:17 +01001107#endif
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01001108
Gavin Howard01055ba2018-11-03 11:00:21 -06001109static void bc_vec_grow(BcVec *v, size_t n)
1110{
1111 size_t cap = v->cap * 2;
1112 while (cap < v->len + n) cap *= 2;
1113 v->v = xrealloc(v->v, v->size * cap);
1114 v->cap = cap;
1115}
1116
1117static void bc_vec_init(BcVec *v, size_t esize, BcVecFree dtor)
1118{
1119 v->size = esize;
1120 v->cap = BC_VEC_START_CAP;
1121 v->len = 0;
1122 v->dtor = dtor;
1123 v->v = xmalloc(esize * BC_VEC_START_CAP);
1124}
1125
Denys Vlasenko7d628012018-12-04 21:46:47 +01001126static void bc_char_vec_init(BcVec *v)
1127{
1128 bc_vec_init(v, sizeof(char), NULL);
1129}
1130
Gavin Howard01055ba2018-11-03 11:00:21 -06001131static void bc_vec_expand(BcVec *v, size_t req)
1132{
1133 if (v->cap < req) {
1134 v->v = xrealloc(v->v, v->size * req);
1135 v->cap = req;
1136 }
1137}
1138
Denys Vlasenkob23ac512018-12-06 13:10:56 +01001139static void bc_vec_pop(BcVec *v)
1140{
1141 v->len--;
1142 if (v->dtor)
1143 v->dtor(v->v + (v->size * v->len));
1144}
Denys Vlasenko2fa11b62018-12-06 12:34:39 +01001145
Gavin Howard01055ba2018-11-03 11:00:21 -06001146static void bc_vec_npop(BcVec *v, size_t n)
1147{
1148 if (!v->dtor)
1149 v->len -= n;
1150 else {
1151 size_t len = v->len - n;
1152 while (v->len > len) v->dtor(v->v + (v->size * --v->len));
1153 }
1154}
1155
Denys Vlasenko7d628012018-12-04 21:46:47 +01001156static void bc_vec_pop_all(BcVec *v)
1157{
1158 bc_vec_npop(v, v->len);
1159}
1160
Gavin Howard01055ba2018-11-03 11:00:21 -06001161static void bc_vec_push(BcVec *v, const void *data)
1162{
1163 if (v->len + 1 > v->cap) bc_vec_grow(v, 1);
1164 memmove(v->v + (v->size * v->len), data, v->size);
1165 v->len += 1;
1166}
1167
1168static void bc_vec_pushByte(BcVec *v, char data)
1169{
1170 bc_vec_push(v, &data);
1171}
1172
Denys Vlasenko08c033c2018-12-05 16:55:08 +01001173static void bc_vec_pushZeroByte(BcVec *v)
1174{
1175 //bc_vec_pushByte(v, '\0');
1176 // better:
1177 bc_vec_push(v, &const_int_0);
1178}
1179
Gavin Howard01055ba2018-11-03 11:00:21 -06001180static void bc_vec_pushAt(BcVec *v, const void *data, size_t idx)
1181{
1182 if (idx == v->len)
1183 bc_vec_push(v, data);
1184 else {
1185
1186 char *ptr;
1187
1188 if (v->len == v->cap) bc_vec_grow(v, 1);
1189
1190 ptr = v->v + v->size * idx;
1191
1192 memmove(ptr + v->size, ptr, v->size * (v->len++ - idx));
1193 memmove(ptr, data, v->size);
1194 }
1195}
1196
1197static void bc_vec_string(BcVec *v, size_t len, const char *str)
1198{
Denys Vlasenko7d628012018-12-04 21:46:47 +01001199 bc_vec_pop_all(v);
Gavin Howard01055ba2018-11-03 11:00:21 -06001200 bc_vec_expand(v, len + 1);
1201 memcpy(v->v, str, len);
1202 v->len = len;
1203
Denys Vlasenko08c033c2018-12-05 16:55:08 +01001204 bc_vec_pushZeroByte(v);
Gavin Howard01055ba2018-11-03 11:00:21 -06001205}
1206
Denys Vlasenko82ea67f2018-12-13 19:23:45 +01001207#if ENABLE_FEATURE_BC_SIGNALS && ENABLE_FEATURE_EDITING
Gavin Howard01055ba2018-11-03 11:00:21 -06001208static void bc_vec_concat(BcVec *v, const char *str)
1209{
Denys Vlasenko8b4cf0d2018-12-10 15:12:58 +01001210 size_t len, slen;
Gavin Howard01055ba2018-11-03 11:00:21 -06001211
Denys Vlasenko08c033c2018-12-05 16:55:08 +01001212 if (v->len == 0) bc_vec_pushZeroByte(v);
Gavin Howard01055ba2018-11-03 11:00:21 -06001213
Denys Vlasenko8b4cf0d2018-12-10 15:12:58 +01001214 slen = strlen(str);
1215 len = v->len + slen;
Gavin Howard01055ba2018-11-03 11:00:21 -06001216
Denys Vlasenko8b4cf0d2018-12-10 15:12:58 +01001217 if (v->cap < len) bc_vec_grow(v, slen);
Denys Vlasenko1ff88622018-12-06 12:06:16 +01001218 strcpy(v->v + v->len - 1, str);
Gavin Howard01055ba2018-11-03 11:00:21 -06001219
1220 v->len = len;
1221}
Denys Vlasenko82ea67f2018-12-13 19:23:45 +01001222#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06001223
1224static void *bc_vec_item(const BcVec *v, size_t idx)
1225{
1226 return v->v + v->size * idx;
1227}
1228
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01001229static char** bc_program_str(size_t idx)
1230{
1231 return bc_vec_item(&G.prog.strs, idx);
1232}
1233
1234static BcFunc* bc_program_func(size_t idx)
1235{
1236 return bc_vec_item(&G.prog.fns, idx);
1237}
1238
Gavin Howard01055ba2018-11-03 11:00:21 -06001239static void *bc_vec_item_rev(const BcVec *v, size_t idx)
1240{
1241 return v->v + v->size * (v->len - idx - 1);
1242}
1243
Denys Vlasenkob23ac512018-12-06 13:10:56 +01001244static void *bc_vec_top(const BcVec *v)
1245{
1246 return v->v + v->size * (v->len - 1);
1247}
1248
Denys Vlasenko5ba55f12018-12-10 15:37:14 +01001249static FAST_FUNC void bc_vec_free(void *vec)
Gavin Howard01055ba2018-11-03 11:00:21 -06001250{
1251 BcVec *v = (BcVec *) vec;
Denys Vlasenko7d628012018-12-04 21:46:47 +01001252 bc_vec_pop_all(v);
Gavin Howard01055ba2018-11-03 11:00:21 -06001253 free(v->v);
1254}
1255
Denys Vlasenkocca79a02018-12-05 21:15:46 +01001256static int bc_id_cmp(const void *e1, const void *e2)
1257{
1258 return strcmp(((const BcId *) e1)->name, ((const BcId *) e2)->name);
1259}
1260
Denys Vlasenko5ba55f12018-12-10 15:37:14 +01001261static FAST_FUNC void bc_id_free(void *id)
Denys Vlasenkocca79a02018-12-05 21:15:46 +01001262{
1263 free(((BcId *) id)->name);
1264}
1265
Gavin Howard01055ba2018-11-03 11:00:21 -06001266static size_t bc_map_find(const BcVec *v, const void *ptr)
1267{
1268 size_t low = 0, high = v->len;
1269
1270 while (low < high) {
1271
1272 size_t mid = (low + high) / 2;
1273 BcId *id = bc_vec_item(v, mid);
1274 int result = bc_id_cmp(ptr, id);
1275
1276 if (result == 0)
1277 return mid;
1278 else if (result < 0)
1279 high = mid;
1280 else
1281 low = mid + 1;
1282 }
1283
1284 return low;
1285}
1286
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01001287static int bc_map_insert(BcVec *v, const void *ptr, size_t *i)
Gavin Howard01055ba2018-11-03 11:00:21 -06001288{
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01001289 size_t n = *i = bc_map_find(v, ptr);
Gavin Howard01055ba2018-11-03 11:00:21 -06001290
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01001291 if (n == v->len)
Gavin Howard01055ba2018-11-03 11:00:21 -06001292 bc_vec_push(v, ptr);
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01001293 else if (!bc_id_cmp(ptr, bc_vec_item(v, n)))
1294 return 0; // "was not inserted"
Gavin Howard01055ba2018-11-03 11:00:21 -06001295 else
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01001296 bc_vec_pushAt(v, ptr, n);
1297 return 1; // "was inserted"
Gavin Howard01055ba2018-11-03 11:00:21 -06001298}
1299
Denys Vlasenko23c2e9f2018-12-06 11:43:17 +01001300#if ENABLE_BC
Gavin Howard01055ba2018-11-03 11:00:21 -06001301static size_t bc_map_index(const BcVec *v, const void *ptr)
1302{
1303 size_t i = bc_map_find(v, ptr);
1304 if (i >= v->len) return BC_VEC_INVALID_IDX;
1305 return bc_id_cmp(ptr, bc_vec_item(v, i)) ? BC_VEC_INVALID_IDX : i;
1306}
Denys Vlasenko23c2e9f2018-12-06 11:43:17 +01001307#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06001308
Denys Vlasenko82ea67f2018-12-13 19:23:45 +01001309static int bad_input_byte(char c)
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001310{
1311 if ((c < ' ' && c != '\t' && c != '\r' && c != '\n') // also allow '\v' '\f'?
1312 || c > 0x7e
1313 ) {
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001314 bc_error_fmt("illegal character 0x%02x", c);
1315 return 1;
1316 }
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001317 return 0;
1318}
1319
Denys Vlasenko82ea67f2018-12-13 19:23:45 +01001320// Note: it _appends_ data from the stdin to vec.
Denys Vlasenko8a892472018-12-12 22:43:58 +01001321static void bc_read_line(BcVec *vec)
Gavin Howard01055ba2018-11-03 11:00:21 -06001322{
Denys Vlasenko82ea67f2018-12-13 19:23:45 +01001323 again:
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001324 fflush_and_check();
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001325
Gavin Howard01055ba2018-11-03 11:00:21 -06001326#if ENABLE_FEATURE_BC_SIGNALS
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001327 if (G_interrupt) { // ^C was pressed
Denys Vlasenkoc1c24702018-12-03 16:06:02 +01001328 intr:
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001329 G_interrupt = 0;
1330 // GNU bc says "interrupted execution."
1331 // GNU dc says "Interrupt!"
1332 fputs("\ninterrupted execution\n", stderr);
1333 }
Denys Vlasenko82ea67f2018-12-13 19:23:45 +01001334
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001335# if ENABLE_FEATURE_EDITING
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001336 if (G_ttyin) {
1337 int n, i;
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001338# define line_buf bb_common_bufsiz1
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001339 n = read_line_input(G.line_input_state, "", line_buf, COMMON_BUFSIZE);
1340 if (n <= 0) { // read errors or EOF, or ^D, or ^C
1341 if (n == 0) // ^C
1342 goto intr;
Denys Vlasenkoe755e302018-12-13 22:25:28 +01001343 bc_vec_pushZeroByte(vec);
1344 return;
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001345 }
1346 i = 0;
1347 for (;;) {
1348 char c = line_buf[i++];
1349 if (!c) break;
1350 if (bad_input_byte(c)) goto again;
1351 }
1352 bc_vec_concat(vec, line_buf);
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001353# undef line_buf
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001354 } else
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001355# endif
Denys Vlasenkoc1c24702018-12-03 16:06:02 +01001356#endif
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001357 {
1358 int c;
1359 bool bad_chars = 0;
1360 size_t len = vec->len;
Denys Vlasenko82ea67f2018-12-13 19:23:45 +01001361
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001362 IF_FEATURE_BC_SIGNALS(errno = 0;)
1363 do {
1364 c = fgetc(stdin);
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01001365#if ENABLE_FEATURE_BC_SIGNALS && !ENABLE_FEATURE_EDITING
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001366 // Both conditions appear simultaneously, check both just in case
1367 if (errno == EINTR || G_interrupt) {
1368 // ^C was pressed
1369 clearerr(stdin);
1370 goto intr;
Denys Vlasenko82ea67f2018-12-13 19:23:45 +01001371 }
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001372#endif
1373 if (c == EOF) {
1374 if (ferror(stdin))
1375 quit(); // this emits error message
1376 // Note: EOF does not append '\n', therefore:
1377 // printf 'print 123\n' | bc - works
1378 // printf 'print 123' | bc - fails (syntax error)
1379 break;
1380 }
1381 bad_chars |= bad_input_byte(c);
1382 bc_vec_pushByte(vec, (char)c);
1383 } while (c != '\n');
1384 if (bad_chars) {
1385 // Bad chars on this line, ignore entire line
1386 vec->len = len;
1387 goto again;
Denys Vlasenkoed849352018-12-06 10:26:13 +01001388 }
Denys Vlasenko915c72b2018-12-13 19:28:41 +01001389 bc_vec_pushZeroByte(vec);
1390 }
Gavin Howard01055ba2018-11-03 11:00:21 -06001391}
1392
Denys Vlasenkodf515392018-12-02 19:27:48 +01001393static char* bc_read_file(const char *path)
Gavin Howard01055ba2018-11-03 11:00:21 -06001394{
Denys Vlasenkodf515392018-12-02 19:27:48 +01001395 char *buf;
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01001396 size_t size = ((size_t) -1);
1397 size_t i;
Gavin Howard01055ba2018-11-03 11:00:21 -06001398
Denys Vlasenko4c9455f2018-12-06 15:21:39 +01001399 // Never returns NULL (dies on errors)
1400 buf = xmalloc_xopen_read_close(path, &size);
Gavin Howard01055ba2018-11-03 11:00:21 -06001401
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01001402 for (i = 0; i < size; ++i) {
Denys Vlasenkoc1c24702018-12-03 16:06:02 +01001403 char c = buf[i];
1404 if ((c < ' ' && c != '\t' && c != '\r' && c != '\n') // also allow '\v' '\f'?
1405 || c > 0x7e
1406 ) {
Denys Vlasenkodf515392018-12-02 19:27:48 +01001407 free(buf);
1408 buf = NULL;
1409 break;
1410 }
Gavin Howard01055ba2018-11-03 11:00:21 -06001411 }
1412
Denys Vlasenkodf515392018-12-02 19:27:48 +01001413 return buf;
Gavin Howard01055ba2018-11-03 11:00:21 -06001414}
1415
Gavin Howard01055ba2018-11-03 11:00:21 -06001416static void bc_num_setToZero(BcNum *n, size_t scale)
1417{
1418 n->len = 0;
1419 n->neg = false;
1420 n->rdx = scale;
1421}
1422
1423static void bc_num_zero(BcNum *n)
1424{
1425 bc_num_setToZero(n, 0);
1426}
1427
1428static void bc_num_one(BcNum *n)
1429{
1430 bc_num_setToZero(n, 0);
1431 n->len = 1;
1432 n->num[0] = 1;
1433}
1434
1435static void bc_num_ten(BcNum *n)
1436{
1437 bc_num_setToZero(n, 0);
1438 n->len = 2;
1439 n->num[0] = 0;
1440 n->num[1] = 1;
1441}
1442
Denys Vlasenko3129f702018-12-09 12:04:44 +01001443// Note: this also sets BcNum to zero
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001444static void bc_num_init(BcNum *n, size_t req)
1445{
1446 req = req >= BC_NUM_DEF_SIZE ? req : BC_NUM_DEF_SIZE;
Denys Vlasenko3129f702018-12-09 12:04:44 +01001447 //memset(n, 0, sizeof(BcNum)); - cleared by assignments below
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001448 n->num = xmalloc(req);
1449 n->cap = req;
Denys Vlasenko3129f702018-12-09 12:04:44 +01001450 n->rdx = 0;
1451 n->len = 0;
1452 n->neg = false;
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001453}
1454
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01001455static void bc_num_init_DEF_SIZE(BcNum *n)
1456{
1457 bc_num_init(n, BC_NUM_DEF_SIZE);
1458}
1459
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001460static void bc_num_expand(BcNum *n, size_t req)
1461{
1462 req = req >= BC_NUM_DEF_SIZE ? req : BC_NUM_DEF_SIZE;
1463 if (req > n->cap) {
1464 n->num = xrealloc(n->num, req);
1465 n->cap = req;
1466 }
1467}
1468
Denys Vlasenko5ba55f12018-12-10 15:37:14 +01001469static FAST_FUNC void bc_num_free(void *num)
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001470{
1471 free(((BcNum *) num)->num);
1472}
1473
1474static void bc_num_copy(BcNum *d, BcNum *s)
1475{
1476 if (d != s) {
1477 bc_num_expand(d, s->cap);
1478 d->len = s->len;
1479 d->neg = s->neg;
1480 d->rdx = s->rdx;
1481 memcpy(d->num, s->num, sizeof(BcDig) * d->len);
1482 }
1483}
1484
Denys Vlasenko29301232018-12-11 15:29:32 +01001485static BC_STATUS zbc_num_ulong(BcNum *n, unsigned long *result_p)
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001486{
1487 size_t i;
Denys Vlasenkoffdcebd2018-12-07 15:10:05 +01001488 unsigned long pow, result;
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001489
Denys Vlasenko29301232018-12-11 15:29:32 +01001490 if (n->neg) RETURN_STATUS(bc_error("negative number"));
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001491
Denys Vlasenkoffdcebd2018-12-07 15:10:05 +01001492 for (result = 0, pow = 1, i = n->rdx; i < n->len; ++i) {
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001493
Denys Vlasenkoffdcebd2018-12-07 15:10:05 +01001494 unsigned long prev = result, powprev = pow;
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001495
Denys Vlasenkoffdcebd2018-12-07 15:10:05 +01001496 result += ((unsigned long) n->num[i]) * pow;
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001497 pow *= 10;
1498
Denys Vlasenkoffdcebd2018-12-07 15:10:05 +01001499 if (result < prev || pow < powprev)
Denys Vlasenko29301232018-12-11 15:29:32 +01001500 RETURN_STATUS(bc_error("overflow"));
Denys Vlasenkoffdcebd2018-12-07 15:10:05 +01001501 prev = result;
1502 powprev = pow;
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001503 }
Denys Vlasenkoffdcebd2018-12-07 15:10:05 +01001504 *result_p = result;
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001505
Denys Vlasenko29301232018-12-11 15:29:32 +01001506 RETURN_STATUS(BC_STATUS_SUCCESS);
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001507}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01001508#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01001509# define zbc_num_ulong(...) (zbc_num_ulong(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01001510#endif
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001511
1512static void bc_num_ulong2num(BcNum *n, unsigned long val)
1513{
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001514 BcDig *ptr;
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001515
1516 bc_num_zero(n);
1517
1518 if (val == 0) return;
1519
Denys Vlasenkob696d9e2018-12-10 12:22:15 +01001520 if (ULONG_MAX == 0xffffffffUL)
1521 bc_num_expand(n, 10); // 10 digits: 4294967295
Denys Vlasenkoc665c182018-12-10 15:15:42 +01001522 if (ULONG_MAX == 0xffffffffffffffffULL)
Denys Vlasenkob696d9e2018-12-10 12:22:15 +01001523 bc_num_expand(n, 20); // 20 digits: 18446744073709551615
Denys Vlasenkoc665c182018-12-10 15:15:42 +01001524 BUILD_BUG_ON(ULONG_MAX > 0xffffffffffffffffULL);
Denys Vlasenkob696d9e2018-12-10 12:22:15 +01001525
1526 ptr = n->num;
1527 for (;;) {
1528 n->len++;
1529 *ptr++ = val % 10;
1530 val /= 10;
1531 if (val == 0) break;
1532 }
Denys Vlasenkob0e37612018-12-05 21:03:16 +01001533}
1534
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01001535static void bc_num_subArrays(BcDig *restrict a, BcDig *restrict b,
Gavin Howard01055ba2018-11-03 11:00:21 -06001536 size_t len)
1537{
1538 size_t i, j;
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01001539 for (i = 0; i < len; ++i) {
1540 for (a[i] -= b[i], j = 0; a[i + j] < 0;) {
Gavin Howard01055ba2018-11-03 11:00:21 -06001541 a[i + j++] += 10;
1542 a[i + j] -= 1;
1543 }
1544 }
Gavin Howard01055ba2018-11-03 11:00:21 -06001545}
1546
1547static ssize_t bc_num_compare(BcDig *restrict a, BcDig *restrict b, size_t len)
1548{
1549 size_t i;
1550 int c = 0;
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01001551 for (i = len - 1; i < len && !(c = a[i] - b[i]); --i);
Gavin Howard01055ba2018-11-03 11:00:21 -06001552 return BC_NUM_NEG(i + 1, c < 0);
1553}
1554
1555static ssize_t bc_num_cmp(BcNum *a, BcNum *b)
1556{
1557 size_t i, min, a_int, b_int, diff;
1558 BcDig *max_num, *min_num;
Denys Vlasenko251fbb52018-12-12 11:51:32 +01001559 bool a_max, neg;
Gavin Howard01055ba2018-11-03 11:00:21 -06001560 ssize_t cmp;
1561
1562 if (a == b) return 0;
1563 if (a->len == 0) return BC_NUM_NEG(!!b->len, !b->neg);
1564 if (b->len == 0) return BC_NUM_NEG(1, a->neg);
Denys Vlasenko251fbb52018-12-12 11:51:32 +01001565
1566 if (a->neg != b->neg) // signs of a and b differ
1567 // +a,-b = a>b = 1 or -a,+b = a<b = -1
1568 return (int)b->neg - (int)a->neg;
1569 neg = a->neg; // 1 if both negative, 0 if both positive
Gavin Howard01055ba2018-11-03 11:00:21 -06001570
1571 a_int = BC_NUM_INT(a);
1572 b_int = BC_NUM_INT(b);
1573 a_int -= b_int;
Gavin Howard01055ba2018-11-03 11:00:21 -06001574
1575 if (a_int != 0) return (ssize_t) a_int;
1576
Denys Vlasenko251fbb52018-12-12 11:51:32 +01001577 a_max = (a->rdx > b->rdx);
Gavin Howard01055ba2018-11-03 11:00:21 -06001578 if (a_max) {
1579 min = b->rdx;
1580 diff = a->rdx - b->rdx;
1581 max_num = a->num + diff;
1582 min_num = b->num;
Denys Vlasenko251fbb52018-12-12 11:51:32 +01001583 // neg = (a_max == neg); - NOP (maps 1->1 and 0->0)
1584 } else {
Gavin Howard01055ba2018-11-03 11:00:21 -06001585 min = a->rdx;
1586 diff = b->rdx - a->rdx;
1587 max_num = b->num + diff;
1588 min_num = a->num;
Denys Vlasenko251fbb52018-12-12 11:51:32 +01001589 neg = !neg; // same as "neg = (a_max == neg)"
Gavin Howard01055ba2018-11-03 11:00:21 -06001590 }
1591
1592 cmp = bc_num_compare(max_num, min_num, b_int + min);
Denys Vlasenko251fbb52018-12-12 11:51:32 +01001593 if (cmp != 0) return BC_NUM_NEG(cmp, neg);
Gavin Howard01055ba2018-11-03 11:00:21 -06001594
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01001595 for (max_num -= diff, i = diff - 1; i < diff; --i) {
Denys Vlasenko251fbb52018-12-12 11:51:32 +01001596 if (max_num[i]) return BC_NUM_NEG(1, neg);
Gavin Howard01055ba2018-11-03 11:00:21 -06001597 }
1598
1599 return 0;
1600}
1601
1602static void bc_num_truncate(BcNum *n, size_t places)
1603{
1604 if (places == 0) return;
1605
1606 n->rdx -= places;
1607
1608 if (n->len != 0) {
1609 n->len -= places;
1610 memmove(n->num, n->num + places, n->len * sizeof(BcDig));
1611 }
1612}
1613
1614static void bc_num_extend(BcNum *n, size_t places)
1615{
1616 size_t len = n->len + places;
1617
1618 if (places != 0) {
1619
1620 if (n->cap < len) bc_num_expand(n, len);
1621
1622 memmove(n->num + places, n->num, sizeof(BcDig) * n->len);
1623 memset(n->num, 0, sizeof(BcDig) * places);
1624
1625 n->len += places;
1626 n->rdx += places;
1627 }
1628}
1629
1630static void bc_num_clean(BcNum *n)
1631{
1632 while (n->len > 0 && n->num[n->len - 1] == 0) --n->len;
1633 if (n->len == 0)
1634 n->neg = false;
1635 else if (n->len < n->rdx)
1636 n->len = n->rdx;
1637}
1638
1639static void bc_num_retireMul(BcNum *n, size_t scale, bool neg1, bool neg2)
1640{
1641 if (n->rdx < scale)
1642 bc_num_extend(n, scale - n->rdx);
1643 else
1644 bc_num_truncate(n, n->rdx - scale);
1645
1646 bc_num_clean(n);
1647 if (n->len != 0) n->neg = !neg1 != !neg2;
1648}
1649
1650static void bc_num_split(BcNum *restrict n, size_t idx, BcNum *restrict a,
1651 BcNum *restrict b)
1652{
1653 if (idx < n->len) {
1654
1655 b->len = n->len - idx;
1656 a->len = idx;
1657 a->rdx = b->rdx = 0;
1658
1659 memcpy(b->num, n->num + idx, b->len * sizeof(BcDig));
1660 memcpy(a->num, n->num, idx * sizeof(BcDig));
1661 }
1662 else {
1663 bc_num_zero(b);
1664 bc_num_copy(a, n);
1665 }
1666
1667 bc_num_clean(a);
1668 bc_num_clean(b);
1669}
1670
Denys Vlasenko29301232018-12-11 15:29:32 +01001671static BC_STATUS zbc_num_shift(BcNum *n, size_t places)
Gavin Howard01055ba2018-11-03 11:00:21 -06001672{
Denys Vlasenko29301232018-12-11 15:29:32 +01001673 if (places == 0 || n->len == 0) RETURN_STATUS(BC_STATUS_SUCCESS);
Denys Vlasenko64074a12018-12-07 15:50:14 +01001674
1675 // This check makes sense only if size_t is (much) larger than BC_MAX_NUM.
1676 if (SIZE_MAX > (BC_MAX_NUM | 0xff)) {
1677 if (places + n->len > BC_MAX_NUM)
Denys Vlasenko29301232018-12-11 15:29:32 +01001678 RETURN_STATUS(bc_error("number too long: must be [1,"BC_MAX_NUM_STR"]"));
Denys Vlasenko64074a12018-12-07 15:50:14 +01001679 }
Gavin Howard01055ba2018-11-03 11:00:21 -06001680
1681 if (n->rdx >= places)
1682 n->rdx -= places;
1683 else {
1684 bc_num_extend(n, places - n->rdx);
1685 n->rdx = 0;
1686 }
1687
1688 bc_num_clean(n);
1689
Denys Vlasenko29301232018-12-11 15:29:32 +01001690 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06001691}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01001692#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01001693# define zbc_num_shift(...) (zbc_num_shift(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01001694#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06001695
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001696static BC_STATUS zbc_num_inv(BcNum *a, BcNum *b, size_t scale)
Gavin Howard01055ba2018-11-03 11:00:21 -06001697{
1698 BcNum one;
1699 BcDig num[2];
1700
1701 one.cap = 2;
1702 one.num = num;
1703 bc_num_one(&one);
1704
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001705 RETURN_STATUS(zbc_num_div(&one, a, b, scale));
Gavin Howard01055ba2018-11-03 11:00:21 -06001706}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001707#if ERRORS_ARE_FATAL
1708# define zbc_num_inv(...) (zbc_num_inv(__VA_ARGS__), BC_STATUS_SUCCESS)
1709#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06001710
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001711static FAST_FUNC BC_STATUS zbc_num_a(BcNum *a, BcNum *b, BcNum *restrict c, size_t sub)
Gavin Howard01055ba2018-11-03 11:00:21 -06001712{
1713 BcDig *ptr, *ptr_a, *ptr_b, *ptr_c;
1714 size_t i, max, min_rdx, min_int, diff, a_int, b_int;
1715 int carry, in;
1716
1717 // Because this function doesn't need to use scale (per the bc spec),
1718 // I am hijacking it to say whether it's doing an add or a subtract.
1719
1720 if (a->len == 0) {
1721 bc_num_copy(c, b);
1722 if (sub && c->len) c->neg = !c->neg;
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001723 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06001724 }
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001725 if (b->len == 0) {
Gavin Howard01055ba2018-11-03 11:00:21 -06001726 bc_num_copy(c, a);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001727 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06001728 }
1729
1730 c->neg = a->neg;
1731 c->rdx = BC_MAX(a->rdx, b->rdx);
1732 min_rdx = BC_MIN(a->rdx, b->rdx);
1733 c->len = 0;
1734
1735 if (a->rdx > b->rdx) {
1736 diff = a->rdx - b->rdx;
1737 ptr = a->num;
1738 ptr_a = a->num + diff;
1739 ptr_b = b->num;
1740 }
1741 else {
1742 diff = b->rdx - a->rdx;
1743 ptr = b->num;
1744 ptr_a = a->num;
1745 ptr_b = b->num + diff;
1746 }
1747
1748 for (ptr_c = c->num, i = 0; i < diff; ++i, ++c->len) ptr_c[i] = ptr[i];
1749
1750 ptr_c += diff;
1751 a_int = BC_NUM_INT(a);
1752 b_int = BC_NUM_INT(b);
1753
1754 if (a_int > b_int) {
1755 min_int = b_int;
1756 max = a_int;
1757 ptr = ptr_a;
1758 }
1759 else {
1760 min_int = a_int;
1761 max = b_int;
1762 ptr = ptr_b;
1763 }
1764
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01001765 for (carry = 0, i = 0; i < min_rdx + min_int; ++i, ++c->len) {
Gavin Howard01055ba2018-11-03 11:00:21 -06001766 in = ((int) ptr_a[i]) + ((int) ptr_b[i]) + carry;
1767 carry = in / 10;
1768 ptr_c[i] = (BcDig)(in % 10);
1769 }
1770
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01001771 for (; i < max + min_rdx; ++i, ++c->len) {
Gavin Howard01055ba2018-11-03 11:00:21 -06001772 in = ((int) ptr[i]) + carry;
1773 carry = in / 10;
1774 ptr_c[i] = (BcDig)(in % 10);
1775 }
1776
1777 if (carry != 0) c->num[c->len++] = (BcDig) carry;
1778
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001779 RETURN_STATUS(BC_STATUS_SUCCESS); // can't make void, see zbc_num_binary()
Gavin Howard01055ba2018-11-03 11:00:21 -06001780}
1781
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001782static FAST_FUNC BC_STATUS zbc_num_s(BcNum *a, BcNum *b, BcNum *restrict c, size_t sub)
Gavin Howard01055ba2018-11-03 11:00:21 -06001783{
Gavin Howard01055ba2018-11-03 11:00:21 -06001784 ssize_t cmp;
1785 BcNum *minuend, *subtrahend;
1786 size_t start;
1787 bool aneg, bneg, neg;
1788
1789 // Because this function doesn't need to use scale (per the bc spec),
1790 // I am hijacking it to say whether it's doing an add or a subtract.
1791
1792 if (a->len == 0) {
1793 bc_num_copy(c, b);
1794 if (sub && c->len) c->neg = !c->neg;
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001795 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06001796 }
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001797 if (b->len == 0) {
Gavin Howard01055ba2018-11-03 11:00:21 -06001798 bc_num_copy(c, a);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001799 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06001800 }
1801
1802 aneg = a->neg;
1803 bneg = b->neg;
1804 a->neg = b->neg = false;
1805
1806 cmp = bc_num_cmp(a, b);
1807
1808 a->neg = aneg;
1809 b->neg = bneg;
1810
1811 if (cmp == 0) {
1812 bc_num_setToZero(c, BC_MAX(a->rdx, b->rdx));
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001813 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06001814 }
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001815 if (cmp > 0) {
Gavin Howard01055ba2018-11-03 11:00:21 -06001816 neg = a->neg;
1817 minuend = a;
1818 subtrahend = b;
1819 }
1820 else {
1821 neg = b->neg;
1822 if (sub) neg = !neg;
1823 minuend = b;
1824 subtrahend = a;
1825 }
1826
1827 bc_num_copy(c, minuend);
1828 c->neg = neg;
1829
1830 if (c->rdx < subtrahend->rdx) {
1831 bc_num_extend(c, subtrahend->rdx - c->rdx);
1832 start = 0;
1833 }
1834 else
1835 start = c->rdx - subtrahend->rdx;
1836
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01001837 bc_num_subArrays(c->num + start, subtrahend->num, subtrahend->len);
Gavin Howard01055ba2018-11-03 11:00:21 -06001838
1839 bc_num_clean(c);
1840
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001841 RETURN_STATUS(BC_STATUS_SUCCESS); // can't make void, see zbc_num_binary()
Gavin Howard01055ba2018-11-03 11:00:21 -06001842}
1843
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001844static FAST_FUNC BC_STATUS zbc_num_k(BcNum *restrict a, BcNum *restrict b,
Gavin Howard01055ba2018-11-03 11:00:21 -06001845 BcNum *restrict c)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001846#if ERRORS_ARE_FATAL
1847# define zbc_num_k(...) (zbc_num_k(__VA_ARGS__), BC_STATUS_SUCCESS)
1848#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06001849{
1850 BcStatus s;
Denys Vlasenkob692c2f2018-12-05 18:56:14 +01001851 size_t max = BC_MAX(a->len, b->len), max2 = (max + 1) / 2;
Gavin Howard01055ba2018-11-03 11:00:21 -06001852 BcNum l1, h1, l2, h2, m2, m1, z0, z1, z2, temp;
Denys Vlasenkob692c2f2018-12-05 18:56:14 +01001853 bool aone;
Gavin Howard01055ba2018-11-03 11:00:21 -06001854
Gavin Howard01055ba2018-11-03 11:00:21 -06001855 if (a->len == 0 || b->len == 0) {
1856 bc_num_zero(c);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001857 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06001858 }
Denys Vlasenkob692c2f2018-12-05 18:56:14 +01001859 aone = BC_NUM_ONE(a);
1860 if (aone || BC_NUM_ONE(b)) {
Gavin Howard01055ba2018-11-03 11:00:21 -06001861 bc_num_copy(c, aone ? b : a);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001862 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06001863 }
1864
1865 if (a->len + b->len < BC_NUM_KARATSUBA_LEN ||
1866 a->len < BC_NUM_KARATSUBA_LEN || b->len < BC_NUM_KARATSUBA_LEN)
1867 {
Denys Vlasenkob692c2f2018-12-05 18:56:14 +01001868 size_t i, j, len;
Denys Vlasenkob3cb9012018-12-05 19:05:32 +01001869 unsigned carry;
Denys Vlasenkob692c2f2018-12-05 18:56:14 +01001870
Gavin Howard01055ba2018-11-03 11:00:21 -06001871 bc_num_expand(c, a->len + b->len + 1);
1872
1873 memset(c->num, 0, sizeof(BcDig) * c->cap);
Denys Vlasenkob692c2f2018-12-05 18:56:14 +01001874 c->len = len = 0;
Gavin Howard01055ba2018-11-03 11:00:21 -06001875
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01001876 for (i = 0; i < b->len; ++i) {
Gavin Howard01055ba2018-11-03 11:00:21 -06001877
Denys Vlasenkob692c2f2018-12-05 18:56:14 +01001878 carry = 0;
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01001879 for (j = 0; j < a->len; ++j) {
Denys Vlasenkob3cb9012018-12-05 19:05:32 +01001880 unsigned in = c->num[i + j];
1881 in += ((unsigned) a->num[j]) * ((unsigned) b->num[i]) + carry;
1882 // note: compilers prefer _unsigned_ div/const
Gavin Howard01055ba2018-11-03 11:00:21 -06001883 carry = in / 10;
1884 c->num[i + j] = (BcDig)(in % 10);
1885 }
1886
1887 c->num[i + j] += (BcDig) carry;
1888 len = BC_MAX(len, i + j + !!carry);
Denys Vlasenko06fa65b2018-12-05 19:00:58 +01001889
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001890#if ENABLE_FEATURE_BC_SIGNALS
Denys Vlasenko06fa65b2018-12-05 19:00:58 +01001891 // a=2^1000000
1892 // a*a <- without check below, this will not be interruptible
1893 if (G_interrupt) return BC_STATUS_FAILURE;
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001894#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06001895 }
1896
1897 c->len = len;
1898
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001899 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06001900 }
1901
1902 bc_num_init(&l1, max);
1903 bc_num_init(&h1, max);
1904 bc_num_init(&l2, max);
1905 bc_num_init(&h2, max);
1906 bc_num_init(&m1, max);
1907 bc_num_init(&m2, max);
1908 bc_num_init(&z0, max);
1909 bc_num_init(&z1, max);
1910 bc_num_init(&z2, max);
1911 bc_num_init(&temp, max + max);
1912
1913 bc_num_split(a, max2, &l1, &h1);
1914 bc_num_split(b, max2, &l2, &h2);
1915
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001916 s = zbc_num_add(&h1, &l1, &m1, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06001917 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001918 s = zbc_num_add(&h2, &l2, &m2, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06001919 if (s) goto err;
1920
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001921 s = zbc_num_k(&h1, &h2, &z0);
Gavin Howard01055ba2018-11-03 11:00:21 -06001922 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001923 s = zbc_num_k(&m1, &m2, &z1);
Gavin Howard01055ba2018-11-03 11:00:21 -06001924 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001925 s = zbc_num_k(&l1, &l2, &z2);
Gavin Howard01055ba2018-11-03 11:00:21 -06001926 if (s) goto err;
1927
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001928 s = zbc_num_sub(&z1, &z0, &temp, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06001929 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001930 s = zbc_num_sub(&temp, &z2, &z1, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06001931 if (s) goto err;
1932
Denys Vlasenko29301232018-12-11 15:29:32 +01001933 s = zbc_num_shift(&z0, max2 * 2);
Gavin Howard01055ba2018-11-03 11:00:21 -06001934 if (s) goto err;
Denys Vlasenko29301232018-12-11 15:29:32 +01001935 s = zbc_num_shift(&z1, max2);
Gavin Howard01055ba2018-11-03 11:00:21 -06001936 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001937 s = zbc_num_add(&z0, &z1, &temp, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06001938 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001939 s = zbc_num_add(&temp, &z2, c, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06001940
1941err:
1942 bc_num_free(&temp);
1943 bc_num_free(&z2);
1944 bc_num_free(&z1);
1945 bc_num_free(&z0);
1946 bc_num_free(&m2);
1947 bc_num_free(&m1);
1948 bc_num_free(&h2);
1949 bc_num_free(&l2);
1950 bc_num_free(&h1);
1951 bc_num_free(&l1);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001952 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06001953}
1954
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001955static FAST_FUNC BC_STATUS zbc_num_m(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
Gavin Howard01055ba2018-11-03 11:00:21 -06001956{
1957 BcStatus s;
1958 BcNum cpa, cpb;
1959 size_t maxrdx = BC_MAX(a->rdx, b->rdx);
1960
1961 scale = BC_MAX(scale, a->rdx);
1962 scale = BC_MAX(scale, b->rdx);
1963 scale = BC_MIN(a->rdx + b->rdx, scale);
1964 maxrdx = BC_MAX(maxrdx, scale);
1965
1966 bc_num_init(&cpa, a->len);
1967 bc_num_init(&cpb, b->len);
1968
1969 bc_num_copy(&cpa, a);
1970 bc_num_copy(&cpb, b);
1971 cpa.neg = cpb.neg = false;
1972
Denys Vlasenko29301232018-12-11 15:29:32 +01001973 s = zbc_num_shift(&cpa, maxrdx);
Gavin Howard01055ba2018-11-03 11:00:21 -06001974 if (s) goto err;
Denys Vlasenko29301232018-12-11 15:29:32 +01001975 s = zbc_num_shift(&cpb, maxrdx);
Gavin Howard01055ba2018-11-03 11:00:21 -06001976 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01001977 s = zbc_num_k(&cpa, &cpb, c);
Gavin Howard01055ba2018-11-03 11:00:21 -06001978 if (s) goto err;
1979
1980 maxrdx += scale;
1981 bc_num_expand(c, c->len + maxrdx);
1982
1983 if (c->len < maxrdx) {
1984 memset(c->num + c->len, 0, (c->cap - c->len) * sizeof(BcDig));
1985 c->len += maxrdx;
1986 }
1987
1988 c->rdx = maxrdx;
1989 bc_num_retireMul(c, scale, a->neg, b->neg);
1990
1991err:
1992 bc_num_free(&cpb);
1993 bc_num_free(&cpa);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001994 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06001995}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01001996#if ERRORS_ARE_FATAL
1997# define zbc_num_m(...) (zbc_num_m(__VA_ARGS__), BC_STATUS_SUCCESS)
1998#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06001999
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002000static FAST_FUNC BC_STATUS zbc_num_d(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
Gavin Howard01055ba2018-11-03 11:00:21 -06002001{
2002 BcStatus s = BC_STATUS_SUCCESS;
2003 BcDig *n, *p, q;
2004 size_t len, end, i;
2005 BcNum cp;
2006 bool zero = true;
2007
2008 if (b->len == 0)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002009 RETURN_STATUS(bc_error("divide by zero"));
2010 if (a->len == 0) {
Gavin Howard01055ba2018-11-03 11:00:21 -06002011 bc_num_setToZero(c, scale);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002012 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002013 }
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002014 if (BC_NUM_ONE(b)) {
Gavin Howard01055ba2018-11-03 11:00:21 -06002015 bc_num_copy(c, a);
2016 bc_num_retireMul(c, scale, a->neg, b->neg);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002017 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002018 }
2019
2020 bc_num_init(&cp, BC_NUM_MREQ(a, b, scale));
2021 bc_num_copy(&cp, a);
2022 len = b->len;
2023
2024 if (len > cp.len) {
2025 bc_num_expand(&cp, len + 2);
2026 bc_num_extend(&cp, len - cp.len);
2027 }
2028
2029 if (b->rdx > cp.rdx) bc_num_extend(&cp, b->rdx - cp.rdx);
2030 cp.rdx -= b->rdx;
2031 if (scale > cp.rdx) bc_num_extend(&cp, scale - cp.rdx);
2032
2033 if (b->rdx == b->len) {
2034 for (i = 0; zero && i < len; ++i) zero = !b->num[len - i - 1];
2035 len -= i - 1;
2036 }
2037
2038 if (cp.cap == cp.len) bc_num_expand(&cp, cp.len + 1);
2039
2040 // We want an extra zero in front to make things simpler.
2041 cp.num[cp.len++] = 0;
2042 end = cp.len - len;
2043
2044 bc_num_expand(c, cp.len);
2045
2046 bc_num_zero(c);
2047 memset(c->num + end, 0, (c->cap - end) * sizeof(BcDig));
2048 c->rdx = cp.rdx;
2049 c->len = cp.len;
2050 p = b->num;
2051
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01002052 for (i = end - 1; !s && i < end; --i) {
Gavin Howard01055ba2018-11-03 11:00:21 -06002053 n = cp.num + i;
2054 for (q = 0; (!s && n[len] != 0) || bc_num_compare(n, p, len) >= 0; ++q)
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01002055 bc_num_subArrays(n, p, len);
Gavin Howard01055ba2018-11-03 11:00:21 -06002056 c->num[i] = q;
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002057#if ENABLE_FEATURE_BC_SIGNALS
Denys Vlasenkof381a882018-12-05 19:21:34 +01002058 // a=2^100000
2059 // scale=40000
2060 // 1/a <- without check below, this will not be interruptible
2061 if (G_interrupt) {
2062 s = BC_STATUS_FAILURE;
2063 break;
2064 }
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002065#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002066 }
2067
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01002068 bc_num_retireMul(c, scale, a->neg, b->neg);
Gavin Howard01055ba2018-11-03 11:00:21 -06002069 bc_num_free(&cp);
2070
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002071 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002072}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002073#if ERRORS_ARE_FATAL
2074# define zbc_num_d(...) (zbc_num_d(__VA_ARGS__), BC_STATUS_SUCCESS)
2075#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002076
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002077static FAST_FUNC BC_STATUS zbc_num_r(BcNum *a, BcNum *b, BcNum *restrict c,
Gavin Howard01055ba2018-11-03 11:00:21 -06002078 BcNum *restrict d, size_t scale, size_t ts)
2079{
2080 BcStatus s;
2081 BcNum temp;
2082 bool neg;
2083
Denys Vlasenko60cf7472018-12-04 20:05:28 +01002084 if (b->len == 0)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002085 RETURN_STATUS(bc_error("divide by zero"));
Gavin Howard01055ba2018-11-03 11:00:21 -06002086
2087 if (a->len == 0) {
2088 bc_num_setToZero(d, ts);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002089 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002090 }
2091
2092 bc_num_init(&temp, d->cap);
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002093 s = zbc_num_d(a, b, c, scale);
Denys Vlasenkof381a882018-12-05 19:21:34 +01002094 if (s) goto err;
Gavin Howard01055ba2018-11-03 11:00:21 -06002095
2096 if (scale != 0) scale = ts;
2097
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002098 s = zbc_num_m(c, b, &temp, scale);
Gavin Howard01055ba2018-11-03 11:00:21 -06002099 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002100 s = zbc_num_sub(a, &temp, d, scale);
Gavin Howard01055ba2018-11-03 11:00:21 -06002101 if (s) goto err;
2102
2103 if (ts > d->rdx && d->len) bc_num_extend(d, ts - d->rdx);
2104
2105 neg = d->neg;
2106 bc_num_retireMul(d, ts, a->neg, b->neg);
2107 d->neg = neg;
2108
2109err:
2110 bc_num_free(&temp);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002111 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002112}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002113#if ERRORS_ARE_FATAL
2114# define zbc_num_r(...) (zbc_num_r(__VA_ARGS__), BC_STATUS_SUCCESS)
2115#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002116
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002117static FAST_FUNC BC_STATUS zbc_num_rem(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
Gavin Howard01055ba2018-11-03 11:00:21 -06002118{
2119 BcStatus s;
2120 BcNum c1;
2121 size_t ts = BC_MAX(scale + b->rdx, a->rdx), len = BC_NUM_MREQ(a, b, ts);
2122
2123 bc_num_init(&c1, len);
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002124 s = zbc_num_r(a, b, &c1, c, scale, ts);
Gavin Howard01055ba2018-11-03 11:00:21 -06002125 bc_num_free(&c1);
2126
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002127 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002128}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002129#if ERRORS_ARE_FATAL
2130# define zbc_num_rem(...) (zbc_num_rem(__VA_ARGS__), BC_STATUS_SUCCESS)
2131#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002132
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002133static FAST_FUNC BC_STATUS zbc_num_p(BcNum *a, BcNum *b, BcNum *restrict c, size_t scale)
Gavin Howard01055ba2018-11-03 11:00:21 -06002134{
2135 BcStatus s = BC_STATUS_SUCCESS;
2136 BcNum copy;
2137 unsigned long pow;
2138 size_t i, powrdx, resrdx;
2139 bool neg, zero;
2140
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002141 if (b->rdx) RETURN_STATUS(bc_error("non integer number"));
Gavin Howard01055ba2018-11-03 11:00:21 -06002142
2143 if (b->len == 0) {
2144 bc_num_one(c);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002145 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002146 }
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002147 if (a->len == 0) {
Gavin Howard01055ba2018-11-03 11:00:21 -06002148 bc_num_setToZero(c, scale);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002149 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002150 }
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002151 if (BC_NUM_ONE(b)) {
Gavin Howard01055ba2018-11-03 11:00:21 -06002152 if (!b->neg)
2153 bc_num_copy(c, a);
2154 else
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002155 s = zbc_num_inv(a, c, scale);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002156 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002157 }
2158
2159 neg = b->neg;
2160 b->neg = false;
2161
Denys Vlasenko29301232018-12-11 15:29:32 +01002162 s = zbc_num_ulong(b, &pow);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002163 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002164
2165 bc_num_init(&copy, a->len);
2166 bc_num_copy(&copy, a);
2167
Denys Vlasenko2d615fe2018-12-07 16:22:45 +01002168 if (!neg) {
2169 if (a->rdx > scale)
2170 scale = a->rdx;
2171 if (a->rdx * pow < scale)
2172 scale = a->rdx * pow;
2173 }
Gavin Howard01055ba2018-11-03 11:00:21 -06002174
2175 b->neg = neg;
2176
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01002177 for (powrdx = a->rdx; !(pow & 1); pow >>= 1) {
Gavin Howard01055ba2018-11-03 11:00:21 -06002178 powrdx <<= 1;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002179 s = zbc_num_mul(&copy, &copy, &copy, powrdx);
Gavin Howard01055ba2018-11-03 11:00:21 -06002180 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002181 // Not needed: zbc_num_mul() has a check for ^C:
Denys Vlasenko06fa65b2018-12-05 19:00:58 +01002182 //if (G_interrupt) {
2183 // s = BC_STATUS_FAILURE;
2184 // goto err;
2185 //}
Gavin Howard01055ba2018-11-03 11:00:21 -06002186 }
2187
Gavin Howard01055ba2018-11-03 11:00:21 -06002188 bc_num_copy(c, &copy);
2189
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01002190 for (resrdx = powrdx, pow >>= 1; pow != 0; pow >>= 1) {
Gavin Howard01055ba2018-11-03 11:00:21 -06002191
2192 powrdx <<= 1;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002193 s = zbc_num_mul(&copy, &copy, &copy, powrdx);
Gavin Howard01055ba2018-11-03 11:00:21 -06002194 if (s) goto err;
2195
2196 if (pow & 1) {
2197 resrdx += powrdx;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002198 s = zbc_num_mul(c, &copy, c, resrdx);
Gavin Howard01055ba2018-11-03 11:00:21 -06002199 if (s) goto err;
2200 }
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002201 // Not needed: zbc_num_mul() has a check for ^C:
Denys Vlasenko06fa65b2018-12-05 19:00:58 +01002202 //if (G_interrupt) {
2203 // s = BC_STATUS_FAILURE;
2204 // goto err;
2205 //}
Gavin Howard01055ba2018-11-03 11:00:21 -06002206 }
2207
2208 if (neg) {
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002209 s = zbc_num_inv(c, c, scale);
Gavin Howard01055ba2018-11-03 11:00:21 -06002210 if (s) goto err;
2211 }
2212
Gavin Howard01055ba2018-11-03 11:00:21 -06002213 if (c->rdx > scale) bc_num_truncate(c, c->rdx - scale);
2214
2215 // We can't use bc_num_clean() here.
2216 for (zero = true, i = 0; zero && i < c->len; ++i) zero = !c->num[i];
2217 if (zero) bc_num_setToZero(c, scale);
2218
2219err:
2220 bc_num_free(&copy);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002221 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002222}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002223#if ERRORS_ARE_FATAL
2224# define zbc_num_p(...) (zbc_num_p(__VA_ARGS__), BC_STATUS_SUCCESS)
2225#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002226
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002227static BC_STATUS zbc_num_binary(BcNum *a, BcNum *b, BcNum *c, size_t scale,
Gavin Howard01055ba2018-11-03 11:00:21 -06002228 BcNumBinaryOp op, size_t req)
2229{
2230 BcStatus s;
2231 BcNum num2, *ptr_a, *ptr_b;
2232 bool init = false;
2233
2234 if (c == a) {
2235 ptr_a = &num2;
2236 memcpy(ptr_a, c, sizeof(BcNum));
2237 init = true;
2238 }
2239 else
2240 ptr_a = a;
2241
2242 if (c == b) {
2243 ptr_b = &num2;
2244 if (c != a) {
2245 memcpy(ptr_b, c, sizeof(BcNum));
2246 init = true;
2247 }
2248 }
2249 else
2250 ptr_b = b;
2251
2252 if (init)
2253 bc_num_init(c, req);
2254 else
2255 bc_num_expand(c, req);
2256
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002257 s = BC_STATUS_SUCCESS;
Denys Vlasenko26819db2018-12-12 16:08:46 +01002258 ERROR_RETURN(s =) op(ptr_a, ptr_b, c, scale);
Gavin Howard01055ba2018-11-03 11:00:21 -06002259
2260 if (init) bc_num_free(&num2);
2261
Denys Vlasenko29301232018-12-11 15:29:32 +01002262 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002263}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01002264#if ERRORS_ARE_FATAL
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002265# define zbc_num_binary(...) (zbc_num_binary(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01002266#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002267
Denys Vlasenko9311e012018-12-10 11:54:18 +01002268static bool bc_num_strValid(const char *val, size_t base)
2269{
2270 BcDig b;
2271 bool radix;
2272
2273 b = (BcDig)(base <= 10 ? base + '0' : base - 10 + 'A');
2274 radix = false;
2275 for (;;) {
2276 BcDig c = *val++;
2277 if (c == '\0')
2278 break;
2279 if (c == '.') {
2280 if (radix) return false;
2281 radix = true;
2282 continue;
2283 }
2284 if (c < '0' || c >= b || (c > '9' && c < 'A'))
2285 return false;
2286 }
2287 return true;
2288}
2289
2290// Note: n is already "bc_num_zero()"ed,
2291// leading zeroes in "val" are removed
2292static void bc_num_parseDecimal(BcNum *n, const char *val)
2293{
2294 size_t len, i;
2295 const char *ptr;
Denys Vlasenko9311e012018-12-10 11:54:18 +01002296
2297 len = strlen(val);
2298 if (len == 0)
2299 return;
2300
Denys Vlasenko9311e012018-12-10 11:54:18 +01002301 bc_num_expand(n, len);
2302
2303 ptr = strchr(val, '.');
2304
2305 n->rdx = 0;
2306 if (ptr != NULL)
2307 n->rdx = (size_t)((val + len) - (ptr + 1));
2308
Denys Vlasenkodafbc2c2018-12-10 15:38:52 +01002309 for (i = 0; val[i]; ++i) {
2310 if (val[i] != '0' && val[i] != '.') {
2311 // Not entirely zero value - convert it, and exit
2312 i = len - 1;
2313 for (;;) {
2314 n->num[n->len] = val[i] - '0';
2315 ++n->len;
Denys Vlasenko9311e012018-12-10 11:54:18 +01002316 skip_dot:
Denys Vlasenko87b49be2018-12-14 16:24:01 +01002317 if (i == 0) break;
2318 if (val[--i] == '.') goto skip_dot;
Denys Vlasenkodafbc2c2018-12-10 15:38:52 +01002319 }
2320 break;
Denys Vlasenko9311e012018-12-10 11:54:18 +01002321 }
2322 }
Denys Vlasenko87b49be2018-12-14 16:24:01 +01002323 // if for() exits without hitting if(), the value is entirely zero
Denys Vlasenko9311e012018-12-10 11:54:18 +01002324}
2325
2326// Note: n is already "bc_num_zero()"ed,
2327// leading zeroes in "val" are removed
2328static void bc_num_parseBase(BcNum *n, const char *val, BcNum *base)
2329{
2330 BcStatus s;
2331 BcNum temp, mult, result;
2332 BcDig c = '\0';
2333 unsigned long v;
2334 size_t i, digits;
2335
2336 for (i = 0; ; ++i) {
2337 if (val[i] == '\0')
2338 return;
2339 if (val[i] != '.' && val[i] != '0')
2340 break;
2341 }
2342
2343 bc_num_init_DEF_SIZE(&temp);
2344 bc_num_init_DEF_SIZE(&mult);
2345
2346 for (;;) {
2347 c = *val++;
2348 if (c == '\0') goto int_err;
2349 if (c == '.') break;
2350
2351 v = (unsigned long) (c <= '9' ? c - '0' : c - 'A' + 10);
2352
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002353 s = zbc_num_mul(n, base, &mult, 0);
Denys Vlasenko9311e012018-12-10 11:54:18 +01002354 if (s) goto int_err;
2355 bc_num_ulong2num(&temp, v);
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002356 s = zbc_num_add(&mult, &temp, n, 0);
Denys Vlasenko9311e012018-12-10 11:54:18 +01002357 if (s) goto int_err;
2358 }
2359
2360 bc_num_init(&result, base->len);
2361 //bc_num_zero(&result); - already is
2362 bc_num_one(&mult);
2363
2364 digits = 0;
2365 for (;;) {
2366 c = *val++;
2367 if (c == '\0') break;
2368 digits++;
2369
2370 v = (unsigned long) (c <= '9' ? c - '0' : c - 'A' + 10);
2371
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002372 s = zbc_num_mul(&result, base, &result, 0);
Denys Vlasenko9311e012018-12-10 11:54:18 +01002373 if (s) goto err;
2374 bc_num_ulong2num(&temp, v);
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002375 s = zbc_num_add(&result, &temp, &result, 0);
Denys Vlasenko9311e012018-12-10 11:54:18 +01002376 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002377 s = zbc_num_mul(&mult, base, &mult, 0);
Denys Vlasenko9311e012018-12-10 11:54:18 +01002378 if (s) goto err;
2379 }
2380
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002381 s = zbc_num_div(&result, &mult, &result, digits);
Denys Vlasenko9311e012018-12-10 11:54:18 +01002382 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002383 s = zbc_num_add(n, &result, n, digits);
Denys Vlasenko9311e012018-12-10 11:54:18 +01002384 if (s) goto err;
2385
2386 if (n->len != 0) {
2387 if (n->rdx < digits) bc_num_extend(n, digits - n->rdx);
2388 } else
2389 bc_num_zero(n);
2390
2391err:
2392 bc_num_free(&result);
2393int_err:
2394 bc_num_free(&mult);
2395 bc_num_free(&temp);
2396}
2397
Denys Vlasenko29301232018-12-11 15:29:32 +01002398static BC_STATUS zbc_num_parse(BcNum *n, const char *val, BcNum *base,
Gavin Howard01055ba2018-11-03 11:00:21 -06002399 size_t base_t)
2400{
Denys Vlasenko60cf7472018-12-04 20:05:28 +01002401 if (!bc_num_strValid(val, base_t))
Denys Vlasenko29301232018-12-11 15:29:32 +01002402 RETURN_STATUS(bc_error("bad number string"));
Gavin Howard01055ba2018-11-03 11:00:21 -06002403
Denys Vlasenko4a024c72018-12-09 13:21:54 +01002404 bc_num_zero(n);
2405 while (*val == '0') val++;
2406
Gavin Howard01055ba2018-11-03 11:00:21 -06002407 if (base_t == 10)
2408 bc_num_parseDecimal(n, val);
2409 else
2410 bc_num_parseBase(n, val, base);
2411
Denys Vlasenko29301232018-12-11 15:29:32 +01002412 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002413}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01002414#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01002415# define zbc_num_parse(...) (zbc_num_parse(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01002416#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002417
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002418static BC_STATUS zbc_num_sqrt(BcNum *a, BcNum *restrict b, size_t scale)
Gavin Howard01055ba2018-11-03 11:00:21 -06002419{
2420 BcStatus s;
2421 BcNum num1, num2, half, f, fprime, *x0, *x1, *temp;
2422 size_t pow, len, digs, digs1, resrdx, req, times = 0;
2423 ssize_t cmp = 1, cmp1 = SSIZE_MAX, cmp2 = SSIZE_MAX;
2424
2425 req = BC_MAX(scale, a->rdx) + ((BC_NUM_INT(a) + 1) >> 1) + 1;
2426 bc_num_expand(b, req);
2427
2428 if (a->len == 0) {
2429 bc_num_setToZero(b, scale);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002430 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002431 }
2432 else if (a->neg)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002433 RETURN_STATUS(bc_error("negative number"));
Gavin Howard01055ba2018-11-03 11:00:21 -06002434 else if (BC_NUM_ONE(a)) {
2435 bc_num_one(b);
2436 bc_num_extend(b, scale);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002437 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002438 }
2439
2440 scale = BC_MAX(scale, a->rdx) + 1;
2441 len = a->len + scale;
2442
2443 bc_num_init(&num1, len);
2444 bc_num_init(&num2, len);
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01002445 bc_num_init_DEF_SIZE(&half);
Gavin Howard01055ba2018-11-03 11:00:21 -06002446
2447 bc_num_one(&half);
2448 half.num[0] = 5;
2449 half.rdx = 1;
2450
2451 bc_num_init(&f, len);
2452 bc_num_init(&fprime, len);
2453
2454 x0 = &num1;
2455 x1 = &num2;
2456
2457 bc_num_one(x0);
2458 pow = BC_NUM_INT(a);
2459
2460 if (pow) {
2461
2462 if (pow & 1)
2463 x0->num[0] = 2;
2464 else
2465 x0->num[0] = 6;
2466
2467 pow -= 2 - (pow & 1);
2468
2469 bc_num_extend(x0, pow);
2470
2471 // Make sure to move the radix back.
2472 x0->rdx -= pow;
2473 }
2474
2475 x0->rdx = digs = digs1 = 0;
2476 resrdx = scale + 2;
2477 len = BC_NUM_INT(x0) + resrdx - 1;
2478
Denys Vlasenko71e1fc62018-12-02 19:43:34 +01002479 while (cmp != 0 || digs < len) {
Gavin Howard01055ba2018-11-03 11:00:21 -06002480
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002481 s = zbc_num_div(a, x0, &f, resrdx);
Gavin Howard01055ba2018-11-03 11:00:21 -06002482 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002483 s = zbc_num_add(x0, &f, &fprime, resrdx);
Gavin Howard01055ba2018-11-03 11:00:21 -06002484 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002485 s = zbc_num_mul(&fprime, &half, x1, resrdx);
Gavin Howard01055ba2018-11-03 11:00:21 -06002486 if (s) goto err;
2487
2488 cmp = bc_num_cmp(x1, x0);
2489 digs = x1->len - (unsigned long long) llabs(cmp);
2490
2491 if (cmp == cmp2 && digs == digs1)
2492 times += 1;
2493 else
2494 times = 0;
2495
2496 resrdx += times > 4;
2497
2498 cmp2 = cmp1;
2499 cmp1 = cmp;
2500 digs1 = digs;
2501
2502 temp = x0;
2503 x0 = x1;
2504 x1 = temp;
2505 }
2506
Gavin Howard01055ba2018-11-03 11:00:21 -06002507 bc_num_copy(b, x0);
2508 scale -= 1;
2509 if (b->rdx > scale) bc_num_truncate(b, b->rdx - scale);
2510
2511err:
2512 bc_num_free(&fprime);
2513 bc_num_free(&f);
2514 bc_num_free(&half);
2515 bc_num_free(&num2);
2516 bc_num_free(&num1);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002517 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002518}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002519#if ERRORS_ARE_FATAL
2520# define zbc_num_sqrt(...) (zbc_num_sqrt(__VA_ARGS__), BC_STATUS_SUCCESS)
2521#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002522
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002523static BC_STATUS zbc_num_divmod(BcNum *a, BcNum *b, BcNum *c, BcNum *d,
Gavin Howard01055ba2018-11-03 11:00:21 -06002524 size_t scale)
2525{
2526 BcStatus s;
2527 BcNum num2, *ptr_a;
2528 bool init = false;
2529 size_t ts = BC_MAX(scale + b->rdx, a->rdx), len = BC_NUM_MREQ(a, b, ts);
2530
2531 if (c == a) {
2532 memcpy(&num2, c, sizeof(BcNum));
2533 ptr_a = &num2;
2534 bc_num_init(c, len);
2535 init = true;
2536 }
2537 else {
2538 ptr_a = a;
2539 bc_num_expand(c, len);
2540 }
2541
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002542 s = zbc_num_r(ptr_a, b, c, d, scale, ts);
Gavin Howard01055ba2018-11-03 11:00:21 -06002543
2544 if (init) bc_num_free(&num2);
2545
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002546 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002547}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002548#if ERRORS_ARE_FATAL
2549# define zbc_num_divmod(...) (zbc_num_divmod(__VA_ARGS__), BC_STATUS_SUCCESS)
2550#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002551
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01002552#if ENABLE_DC
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002553static BC_STATUS zbc_num_modexp(BcNum *a, BcNum *b, BcNum *c, BcNum *restrict d)
Gavin Howard01055ba2018-11-03 11:00:21 -06002554{
2555 BcStatus s;
2556 BcNum base, exp, two, temp;
2557
Denys Vlasenko60cf7472018-12-04 20:05:28 +01002558 if (c->len == 0)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002559 RETURN_STATUS(bc_error("divide by zero"));
Denys Vlasenko60cf7472018-12-04 20:05:28 +01002560 if (a->rdx || b->rdx || c->rdx)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002561 RETURN_STATUS(bc_error("non integer number"));
Denys Vlasenko60cf7472018-12-04 20:05:28 +01002562 if (b->neg)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002563 RETURN_STATUS(bc_error("negative number"));
Gavin Howard01055ba2018-11-03 11:00:21 -06002564
2565 bc_num_expand(d, c->len);
2566 bc_num_init(&base, c->len);
2567 bc_num_init(&exp, b->len);
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01002568 bc_num_init_DEF_SIZE(&two);
Gavin Howard01055ba2018-11-03 11:00:21 -06002569 bc_num_init(&temp, b->len);
2570
2571 bc_num_one(&two);
2572 two.num[0] = 2;
2573 bc_num_one(d);
2574
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002575 s = zbc_num_rem(a, c, &base, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06002576 if (s) goto err;
2577 bc_num_copy(&exp, b);
2578
2579 while (exp.len != 0) {
2580
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002581 s = zbc_num_divmod(&exp, &two, &exp, &temp, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06002582 if (s) goto err;
2583
2584 if (BC_NUM_ONE(&temp)) {
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002585 s = zbc_num_mul(d, &base, &temp, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06002586 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002587 s = zbc_num_rem(&temp, c, d, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06002588 if (s) goto err;
2589 }
2590
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002591 s = zbc_num_mul(&base, &base, &temp, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06002592 if (s) goto err;
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01002593 s = zbc_num_rem(&temp, c, &base, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06002594 if (s) goto err;
2595 }
2596
2597err:
2598 bc_num_free(&temp);
2599 bc_num_free(&two);
2600 bc_num_free(&exp);
2601 bc_num_free(&base);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002602 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06002603}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01002604#if ERRORS_ARE_FATAL
2605# define zbc_num_modexp(...) (zbc_num_modexp(__VA_ARGS__), BC_STATUS_SUCCESS)
2606#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002607#endif // ENABLE_DC
2608
Denys Vlasenko23c2e9f2018-12-06 11:43:17 +01002609#if ENABLE_BC
Denys Vlasenko29301232018-12-11 15:29:32 +01002610static BC_STATUS zbc_func_insert(BcFunc *f, char *name, bool var)
Gavin Howard01055ba2018-11-03 11:00:21 -06002611{
2612 BcId a;
2613 size_t i;
2614
2615 for (i = 0; i < f->autos.len; ++i) {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01002616 if (strcmp(name, ((BcId *) bc_vec_item(&f->autos, i))->name) == 0)
Denys Vlasenko29301232018-12-11 15:29:32 +01002617 RETURN_STATUS(bc_error("function parameter or auto var has the same name as another"));
Gavin Howard01055ba2018-11-03 11:00:21 -06002618 }
2619
2620 a.idx = var;
2621 a.name = name;
2622
2623 bc_vec_push(&f->autos, &a);
2624
Denys Vlasenko29301232018-12-11 15:29:32 +01002625 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002626}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01002627#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01002628# define zbc_func_insert(...) (zbc_func_insert(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01002629#endif
Denys Vlasenko23c2e9f2018-12-06 11:43:17 +01002630#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002631
2632static void bc_func_init(BcFunc *f)
2633{
Denys Vlasenko7d628012018-12-04 21:46:47 +01002634 bc_char_vec_init(&f->code);
Gavin Howard01055ba2018-11-03 11:00:21 -06002635 bc_vec_init(&f->autos, sizeof(BcId), bc_id_free);
2636 bc_vec_init(&f->labels, sizeof(size_t), NULL);
2637 f->nparams = 0;
2638}
2639
Denys Vlasenko5ba55f12018-12-10 15:37:14 +01002640static FAST_FUNC void bc_func_free(void *func)
Gavin Howard01055ba2018-11-03 11:00:21 -06002641{
2642 BcFunc *f = (BcFunc *) func;
2643 bc_vec_free(&f->code);
2644 bc_vec_free(&f->autos);
2645 bc_vec_free(&f->labels);
2646}
2647
Denys Vlasenkob0e37612018-12-05 21:03:16 +01002648static void bc_array_expand(BcVec *a, size_t len);
2649
Gavin Howard01055ba2018-11-03 11:00:21 -06002650static void bc_array_init(BcVec *a, bool nums)
2651{
2652 if (nums)
2653 bc_vec_init(a, sizeof(BcNum), bc_num_free);
2654 else
2655 bc_vec_init(a, sizeof(BcVec), bc_vec_free);
2656 bc_array_expand(a, 1);
2657}
2658
Gavin Howard01055ba2018-11-03 11:00:21 -06002659static void bc_array_expand(BcVec *a, size_t len)
2660{
2661 BcResultData data;
2662
2663 if (a->size == sizeof(BcNum) && a->dtor == bc_num_free) {
2664 while (len > a->len) {
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01002665 bc_num_init_DEF_SIZE(&data.n);
Gavin Howard01055ba2018-11-03 11:00:21 -06002666 bc_vec_push(a, &data.n);
2667 }
2668 }
2669 else {
2670 while (len > a->len) {
2671 bc_array_init(&data.v, true);
2672 bc_vec_push(a, &data.v);
2673 }
2674 }
2675}
2676
Denys Vlasenkob0e37612018-12-05 21:03:16 +01002677static void bc_array_copy(BcVec *d, const BcVec *s)
2678{
2679 size_t i;
2680
2681 bc_vec_pop_all(d);
2682 bc_vec_expand(d, s->cap);
2683 d->len = s->len;
2684
2685 for (i = 0; i < s->len; ++i) {
2686 BcNum *dnum = bc_vec_item(d, i), *snum = bc_vec_item(s, i);
2687 bc_num_init(dnum, snum->len);
2688 bc_num_copy(dnum, snum);
2689 }
2690}
2691
Denys Vlasenko5ba55f12018-12-10 15:37:14 +01002692static FAST_FUNC void bc_string_free(void *string)
Gavin Howard01055ba2018-11-03 11:00:21 -06002693{
2694 free(*((char **) string));
2695}
2696
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01002697#if ENABLE_DC
Gavin Howard01055ba2018-11-03 11:00:21 -06002698static void bc_result_copy(BcResult *d, BcResult *src)
2699{
2700 d->t = src->t;
2701
2702 switch (d->t) {
2703
2704 case BC_RESULT_TEMP:
2705 case BC_RESULT_IBASE:
2706 case BC_RESULT_SCALE:
2707 case BC_RESULT_OBASE:
2708 {
2709 bc_num_init(&d->d.n, src->d.n.len);
2710 bc_num_copy(&d->d.n, &src->d.n);
2711 break;
2712 }
2713
2714 case BC_RESULT_VAR:
2715 case BC_RESULT_ARRAY:
2716 case BC_RESULT_ARRAY_ELEM:
2717 {
2718 d->d.id.name = xstrdup(src->d.id.name);
2719 break;
2720 }
2721
2722 case BC_RESULT_CONSTANT:
2723 case BC_RESULT_LAST:
2724 case BC_RESULT_ONE:
2725 case BC_RESULT_STR:
2726 {
2727 memcpy(&d->d.n, &src->d.n, sizeof(BcNum));
2728 break;
2729 }
2730 }
2731}
2732#endif // ENABLE_DC
2733
Denys Vlasenko5ba55f12018-12-10 15:37:14 +01002734static FAST_FUNC void bc_result_free(void *result)
Gavin Howard01055ba2018-11-03 11:00:21 -06002735{
2736 BcResult *r = (BcResult *) result;
2737
2738 switch (r->t) {
2739
2740 case BC_RESULT_TEMP:
2741 case BC_RESULT_IBASE:
2742 case BC_RESULT_SCALE:
2743 case BC_RESULT_OBASE:
2744 {
2745 bc_num_free(&r->d.n);
2746 break;
2747 }
2748
2749 case BC_RESULT_VAR:
2750 case BC_RESULT_ARRAY:
2751 case BC_RESULT_ARRAY_ELEM:
2752 {
2753 free(r->d.id.name);
2754 break;
2755 }
2756
2757 default:
2758 {
2759 // Do nothing.
2760 break;
2761 }
2762 }
2763}
2764
2765static void bc_lex_lineComment(BcLex *l)
2766{
2767 l->t.t = BC_LEX_WHITESPACE;
2768 while (l->i < l->len && l->buf[l->i++] != '\n');
2769 --l->i;
2770}
2771
2772static void bc_lex_whitespace(BcLex *l)
2773{
Gavin Howard01055ba2018-11-03 11:00:21 -06002774 l->t.t = BC_LEX_WHITESPACE;
Denys Vlasenko89198a92018-12-13 21:31:29 +01002775 for (;;) {
2776 char c = l->buf[l->i];
Denys Vlasenko9dc5d082018-12-16 18:43:51 +01002777 if (c == '\n') // this is BC_LEX_NLINE, not BC_LEX_WHITESPACE
2778 break;
2779 if (!isspace(c))
Denys Vlasenko89198a92018-12-13 21:31:29 +01002780 break;
2781 l->i++;
2782 }
Gavin Howard01055ba2018-11-03 11:00:21 -06002783}
2784
Denys Vlasenko29301232018-12-11 15:29:32 +01002785static BC_STATUS zbc_lex_number(BcLex *l, char start)
Gavin Howard01055ba2018-11-03 11:00:21 -06002786{
2787 const char *buf = l->buf + l->i;
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002788 size_t len, bslashes, i, ccnt;
2789 bool pt;
Gavin Howard01055ba2018-11-03 11:00:21 -06002790
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002791 pt = (start == '.');
Gavin Howard01055ba2018-11-03 11:00:21 -06002792 l->t.t = BC_LEX_NUMBER;
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002793 bslashes = 0;
2794 ccnt = i = 0;
2795 for (;;) {
2796 char c = buf[i];
2797 if (c == '\0')
2798 break;
2799 if (c == '\\' && buf[i + 1] == '\n') {
2800 i += 2;
2801 bslashes++;
2802 continue;
Gavin Howard01055ba2018-11-03 11:00:21 -06002803 }
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002804 if (!isdigit(c) && (c < 'A' || c > 'F')) {
2805 if (c != '.') break;
2806 // if '.' was already seen, stop on second one:
2807 if (pt) break;
2808 pt = 1;
Gavin Howard01055ba2018-11-03 11:00:21 -06002809 }
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002810 // buf[i] is one of "0-9A-F."
2811 i++;
2812 if (c != '.')
2813 ccnt = i;
Gavin Howard01055ba2018-11-03 11:00:21 -06002814 }
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002815 //i is buf[i] index of the first not-yet-parsed char
2816 l->i += i;
Gavin Howard01055ba2018-11-03 11:00:21 -06002817
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002818 //ccnt is the number of chars in the number string, excluding possible
2819 //trailing "." and possible following trailing "\<newline>"(s).
2820 len = ccnt - bslashes * 2 + 1; // +1 byte for NUL termination
2821
Denys Vlasenko64074a12018-12-07 15:50:14 +01002822 // This check makes sense only if size_t is (much) larger than BC_MAX_NUM.
2823 if (SIZE_MAX > (BC_MAX_NUM | 0xff)) {
2824 if (len > BC_MAX_NUM)
Denys Vlasenko29301232018-12-11 15:29:32 +01002825 RETURN_STATUS(bc_error("number too long: must be [1,"BC_MAX_NUM_STR"]"));
Denys Vlasenko64074a12018-12-07 15:50:14 +01002826 }
Gavin Howard01055ba2018-11-03 11:00:21 -06002827
Denys Vlasenko7d628012018-12-04 21:46:47 +01002828 bc_vec_pop_all(&l->t.v);
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002829 bc_vec_expand(&l->t.v, 1 + len);
Gavin Howard01055ba2018-11-03 11:00:21 -06002830 bc_vec_push(&l->t.v, &start);
2831
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002832 while (ccnt != 0) {
Gavin Howard01055ba2018-11-03 11:00:21 -06002833 // If we have hit a backslash, skip it. We don't have
2834 // to check for a newline because it's guaranteed.
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002835 if (*buf == '\\') {
2836 buf += 2;
2837 ccnt -= 2;
Gavin Howard01055ba2018-11-03 11:00:21 -06002838 continue;
2839 }
Denys Vlasenkoc355c4a2018-12-11 17:36:21 +01002840 bc_vec_push(&l->t.v, buf);
2841 buf++;
2842 ccnt--;
Gavin Howard01055ba2018-11-03 11:00:21 -06002843 }
2844
Denys Vlasenko08c033c2018-12-05 16:55:08 +01002845 bc_vec_pushZeroByte(&l->t.v);
Gavin Howard01055ba2018-11-03 11:00:21 -06002846
Denys Vlasenko29301232018-12-11 15:29:32 +01002847 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06002848}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01002849#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01002850# define zbc_lex_number(...) (zbc_lex_number(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01002851#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002852
Denys Vlasenko88cfea62018-12-10 20:26:04 +01002853static void bc_lex_name(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06002854{
Denys Vlasenko88cfea62018-12-10 20:26:04 +01002855 size_t i;
2856 const char *buf;
Gavin Howard01055ba2018-11-03 11:00:21 -06002857
2858 l->t.t = BC_LEX_NAME;
2859
Denys Vlasenko88cfea62018-12-10 20:26:04 +01002860 i = 0;
2861 buf = l->buf + l->i - 1;
2862 for (;;) {
2863 char c = buf[i];
2864 if ((c < 'a' || c > 'z') && !isdigit(c) && c != '_') break;
2865 i++;
2866 }
Gavin Howard01055ba2018-11-03 11:00:21 -06002867
Denys Vlasenko88cfea62018-12-10 20:26:04 +01002868#if 0 // We do not protect against people with gigabyte-long names
Denys Vlasenko64074a12018-12-07 15:50:14 +01002869 // This check makes sense only if size_t is (much) larger than BC_MAX_STRING.
2870 if (SIZE_MAX > (BC_MAX_STRING | 0xff)) {
2871 if (i > BC_MAX_STRING)
2872 return bc_error("name too long: must be [1,"BC_MAX_STRING_STR"]");
2873 }
Denys Vlasenko88cfea62018-12-10 20:26:04 +01002874#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06002875 bc_vec_string(&l->t.v, i, buf);
2876
2877 // Increment the index. We minus 1 because it has already been incremented.
2878 l->i += i - 1;
2879
Denys Vlasenko88cfea62018-12-10 20:26:04 +01002880 //return BC_STATUS_SUCCESS;
Gavin Howard01055ba2018-11-03 11:00:21 -06002881}
2882
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01002883static void bc_lex_init(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06002884{
Denys Vlasenko7d628012018-12-04 21:46:47 +01002885 bc_char_vec_init(&l->t.v);
Gavin Howard01055ba2018-11-03 11:00:21 -06002886}
2887
2888static void bc_lex_free(BcLex *l)
2889{
2890 bc_vec_free(&l->t.v);
2891}
2892
Denys Vlasenko0409ad32018-12-05 16:39:22 +01002893static void bc_lex_file(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06002894{
Denys Vlasenko5318f812018-12-05 17:48:01 +01002895 G.err_line = l->line = 1;
Gavin Howard01055ba2018-11-03 11:00:21 -06002896 l->newline = false;
Gavin Howard01055ba2018-11-03 11:00:21 -06002897}
2898
Denys Vlasenkoe755e302018-12-13 22:25:28 +01002899IF_BC(static BC_STATUS zbc_lex_token(BcLex *l);)
2900IF_DC(static BC_STATUS zdc_lex_token(BcLex *l);)
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01002901
2902static BC_STATUS zcommon_lex_token(BcLex *l)
2903{
2904 if (IS_BC) {
2905 IF_BC(RETURN_STATUS(zbc_lex_token(l));)
2906 }
2907 IF_DC(RETURN_STATUS(zdc_lex_token(l));)
2908}
2909
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01002910static bool bc_lex_more_input(BcLex *l)
2911{
2912 size_t str;
2913 bool comment;
2914
2915 bc_vec_pop_all(&G.stdin_buffer);
2916
2917 // This loop is complex because the vm tries not to send any lines that end
2918 // with a backslash to the parser. The reason for that is because the parser
2919 // treats a backslash+newline combo as whitespace, per the bc spec. In that
2920 // case, and for strings and comments, the parser will expect more stuff.
2921 comment = false;
2922 str = 0;
2923 for (;;) {
2924 size_t prevlen = G.stdin_buffer.len;
2925 char *string;
2926
2927 bc_read_line(&G.stdin_buffer);
2928 // No more input means EOF
2929 if (G.stdin_buffer.len <= prevlen + 1) // (we expect +1 for NUL byte)
2930 break;
2931
2932 string = G.stdin_buffer.v + prevlen;
2933 while (*string) {
2934 char c = *string;
2935 if (string == G.stdin_buffer.v || string[-1] != '\\') {
2936 if (IS_BC)
2937 str ^= (c == '"');
2938 else {
2939 if (c == ']')
2940 str -= 1;
2941 else if (c == '[')
2942 str += 1;
2943 }
2944 }
2945 string++;
2946 if (c == '/' && *string == '*') {
2947 comment = true;
2948 string++;
2949 continue;
2950 }
2951 if (c == '*' && *string == '/') {
2952 comment = false;
2953 string++;
2954 }
2955 }
2956 if (str != 0 || comment) {
2957 G.stdin_buffer.len--; // backstep over the trailing NUL byte
2958 continue;
2959 }
2960
2961 // Check for backslash+newline.
2962 // we do not check that last char is '\n' -
2963 // if it is not, then it's EOF, and looping back
2964 // to bc_read_line() will detect it:
2965 string -= 2;
2966 if (string >= G.stdin_buffer.v && *string == '\\') {
2967 G.stdin_buffer.len--;
2968 continue;
2969 }
2970
2971 break;
2972 }
2973
2974 l->buf = G.stdin_buffer.v;
2975 l->i = 0;
2976//bb_error_msg("G.stdin_buffer.len:%d '%s'", G.stdin_buffer.len, G.stdin_buffer.v);
2977 l->len = G.stdin_buffer.len - 1; // do not include NUL
2978
2979 G.use_stdin = (l->len != 0);
2980 return G.use_stdin;
2981}
2982
Denys Vlasenko9a34e892018-12-12 13:58:55 +01002983static BC_STATUS zbc_lex_next(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06002984{
2985 BcStatus s;
2986
2987 l->t.last = l->t.t;
Denys Vlasenko9a34e892018-12-12 13:58:55 +01002988 if (l->t.last == BC_LEX_EOF) RETURN_STATUS(bc_error("end of file"));
Gavin Howard01055ba2018-11-03 11:00:21 -06002989
2990 l->line += l->newline;
Denys Vlasenko5318f812018-12-05 17:48:01 +01002991 G.err_line = l->line;
Gavin Howard01055ba2018-11-03 11:00:21 -06002992
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01002993 l->t.t = BC_LEX_EOF;
2994//this NL handling is bogus
Gavin Howard01055ba2018-11-03 11:00:21 -06002995 l->newline = (l->i == l->len);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01002996 if (l->newline) {
2997 if (!G.use_stdin || !bc_lex_more_input(l))
2998 RETURN_STATUS(BC_STATUS_SUCCESS);
2999 // here it's guaranteed that l->i is below l->len
3000 l->newline = false;
3001 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003002
3003 // Loop until failure or we don't have whitespace. This
3004 // is so the parser doesn't get inundated with whitespace.
Denys Vlasenko9dc5d082018-12-16 18:43:51 +01003005 // Comments are also BC_LEX_WHITESPACE tokens and eaten here.
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003006 s = BC_STATUS_SUCCESS;
Gavin Howard01055ba2018-11-03 11:00:21 -06003007 do {
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01003008 dbg_lex("next string to parse:'%.*s'",
Denys Vlasenko0a238142018-12-14 16:48:34 +01003009 (int)(strchrnul(l->buf + l->i, '\n') - (l->buf + l->i)),
3010 l->buf + l->i);
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01003011 ERROR_RETURN(s =) zcommon_lex_token(l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003012 } while (!s && l->t.t == BC_LEX_WHITESPACE);
Denys Vlasenko17df8822018-12-14 23:00:24 +01003013 dbg_lex("l->t.t from string:%d", l->t.t);
Gavin Howard01055ba2018-11-03 11:00:21 -06003014
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003015 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003016}
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003017#if ERRORS_ARE_FATAL
3018# define zbc_lex_next(...) (zbc_lex_next(__VA_ARGS__), BC_STATUS_SUCCESS)
3019#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003020
Denys Vlasenko202dd192018-12-16 17:30:35 +01003021static BC_STATUS zbc_lex_skip_if_at_NLINE(BcLex *l)
3022{
3023 if (l->t.t == BC_LEX_NLINE)
3024 RETURN_STATUS(zbc_lex_next(l));
3025 RETURN_STATUS(BC_STATUS_SUCCESS);
3026}
3027#if ERRORS_ARE_FATAL
3028# define zbc_lex_skip_if_at_NLINE(...) (zbc_lex_skip_if_at_NLINE(__VA_ARGS__), BC_STATUS_SUCCESS)
3029#endif
3030
3031static BC_STATUS zbc_lex_next_and_skip_NLINE(BcLex *l)
3032{
3033 BcStatus s;
3034 s = zbc_lex_next(l);
3035 if (s) RETURN_STATUS(s);
3036 // if(cond)<newline>stmt is accepted too (but not 2+ newlines)
3037 s = zbc_lex_skip_if_at_NLINE(l);
3038 RETURN_STATUS(s);
3039}
3040#if ERRORS_ARE_FATAL
3041# define zbc_lex_next_and_skip_NLINE(...) (zbc_lex_next_and_skip_NLINE(__VA_ARGS__), BC_STATUS_SUCCESS)
3042#endif
3043
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01003044static BC_STATUS zbc_lex_text_init(BcLex *l, const char *text)
Gavin Howard01055ba2018-11-03 11:00:21 -06003045{
3046 l->buf = text;
3047 l->i = 0;
3048 l->len = strlen(text);
3049 l->t.t = l->t.last = BC_LEX_INVALID;
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003050 RETURN_STATUS(zbc_lex_next(l));
Gavin Howard01055ba2018-11-03 11:00:21 -06003051}
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003052#if ERRORS_ARE_FATAL
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01003053# define zbc_lex_text_init(...) (zbc_lex_text_init(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003054#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003055
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01003056#if ENABLE_BC
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003057static BC_STATUS zbc_lex_identifier(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06003058{
3059 BcStatus s;
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +01003060 unsigned i;
Gavin Howard01055ba2018-11-03 11:00:21 -06003061 const char *buf = l->buf + l->i - 1;
3062
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +01003063 for (i = 0; i < ARRAY_SIZE(bc_lex_kws); ++i) {
3064 const char *keyword8 = bc_lex_kws[i].name8;
3065 unsigned j = 0;
3066 while (buf[j] != '\0' && buf[j] == keyword8[j]) {
3067 j++;
3068 if (j == 8) goto match;
Gavin Howard01055ba2018-11-03 11:00:21 -06003069 }
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +01003070 if (keyword8[j] != '\0')
3071 continue;
3072 match:
3073 // buf starts with keyword bc_lex_kws[i]
3074 l->t.t = BC_LEX_KEY_1st_keyword + i;
Denys Vlasenkod00d2f92018-12-06 12:59:40 +01003075 if (!bc_lex_kws_POSIX(i)) {
Denys Vlasenko0d7e46b2018-12-05 18:31:19 +01003076 s = bc_posix_error_fmt("%sthe '%.8s' keyword", "POSIX does not allow ", bc_lex_kws[i].name8);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003077 ERROR_RETURN(if (s) RETURN_STATUS(s);)
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +01003078 }
3079
3080 // We minus 1 because the index has already been incremented.
3081 l->i += j - 1;
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003082 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06003083 }
3084
Denys Vlasenko88cfea62018-12-10 20:26:04 +01003085 bc_lex_name(l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003086
Denys Vlasenko0d7e46b2018-12-05 18:31:19 +01003087 if (l->t.v.len > 2) {
3088 // Prevent this:
3089 // >>> qwe=1
3090 // bc: POSIX only allows one character names; the following is bad: 'qwe=1
3091 // '
3092 unsigned len = strchrnul(buf, '\n') - buf;
3093 s = bc_posix_error_fmt("POSIX only allows one character names; the following is bad: '%.*s'", len, buf);
3094 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003095
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003096 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003097}
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003098#if ERRORS_ARE_FATAL
3099# define zbc_lex_identifier(...) (zbc_lex_identifier(__VA_ARGS__), BC_STATUS_SUCCESS)
3100#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003101
Denys Vlasenko26819db2018-12-12 16:08:46 +01003102static BC_STATUS zbc_lex_string(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06003103{
3104 size_t len, nls = 0, i = l->i;
3105 char c;
3106
3107 l->t.t = BC_LEX_STR;
3108
Denys Vlasenko26819db2018-12-12 16:08:46 +01003109 for (c = l->buf[i]; c != 0 && c != '"'; c = l->buf[++i])
3110 nls += (c == '\n');
Gavin Howard01055ba2018-11-03 11:00:21 -06003111
3112 if (c == '\0') {
3113 l->i = i;
Denys Vlasenko26819db2018-12-12 16:08:46 +01003114 RETURN_STATUS(bc_error("string end could not be found"));
Gavin Howard01055ba2018-11-03 11:00:21 -06003115 }
3116
3117 len = i - l->i;
Denys Vlasenko64074a12018-12-07 15:50:14 +01003118 // This check makes sense only if size_t is (much) larger than BC_MAX_STRING.
3119 if (SIZE_MAX > (BC_MAX_STRING | 0xff)) {
3120 if (len > BC_MAX_STRING)
Denys Vlasenko9811ad02018-12-12 23:25:13 +01003121 RETURN_STATUS(bc_error("string too long: must be [1,"BC_MAX_STRING_STR"]"));
Denys Vlasenko64074a12018-12-07 15:50:14 +01003122 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003123 bc_vec_string(&l->t.v, len, l->buf + l->i);
3124
3125 l->i = i + 1;
3126 l->line += nls;
Denys Vlasenko5318f812018-12-05 17:48:01 +01003127 G.err_line = l->line;
Gavin Howard01055ba2018-11-03 11:00:21 -06003128
Denys Vlasenko26819db2018-12-12 16:08:46 +01003129 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06003130}
Denys Vlasenko26819db2018-12-12 16:08:46 +01003131#if ERRORS_ARE_FATAL
3132# define zbc_lex_string(...) (zbc_lex_string(__VA_ARGS__), BC_STATUS_SUCCESS)
3133#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003134
Denys Vlasenko0a238142018-12-14 16:48:34 +01003135static void bc_lex_assign(BcLex *l, unsigned with_and_without)
Gavin Howard01055ba2018-11-03 11:00:21 -06003136{
3137 if (l->buf[l->i] == '=') {
3138 ++l->i;
Denys Vlasenko0a238142018-12-14 16:48:34 +01003139 with_and_without >>= 8; // store "with" value
3140 } // else store "without" value
3141 l->t.t = (with_and_without & 0xff);
Gavin Howard01055ba2018-11-03 11:00:21 -06003142}
Denys Vlasenko0a238142018-12-14 16:48:34 +01003143#define bc_lex_assign(l, with, without) \
3144 bc_lex_assign(l, ((with)<<8)|(without))
Gavin Howard01055ba2018-11-03 11:00:21 -06003145
Denys Vlasenko29301232018-12-11 15:29:32 +01003146static BC_STATUS zbc_lex_comment(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06003147{
3148 size_t i, nls = 0;
3149 const char *buf = l->buf;
Gavin Howard01055ba2018-11-03 11:00:21 -06003150
3151 l->t.t = BC_LEX_WHITESPACE;
Denys Vlasenko9dc5d082018-12-16 18:43:51 +01003152 i = l->i; /* here buf[l->i] is the '*' of opening comment delimiter */
Denys Vlasenkobc5ce662018-12-03 19:12:29 +01003153 for (;;) {
Denys Vlasenko9dc5d082018-12-16 18:43:51 +01003154 char c = buf[++i];
Denys Vlasenkobc5ce662018-12-03 19:12:29 +01003155 check_star:
3156 if (c == '*') {
3157 c = buf[++i];
3158 if (c == '/')
3159 break;
3160 goto check_star;
3161 }
3162 if (c == '\0') {
Gavin Howard01055ba2018-11-03 11:00:21 -06003163 l->i = i;
Denys Vlasenko29301232018-12-11 15:29:32 +01003164 RETURN_STATUS(bc_error("comment end could not be found"));
Gavin Howard01055ba2018-11-03 11:00:21 -06003165 }
Denys Vlasenkobc5ce662018-12-03 19:12:29 +01003166 nls += (c == '\n');
Gavin Howard01055ba2018-11-03 11:00:21 -06003167 }
3168
Denys Vlasenkobc5ce662018-12-03 19:12:29 +01003169 l->i = i + 1;
Gavin Howard01055ba2018-11-03 11:00:21 -06003170 l->line += nls;
Denys Vlasenko5318f812018-12-05 17:48:01 +01003171 G.err_line = l->line;
Gavin Howard01055ba2018-11-03 11:00:21 -06003172
Denys Vlasenko29301232018-12-11 15:29:32 +01003173 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06003174}
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01003175#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01003176# define zbc_lex_comment(...) (zbc_lex_comment(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01003177#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003178
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01003179static BC_STATUS zbc_lex_token(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06003180{
3181 BcStatus s = BC_STATUS_SUCCESS;
3182 char c = l->buf[l->i++], c2;
3183
3184 // This is the workhorse of the lexer.
3185 switch (c) {
Denys Vlasenko9dc5d082018-12-16 18:43:51 +01003186 case '\0': // probably never reached
3187 l->i--;
3188 l->t.t = BC_LEX_EOF;
Gavin Howard01055ba2018-11-03 11:00:21 -06003189 l->newline = true;
Denys Vlasenko9dc5d082018-12-16 18:43:51 +01003190 break;
3191 case '\n':
3192 l->t.t = BC_LEX_NLINE;
3193 l->newline = true;
Gavin Howard01055ba2018-11-03 11:00:21 -06003194 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003195 case '\t':
3196 case '\v':
3197 case '\f':
3198 case '\r':
3199 case ' ':
Gavin Howard01055ba2018-11-03 11:00:21 -06003200 bc_lex_whitespace(l);
3201 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003202 case '!':
Gavin Howard01055ba2018-11-03 11:00:21 -06003203 bc_lex_assign(l, BC_LEX_OP_REL_NE, BC_LEX_OP_BOOL_NOT);
Gavin Howard01055ba2018-11-03 11:00:21 -06003204 if (l->t.t == BC_LEX_OP_BOOL_NOT) {
Denys Vlasenko00646792018-12-05 18:12:27 +01003205 s = bc_POSIX_does_not_allow_bool_ops_this_is_bad("!");
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003206 ERROR_RETURN(if (s) RETURN_STATUS(s);)
Gavin Howard01055ba2018-11-03 11:00:21 -06003207 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003208 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003209 case '"':
Denys Vlasenko26819db2018-12-12 16:08:46 +01003210 s = zbc_lex_string(l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003211 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003212 case '#':
Denys Vlasenko00646792018-12-05 18:12:27 +01003213 s = bc_POSIX_does_not_allow("'#' script comments");
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003214 ERROR_RETURN(if (s) RETURN_STATUS(s);)
Gavin Howard01055ba2018-11-03 11:00:21 -06003215 bc_lex_lineComment(l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003216 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003217 case '%':
Gavin Howard01055ba2018-11-03 11:00:21 -06003218 bc_lex_assign(l, BC_LEX_OP_ASSIGN_MODULUS, BC_LEX_OP_MODULUS);
3219 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003220 case '&':
Gavin Howard01055ba2018-11-03 11:00:21 -06003221 c2 = l->buf[l->i];
3222 if (c2 == '&') {
Denys Vlasenko00646792018-12-05 18:12:27 +01003223 s = bc_POSIX_does_not_allow_bool_ops_this_is_bad("&&");
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003224 ERROR_RETURN(if (s) RETURN_STATUS(s);)
Gavin Howard01055ba2018-11-03 11:00:21 -06003225 ++l->i;
3226 l->t.t = BC_LEX_OP_BOOL_AND;
Denys Vlasenko12b9eaf2018-12-11 23:50:14 +01003227 } else {
Gavin Howard01055ba2018-11-03 11:00:21 -06003228 l->t.t = BC_LEX_INVALID;
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003229 s = bc_error_bad_character('&');
Gavin Howard01055ba2018-11-03 11:00:21 -06003230 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003231 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003232 case '(':
3233 case ')':
Gavin Howard01055ba2018-11-03 11:00:21 -06003234 l->t.t = (BcLexType)(c - '(' + BC_LEX_LPAREN);
3235 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003236 case '*':
Gavin Howard01055ba2018-11-03 11:00:21 -06003237 bc_lex_assign(l, BC_LEX_OP_ASSIGN_MULTIPLY, BC_LEX_OP_MULTIPLY);
3238 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003239 case '+':
Gavin Howard01055ba2018-11-03 11:00:21 -06003240 c2 = l->buf[l->i];
3241 if (c2 == '+') {
3242 ++l->i;
3243 l->t.t = BC_LEX_OP_INC;
Denys Vlasenko12b9eaf2018-12-11 23:50:14 +01003244 } else
Gavin Howard01055ba2018-11-03 11:00:21 -06003245 bc_lex_assign(l, BC_LEX_OP_ASSIGN_PLUS, BC_LEX_OP_PLUS);
3246 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003247 case ',':
Gavin Howard01055ba2018-11-03 11:00:21 -06003248 l->t.t = BC_LEX_COMMA;
3249 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003250 case '-':
Gavin Howard01055ba2018-11-03 11:00:21 -06003251 c2 = l->buf[l->i];
3252 if (c2 == '-') {
3253 ++l->i;
3254 l->t.t = BC_LEX_OP_DEC;
Denys Vlasenko12b9eaf2018-12-11 23:50:14 +01003255 } else
Gavin Howard01055ba2018-11-03 11:00:21 -06003256 bc_lex_assign(l, BC_LEX_OP_ASSIGN_MINUS, BC_LEX_OP_MINUS);
3257 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003258 case '.':
Gavin Howard01055ba2018-11-03 11:00:21 -06003259 if (isdigit(l->buf[l->i]))
Denys Vlasenko29301232018-12-11 15:29:32 +01003260 s = zbc_lex_number(l, c);
Gavin Howard01055ba2018-11-03 11:00:21 -06003261 else {
3262 l->t.t = BC_LEX_KEY_LAST;
Denys Vlasenko00646792018-12-05 18:12:27 +01003263 s = bc_POSIX_does_not_allow("a period ('.') as a shortcut for the last result");
Gavin Howard01055ba2018-11-03 11:00:21 -06003264 }
3265 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003266 case '/':
Gavin Howard01055ba2018-11-03 11:00:21 -06003267 c2 = l->buf[l->i];
3268 if (c2 == '*')
Denys Vlasenko29301232018-12-11 15:29:32 +01003269 s = zbc_lex_comment(l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003270 else
3271 bc_lex_assign(l, BC_LEX_OP_ASSIGN_DIVIDE, BC_LEX_OP_DIVIDE);
3272 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003273 case '0':
3274 case '1':
3275 case '2':
3276 case '3':
3277 case '4':
3278 case '5':
3279 case '6':
3280 case '7':
3281 case '8':
3282 case '9':
3283 case 'A':
3284 case 'B':
3285 case 'C':
3286 case 'D':
3287 case 'E':
3288 case 'F':
Denys Vlasenko29301232018-12-11 15:29:32 +01003289 s = zbc_lex_number(l, c);
Gavin Howard01055ba2018-11-03 11:00:21 -06003290 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003291 case ';':
Gavin Howard01055ba2018-11-03 11:00:21 -06003292 l->t.t = BC_LEX_SCOLON;
3293 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003294 case '<':
Gavin Howard01055ba2018-11-03 11:00:21 -06003295 bc_lex_assign(l, BC_LEX_OP_REL_LE, BC_LEX_OP_REL_LT);
3296 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003297 case '=':
Gavin Howard01055ba2018-11-03 11:00:21 -06003298 bc_lex_assign(l, BC_LEX_OP_REL_EQ, BC_LEX_OP_ASSIGN);
3299 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003300 case '>':
Gavin Howard01055ba2018-11-03 11:00:21 -06003301 bc_lex_assign(l, BC_LEX_OP_REL_GE, BC_LEX_OP_REL_GT);
3302 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003303 case '[':
3304 case ']':
Gavin Howard01055ba2018-11-03 11:00:21 -06003305 l->t.t = (BcLexType)(c - '[' + BC_LEX_LBRACKET);
3306 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003307 case '\\':
Gavin Howard01055ba2018-11-03 11:00:21 -06003308 if (l->buf[l->i] == '\n') {
3309 l->t.t = BC_LEX_WHITESPACE;
3310 ++l->i;
Denys Vlasenko12b9eaf2018-12-11 23:50:14 +01003311 } else
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003312 s = bc_error_bad_character(c);
Gavin Howard01055ba2018-11-03 11:00:21 -06003313 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003314 case '^':
Gavin Howard01055ba2018-11-03 11:00:21 -06003315 bc_lex_assign(l, BC_LEX_OP_ASSIGN_POWER, BC_LEX_OP_POWER);
3316 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003317 case 'a':
3318 case 'b':
3319 case 'c':
3320 case 'd':
3321 case 'e':
3322 case 'f':
3323 case 'g':
3324 case 'h':
3325 case 'i':
3326 case 'j':
3327 case 'k':
3328 case 'l':
3329 case 'm':
3330 case 'n':
3331 case 'o':
3332 case 'p':
3333 case 'q':
3334 case 'r':
3335 case 's':
3336 case 't':
3337 case 'u':
3338 case 'v':
3339 case 'w':
3340 case 'x':
3341 case 'y':
3342 case 'z':
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003343 s = zbc_lex_identifier(l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003344 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003345 case '{':
3346 case '}':
Gavin Howard01055ba2018-11-03 11:00:21 -06003347 l->t.t = (BcLexType)(c - '{' + BC_LEX_LBRACE);
3348 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003349 case '|':
Gavin Howard01055ba2018-11-03 11:00:21 -06003350 c2 = l->buf[l->i];
Gavin Howard01055ba2018-11-03 11:00:21 -06003351 if (c2 == '|') {
Denys Vlasenko00646792018-12-05 18:12:27 +01003352 s = bc_POSIX_does_not_allow_bool_ops_this_is_bad("||");
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003353 ERROR_RETURN(if (s) RETURN_STATUS(s);)
Gavin Howard01055ba2018-11-03 11:00:21 -06003354 ++l->i;
3355 l->t.t = BC_LEX_OP_BOOL_OR;
Denys Vlasenko12b9eaf2018-12-11 23:50:14 +01003356 } else {
Gavin Howard01055ba2018-11-03 11:00:21 -06003357 l->t.t = BC_LEX_INVALID;
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003358 s = bc_error_bad_character(c);
Gavin Howard01055ba2018-11-03 11:00:21 -06003359 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003360 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003361 default:
Gavin Howard01055ba2018-11-03 11:00:21 -06003362 l->t.t = BC_LEX_INVALID;
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003363 s = bc_error_bad_character(c);
Gavin Howard01055ba2018-11-03 11:00:21 -06003364 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003365 }
3366
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003367 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003368}
3369#endif // ENABLE_BC
3370
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01003371#if ENABLE_DC
Denys Vlasenko29301232018-12-11 15:29:32 +01003372static BC_STATUS zdc_lex_register(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06003373{
Gavin Howard01055ba2018-11-03 11:00:21 -06003374 if (isspace(l->buf[l->i - 1])) {
3375 bc_lex_whitespace(l);
3376 ++l->i;
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01003377 if (!G_exreg)
Denys Vlasenko29301232018-12-11 15:29:32 +01003378 RETURN_STATUS(bc_error("extended register"));
3379 bc_lex_name(l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003380 }
3381 else {
Denys Vlasenko7d628012018-12-04 21:46:47 +01003382 bc_vec_pop_all(&l->t.v);
Denys Vlasenkoe55a5722018-12-06 12:47:17 +01003383 bc_vec_push(&l->t.v, &l->buf[l->i - 1]);
Denys Vlasenko08c033c2018-12-05 16:55:08 +01003384 bc_vec_pushZeroByte(&l->t.v);
Gavin Howard01055ba2018-11-03 11:00:21 -06003385 l->t.t = BC_LEX_NAME;
3386 }
3387
Denys Vlasenko29301232018-12-11 15:29:32 +01003388 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06003389}
Denys Vlasenko88cfea62018-12-10 20:26:04 +01003390#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01003391# define zdc_lex_register(...) (zdc_lex_register(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko88cfea62018-12-10 20:26:04 +01003392#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003393
Denys Vlasenko29301232018-12-11 15:29:32 +01003394static BC_STATUS zdc_lex_string(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06003395{
3396 size_t depth = 1, nls = 0, i = l->i;
3397 char c;
3398
3399 l->t.t = BC_LEX_STR;
Denys Vlasenko7d628012018-12-04 21:46:47 +01003400 bc_vec_pop_all(&l->t.v);
Gavin Howard01055ba2018-11-03 11:00:21 -06003401
3402 for (c = l->buf[i]; c != 0 && depth; c = l->buf[++i]) {
3403
3404 depth += (c == '[' && (i == l->i || l->buf[i - 1] != '\\'));
3405 depth -= (c == ']' && (i == l->i || l->buf[i - 1] != '\\'));
3406 nls += (c == '\n');
3407
3408 if (depth) bc_vec_push(&l->t.v, &c);
3409 }
3410
3411 if (c == '\0') {
3412 l->i = i;
Denys Vlasenko29301232018-12-11 15:29:32 +01003413 RETURN_STATUS(bc_error("string end could not be found"));
Gavin Howard01055ba2018-11-03 11:00:21 -06003414 }
3415
Denys Vlasenko08c033c2018-12-05 16:55:08 +01003416 bc_vec_pushZeroByte(&l->t.v);
Denys Vlasenko64074a12018-12-07 15:50:14 +01003417 // This check makes sense only if size_t is (much) larger than BC_MAX_STRING.
3418 if (SIZE_MAX > (BC_MAX_STRING | 0xff)) {
3419 if (i - l->i > BC_MAX_STRING)
Denys Vlasenko29301232018-12-11 15:29:32 +01003420 RETURN_STATUS(bc_error("string too long: must be [1,"BC_MAX_STRING_STR"]"));
Denys Vlasenko64074a12018-12-07 15:50:14 +01003421 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003422
3423 l->i = i;
3424 l->line += nls;
Denys Vlasenko5318f812018-12-05 17:48:01 +01003425 G.err_line = l->line;
Gavin Howard01055ba2018-11-03 11:00:21 -06003426
Denys Vlasenko29301232018-12-11 15:29:32 +01003427 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06003428}
Denys Vlasenko88cfea62018-12-10 20:26:04 +01003429#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01003430# define zdc_lex_string(...) (zdc_lex_string(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko88cfea62018-12-10 20:26:04 +01003431#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003432
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01003433static BC_STATUS zdc_lex_token(BcLex *l)
Gavin Howard01055ba2018-11-03 11:00:21 -06003434{
3435 BcStatus s = BC_STATUS_SUCCESS;
3436 char c = l->buf[l->i++], c2;
3437 size_t i;
3438
Denys Vlasenko51fb8aa2018-12-05 00:22:34 +01003439 for (i = 0; i < ARRAY_SIZE(dc_lex_regs); ++i) {
3440 if (l->t.last == dc_lex_regs[i])
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003441 RETURN_STATUS(zdc_lex_register(l));
Gavin Howard01055ba2018-11-03 11:00:21 -06003442 }
3443
Denys Vlasenko12b9eaf2018-12-11 23:50:14 +01003444 if (c >= '%' && c <= '~'
3445 && (l->t.t = dc_lex_tokens[(c - '%')]) != BC_LEX_INVALID
3446 ) {
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003447 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003448 }
3449
3450 // This is the workhorse of the lexer.
3451 switch (c) {
Gavin Howard01055ba2018-11-03 11:00:21 -06003452 case '\0':
Gavin Howard01055ba2018-11-03 11:00:21 -06003453 l->t.t = BC_LEX_EOF;
3454 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003455 case '\n':
3456 case '\t':
3457 case '\v':
3458 case '\f':
3459 case '\r':
3460 case ' ':
Gavin Howard01055ba2018-11-03 11:00:21 -06003461 l->newline = (c == '\n');
3462 bc_lex_whitespace(l);
3463 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003464 case '!':
Gavin Howard01055ba2018-11-03 11:00:21 -06003465 c2 = l->buf[l->i];
Gavin Howard01055ba2018-11-03 11:00:21 -06003466 if (c2 == '=')
3467 l->t.t = BC_LEX_OP_REL_NE;
3468 else if (c2 == '<')
3469 l->t.t = BC_LEX_OP_REL_LE;
3470 else if (c2 == '>')
3471 l->t.t = BC_LEX_OP_REL_GE;
3472 else
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003473 RETURN_STATUS(bc_error_bad_character(c));
Gavin Howard01055ba2018-11-03 11:00:21 -06003474 ++l->i;
3475 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003476 case '#':
Gavin Howard01055ba2018-11-03 11:00:21 -06003477 bc_lex_lineComment(l);
3478 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003479 case '.':
Gavin Howard01055ba2018-11-03 11:00:21 -06003480 if (isdigit(l->buf[l->i]))
Denys Vlasenko29301232018-12-11 15:29:32 +01003481 s = zbc_lex_number(l, c);
Gavin Howard01055ba2018-11-03 11:00:21 -06003482 else
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003483 s = bc_error_bad_character(c);
Gavin Howard01055ba2018-11-03 11:00:21 -06003484 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003485 case '0':
3486 case '1':
3487 case '2':
3488 case '3':
3489 case '4':
3490 case '5':
3491 case '6':
3492 case '7':
3493 case '8':
3494 case '9':
3495 case 'A':
3496 case 'B':
3497 case 'C':
3498 case 'D':
3499 case 'E':
3500 case 'F':
Denys Vlasenko29301232018-12-11 15:29:32 +01003501 s = zbc_lex_number(l, c);
Gavin Howard01055ba2018-11-03 11:00:21 -06003502 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003503 case '[':
Denys Vlasenko29301232018-12-11 15:29:32 +01003504 s = zdc_lex_string(l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003505 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003506 default:
Gavin Howard01055ba2018-11-03 11:00:21 -06003507 l->t.t = BC_LEX_INVALID;
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003508 s = bc_error_bad_character(c);
Gavin Howard01055ba2018-11-03 11:00:21 -06003509 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003510 }
3511
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003512 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003513}
3514#endif // ENABLE_DC
3515
Denys Vlasenkob6f60862018-12-06 12:54:26 +01003516static void bc_program_addFunc(char *name, size_t *idx);
3517
Gavin Howard01055ba2018-11-03 11:00:21 -06003518static void bc_parse_addFunc(BcParse *p, char *name, size_t *idx)
3519{
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01003520 bc_program_addFunc(name, idx);
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01003521 p->func = bc_program_func(p->fidx);
Gavin Howard01055ba2018-11-03 11:00:21 -06003522}
3523
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01003524static void bc_parse_push(BcParse *p, char i)
3525{
3526 dbg_lex("%s:%d pushing opcode %d", __func__, __LINE__, i);
3527 bc_vec_pushByte(&p->func->code, i);
3528}
Denys Vlasenkob23ac512018-12-06 13:10:56 +01003529
Gavin Howard01055ba2018-11-03 11:00:21 -06003530static void bc_parse_pushName(BcParse *p, char *name)
3531{
Denys Vlasenkoe6c40c42018-12-16 20:32:58 +01003532 while (*name)
3533 bc_parse_push(p, *name++);
Gavin Howard01055ba2018-11-03 11:00:21 -06003534 bc_parse_push(p, BC_PARSE_STREND);
Gavin Howard01055ba2018-11-03 11:00:21 -06003535}
3536
3537static void bc_parse_pushIndex(BcParse *p, size_t idx)
3538{
Denys Vlasenkoc2da68e2018-12-12 16:44:34 +01003539 size_t mask;
3540 unsigned amt;
Gavin Howard01055ba2018-11-03 11:00:21 -06003541
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01003542 dbg_lex("%s:%d pushing index %d", __func__, __LINE__, idx);
Denys Vlasenkoc2da68e2018-12-12 16:44:34 +01003543 mask = ((size_t)0xff) << (sizeof(idx) * 8 - 8);
3544 amt = sizeof(idx);
3545 do {
3546 if (idx & mask) break;
3547 mask >>= 8;
3548 amt--;
3549 } while (amt != 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06003550
3551 bc_parse_push(p, amt);
Denys Vlasenkoc2da68e2018-12-12 16:44:34 +01003552
3553 while (idx != 0) {
3554 bc_parse_push(p, (unsigned char)idx);
3555 idx >>= 8;
3556 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003557}
3558
Denys Vlasenko9dc5d082018-12-16 18:43:51 +01003559static void bc_parse_number(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06003560{
3561 char *num = xstrdup(p->l.t.v.v);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01003562 size_t idx = G.prog.consts.len;
Gavin Howard01055ba2018-11-03 11:00:21 -06003563
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01003564 bc_vec_push(&G.prog.consts, &num);
Gavin Howard01055ba2018-11-03 11:00:21 -06003565
3566 bc_parse_push(p, BC_INST_NUM);
3567 bc_parse_pushIndex(p, idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06003568}
3569
Denys Vlasenko99b37622018-12-15 20:06:59 +01003570IF_BC(static BC_STATUS zbc_parse_stmt_or_funcdef(BcParse *p);)
Denys Vlasenkoe755e302018-12-13 22:25:28 +01003571IF_DC(static BC_STATUS zdc_parse_parse(BcParse *p);)
Denys Vlasenkoc0ef23c2018-12-12 23:03:10 +01003572
3573static BC_STATUS zcommon_parse(BcParse *p)
3574{
3575 if (IS_BC) {
Denys Vlasenko99b37622018-12-15 20:06:59 +01003576 IF_BC(RETURN_STATUS(zbc_parse_stmt_or_funcdef(p));)
Denys Vlasenkoc0ef23c2018-12-12 23:03:10 +01003577 }
3578 IF_DC(RETURN_STATUS(zdc_parse_parse(p));)
3579}
3580
Denys Vlasenkof86e9602018-12-14 17:01:56 +01003581static BC_STATUS zbc_parse_text_init(BcParse *p, const char *text)
Gavin Howard01055ba2018-11-03 11:00:21 -06003582{
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01003583 p->func = bc_program_func(p->fidx);
Gavin Howard01055ba2018-11-03 11:00:21 -06003584
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01003585 RETURN_STATUS(zbc_lex_text_init(&p->l, text));
Gavin Howard01055ba2018-11-03 11:00:21 -06003586}
Denys Vlasenko26819db2018-12-12 16:08:46 +01003587#if ERRORS_ARE_FATAL
Denys Vlasenkof86e9602018-12-14 17:01:56 +01003588# define zbc_parse_text_init(...) (zbc_parse_text_init(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko26819db2018-12-12 16:08:46 +01003589#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003590
Denys Vlasenkob6f60862018-12-06 12:54:26 +01003591// Called when parsing or execution detects a failure,
3592// resets execution structures.
3593static void bc_program_reset(void)
3594{
3595 BcFunc *f;
3596 BcInstPtr *ip;
3597
3598 bc_vec_npop(&G.prog.stack, G.prog.stack.len - 1);
3599 bc_vec_pop_all(&G.prog.results);
3600
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01003601 f = bc_program_func(0);
Denys Vlasenkob6f60862018-12-06 12:54:26 +01003602 ip = bc_vec_top(&G.prog.stack);
3603 ip->idx = f->code.len;
3604}
3605
Denys Vlasenkoe55a5722018-12-06 12:47:17 +01003606#define bc_parse_updateFunc(p, f) \
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01003607 ((p)->func = bc_program_func((p)->fidx = (f)))
Denys Vlasenkoe55a5722018-12-06 12:47:17 +01003608
Denys Vlasenko26819db2018-12-12 16:08:46 +01003609// Called when zbc/zdc_parse_parse() detects a failure,
Denys Vlasenkod38af482018-12-04 19:11:02 +01003610// resets parsing structures.
3611static void bc_parse_reset(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06003612{
3613 if (p->fidx != BC_PROG_MAIN) {
Gavin Howard01055ba2018-11-03 11:00:21 -06003614 p->func->nparams = 0;
Denys Vlasenko7d628012018-12-04 21:46:47 +01003615 bc_vec_pop_all(&p->func->code);
3616 bc_vec_pop_all(&p->func->autos);
3617 bc_vec_pop_all(&p->func->labels);
Gavin Howard01055ba2018-11-03 11:00:21 -06003618
3619 bc_parse_updateFunc(p, BC_PROG_MAIN);
3620 }
3621
3622 p->l.i = p->l.len;
3623 p->l.t.t = BC_LEX_EOF;
Gavin Howard01055ba2018-11-03 11:00:21 -06003624
Denys Vlasenko7d628012018-12-04 21:46:47 +01003625 bc_vec_pop_all(&p->exits);
3626 bc_vec_pop_all(&p->conds);
3627 bc_vec_pop_all(&p->ops);
Gavin Howard01055ba2018-11-03 11:00:21 -06003628
Denys Vlasenkod38af482018-12-04 19:11:02 +01003629 bc_program_reset();
Gavin Howard01055ba2018-11-03 11:00:21 -06003630}
3631
3632static void bc_parse_free(BcParse *p)
3633{
Gavin Howard01055ba2018-11-03 11:00:21 -06003634 bc_vec_free(&p->exits);
3635 bc_vec_free(&p->conds);
3636 bc_vec_free(&p->ops);
3637 bc_lex_free(&p->l);
3638}
3639
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01003640static void bc_parse_create(BcParse *p, size_t func)
Gavin Howard01055ba2018-11-03 11:00:21 -06003641{
3642 memset(p, 0, sizeof(BcParse));
3643
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01003644 bc_lex_init(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003645 bc_vec_init(&p->exits, sizeof(BcInstPtr), NULL);
3646 bc_vec_init(&p->conds, sizeof(size_t), NULL);
Gavin Howard01055ba2018-11-03 11:00:21 -06003647 bc_vec_init(&p->ops, sizeof(BcLexType), NULL);
3648
Gavin Howard01055ba2018-11-03 11:00:21 -06003649 bc_parse_updateFunc(p, func);
3650}
3651
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01003652#if ENABLE_BC
Denys Vlasenkocca79a02018-12-05 21:15:46 +01003653
3654#define BC_PARSE_TOP_OP(p) (*((BcLexType *) bc_vec_top(&(p)->ops)))
3655#define BC_PARSE_LEAF(p, rparen) \
3656 (((p) >= BC_INST_NUM && (p) <= BC_INST_SQRT) || (rparen) || \
3657 (p) == BC_INST_INC_POST || (p) == BC_INST_DEC_POST)
3658
3659// We can calculate the conversion between tokens and exprs by subtracting the
3660// position of the first operator in the lex enum and adding the position of the
3661// first in the expr enum. Note: This only works for binary operators.
Denys Vlasenko0154d782018-12-14 23:32:51 +01003662#define BC_TOKEN_2_INST(t) ((char) ((t) - BC_LEX_NEG + BC_INST_NEG))
Denys Vlasenkocca79a02018-12-05 21:15:46 +01003663
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01003664static BC_STATUS zbc_parse_stmt_possibly_auto(BcParse *p, bool auto_allowed);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01003665static BC_STATUS zbc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next);
Denys Vlasenko050b0fe2018-12-05 22:40:44 +01003666static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext next);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01003667#if ERRORS_ARE_FATAL
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01003668# define zbc_parse_expr(...) (zbc_parse_expr(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01003669# defone zbc_parse_stmt_possibly_auto(...) (zbc_parse_stmt_possibly_auto(__VA_ARGS__), BC_STATUS_SUCCESS)
3670#endif
3671
3672static BC_STATUS zbc_parse_stmt(BcParse *p)
3673{
3674 RETURN_STATUS(zbc_parse_stmt_possibly_auto(p, false));
3675}
3676#if ERRORS_ARE_FATAL
3677# define zbc_parse_stmt(...) (zbc_parse_stmt(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01003678#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003679
Denys Vlasenkocb18b542018-12-16 20:46:15 +01003680static BC_STATUS zbc_parse_stmt_fail_if_bare_NLINE(BcParse *p, bool auto_allowed, const char *after_X)
Denys Vlasenko2e8be022018-12-16 20:41:32 +01003681{
3682 if (p->l.t.t == BC_LEX_NLINE)
3683 RETURN_STATUS(bc_error_fmt("no statement after '%s'", after_X));
Denys Vlasenkocb18b542018-12-16 20:46:15 +01003684 RETURN_STATUS(zbc_parse_stmt_possibly_auto(p, auto_allowed));
Denys Vlasenko2e8be022018-12-16 20:41:32 +01003685}
3686#if ERRORS_ARE_FATAL
Denys Vlasenkocb18b542018-12-16 20:46:15 +01003687# define zbc_parse_stmt_fail_if_bare_NLINE(...) (zbc_parse_stmt_fail_if_bare_NLINE(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko2e8be022018-12-16 20:41:32 +01003688#endif
3689
Denys Vlasenko7b1df3d2018-12-14 23:12:48 +01003690static void bc_parse_operator(BcParse *p, BcLexType type, size_t start,
3691 size_t *nexprs)
Gavin Howard01055ba2018-11-03 11:00:21 -06003692{
Denys Vlasenko65437582018-12-05 19:37:19 +01003693 char l, r = bc_parse_op_PREC(type - BC_LEX_OP_INC);
3694 bool left = bc_parse_op_LEFT(type - BC_LEX_OP_INC);
Gavin Howard01055ba2018-11-03 11:00:21 -06003695
3696 while (p->ops.len > start) {
Denys Vlasenko7b1df3d2018-12-14 23:12:48 +01003697 BcLexType t = BC_PARSE_TOP_OP(p);
Gavin Howard01055ba2018-11-03 11:00:21 -06003698 if (t == BC_LEX_LPAREN) break;
3699
Denys Vlasenko65437582018-12-05 19:37:19 +01003700 l = bc_parse_op_PREC(t - BC_LEX_OP_INC);
Gavin Howard01055ba2018-11-03 11:00:21 -06003701 if (l >= r && (l != r || !left)) break;
3702
Denys Vlasenko0154d782018-12-14 23:32:51 +01003703 bc_parse_push(p, BC_TOKEN_2_INST(t));
Gavin Howard01055ba2018-11-03 11:00:21 -06003704 bc_vec_pop(&p->ops);
Denys Vlasenko7b1df3d2018-12-14 23:12:48 +01003705 *nexprs -= (t != BC_LEX_OP_BOOL_NOT && t != BC_LEX_NEG);
Gavin Howard01055ba2018-11-03 11:00:21 -06003706 }
3707
3708 bc_vec_push(&p->ops, &type);
Gavin Howard01055ba2018-11-03 11:00:21 -06003709}
3710
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003711static BC_STATUS zbc_parse_rightParen(BcParse *p, size_t ops_bgn, size_t *nexs)
Gavin Howard01055ba2018-11-03 11:00:21 -06003712{
3713 BcLexType top;
3714
Denys Vlasenko60cf7472018-12-04 20:05:28 +01003715 if (p->ops.len <= ops_bgn)
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003716 RETURN_STATUS(bc_error_bad_expression());
Gavin Howard01055ba2018-11-03 11:00:21 -06003717 top = BC_PARSE_TOP_OP(p);
3718
3719 while (top != BC_LEX_LPAREN) {
Denys Vlasenko0154d782018-12-14 23:32:51 +01003720 bc_parse_push(p, BC_TOKEN_2_INST(top));
Gavin Howard01055ba2018-11-03 11:00:21 -06003721
3722 bc_vec_pop(&p->ops);
3723 *nexs -= top != BC_LEX_OP_BOOL_NOT && top != BC_LEX_NEG;
3724
Denys Vlasenko60cf7472018-12-04 20:05:28 +01003725 if (p->ops.len <= ops_bgn)
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003726 RETURN_STATUS(bc_error_bad_expression());
Gavin Howard01055ba2018-11-03 11:00:21 -06003727 top = BC_PARSE_TOP_OP(p);
3728 }
3729
3730 bc_vec_pop(&p->ops);
3731
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003732 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06003733}
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003734#if ERRORS_ARE_FATAL
3735# define zbc_parse_rightParen(...) (zbc_parse_rightParen(__VA_ARGS__), BC_STATUS_SUCCESS)
3736#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003737
Denys Vlasenko26819db2018-12-12 16:08:46 +01003738static BC_STATUS zbc_parse_params(BcParse *p, uint8_t flags)
Gavin Howard01055ba2018-11-03 11:00:21 -06003739{
3740 BcStatus s;
3741 bool comma = false;
3742 size_t nparams;
3743
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01003744 dbg_lex("%s:%d p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003745 s = zbc_lex_next(&p->l);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003746 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003747
3748 for (nparams = 0; p->l.t.t != BC_LEX_RPAREN; ++nparams) {
Gavin Howard01055ba2018-11-03 11:00:21 -06003749 flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01003750 s = zbc_parse_expr(p, flags, bc_parse_next_param);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003751 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003752
3753 comma = p->l.t.t == BC_LEX_COMMA;
3754 if (comma) {
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003755 s = zbc_lex_next(&p->l);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003756 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003757 }
3758 }
3759
Denys Vlasenko26819db2018-12-12 16:08:46 +01003760 if (comma) RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06003761 bc_parse_push(p, BC_INST_CALL);
3762 bc_parse_pushIndex(p, nparams);
3763
Denys Vlasenko26819db2018-12-12 16:08:46 +01003764 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06003765}
Denys Vlasenko26819db2018-12-12 16:08:46 +01003766#if ERRORS_ARE_FATAL
3767# define zbc_parse_params(...) (zbc_parse_params(__VA_ARGS__), BC_STATUS_SUCCESS)
3768#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003769
Denys Vlasenko26819db2018-12-12 16:08:46 +01003770static BC_STATUS zbc_parse_call(BcParse *p, char *name, uint8_t flags)
Gavin Howard01055ba2018-11-03 11:00:21 -06003771{
3772 BcStatus s;
3773 BcId entry, *entry_ptr;
3774 size_t idx;
3775
3776 entry.name = name;
3777
Denys Vlasenko26819db2018-12-12 16:08:46 +01003778 s = zbc_parse_params(p, flags);
Gavin Howard01055ba2018-11-03 11:00:21 -06003779 if (s) goto err;
3780
3781 if (p->l.t.t != BC_LEX_RPAREN) {
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003782 s = bc_error_bad_token();
Gavin Howard01055ba2018-11-03 11:00:21 -06003783 goto err;
3784 }
3785
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01003786 idx = bc_map_index(&G.prog.fn_map, &entry);
Gavin Howard01055ba2018-11-03 11:00:21 -06003787
3788 if (idx == BC_VEC_INVALID_IDX) {
3789 name = xstrdup(entry.name);
3790 bc_parse_addFunc(p, name, &idx);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01003791 idx = bc_map_index(&G.prog.fn_map, &entry);
Gavin Howard01055ba2018-11-03 11:00:21 -06003792 free(entry.name);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003793 } else
Gavin Howard01055ba2018-11-03 11:00:21 -06003794 free(name);
3795
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01003796 entry_ptr = bc_vec_item(&G.prog.fn_map, idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06003797 bc_parse_pushIndex(p, entry_ptr->idx);
3798
Denys Vlasenko26819db2018-12-12 16:08:46 +01003799 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06003800
3801err:
3802 free(name);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003803 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003804}
Denys Vlasenko26819db2018-12-12 16:08:46 +01003805#if ERRORS_ARE_FATAL
3806# define zbc_parse_call(...) (zbc_parse_call(__VA_ARGS__), BC_STATUS_SUCCESS)
3807#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003808
Denys Vlasenko26819db2018-12-12 16:08:46 +01003809static BC_STATUS zbc_parse_name(BcParse *p, BcInst *type, uint8_t flags)
Gavin Howard01055ba2018-11-03 11:00:21 -06003810{
3811 BcStatus s;
3812 char *name;
3813
3814 name = xstrdup(p->l.t.v.v);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003815 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003816 if (s) goto err;
3817
3818 if (p->l.t.t == BC_LEX_LBRACKET) {
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003819 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003820 if (s) goto err;
3821
3822 if (p->l.t.t == BC_LEX_RBRACKET) {
Gavin Howard01055ba2018-11-03 11:00:21 -06003823 if (!(flags & BC_PARSE_ARRAY)) {
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003824 s = bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06003825 goto err;
3826 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003827 *type = BC_INST_ARRAY;
Denys Vlasenko26819db2018-12-12 16:08:46 +01003828 } else {
Gavin Howard01055ba2018-11-03 11:00:21 -06003829 *type = BC_INST_ARRAY_ELEM;
Gavin Howard01055ba2018-11-03 11:00:21 -06003830 flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01003831 s = zbc_parse_expr(p, flags, bc_parse_next_elem);
Gavin Howard01055ba2018-11-03 11:00:21 -06003832 if (s) goto err;
3833 }
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003834 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003835 if (s) goto err;
3836 bc_parse_push(p, *type);
3837 bc_parse_pushName(p, name);
Denys Vlasenkoe6c40c42018-12-16 20:32:58 +01003838 free(name);
Gavin Howard01055ba2018-11-03 11:00:21 -06003839 }
3840 else if (p->l.t.t == BC_LEX_LPAREN) {
Gavin Howard01055ba2018-11-03 11:00:21 -06003841 if (flags & BC_PARSE_NOCALL) {
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003842 s = bc_error_bad_token();
Gavin Howard01055ba2018-11-03 11:00:21 -06003843 goto err;
3844 }
Gavin Howard01055ba2018-11-03 11:00:21 -06003845 *type = BC_INST_CALL;
Denys Vlasenko26819db2018-12-12 16:08:46 +01003846 s = zbc_parse_call(p, name, flags);
3847 } else {
Gavin Howard01055ba2018-11-03 11:00:21 -06003848 *type = BC_INST_VAR;
3849 bc_parse_push(p, BC_INST_VAR);
3850 bc_parse_pushName(p, name);
Denys Vlasenkoe6c40c42018-12-16 20:32:58 +01003851 free(name);
Gavin Howard01055ba2018-11-03 11:00:21 -06003852 }
3853
Denys Vlasenko26819db2018-12-12 16:08:46 +01003854 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003855
3856err:
3857 free(name);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003858 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003859}
Denys Vlasenko26819db2018-12-12 16:08:46 +01003860#if ERRORS_ARE_FATAL
3861# define zbc_parse_name(...) (zbc_parse_name(__VA_ARGS__), BC_STATUS_SUCCESS)
3862#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003863
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01003864static BC_STATUS zbc_parse_read(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06003865{
3866 BcStatus s;
3867
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003868 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01003869 if (s) RETURN_STATUS(s);
3870 if (p->l.t.t != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06003871
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003872 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01003873 if (s) RETURN_STATUS(s);
3874 if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06003875
3876 bc_parse_push(p, BC_INST_READ);
3877
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01003878 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06003879}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01003880#if ERRORS_ARE_FATAL
3881# define zbc_parse_read(...) (zbc_parse_read(__VA_ARGS__), BC_STATUS_SUCCESS)
3882#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003883
Denys Vlasenko26819db2018-12-12 16:08:46 +01003884static BC_STATUS zbc_parse_builtin(BcParse *p, BcLexType type, uint8_t flags,
Gavin Howard01055ba2018-11-03 11:00:21 -06003885 BcInst *prev)
3886{
3887 BcStatus s;
3888
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003889 s = zbc_lex_next(&p->l);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003890 if (s) RETURN_STATUS(s);
3891 if (p->l.t.t != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06003892
3893 flags = (flags & ~(BC_PARSE_PRINT | BC_PARSE_REL)) | BC_PARSE_ARRAY;
3894
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003895 s = zbc_lex_next(&p->l);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003896 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003897
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01003898 s = zbc_parse_expr(p, flags, bc_parse_next_rel);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003899 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003900
Denys Vlasenko26819db2018-12-12 16:08:46 +01003901 if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06003902
3903 *prev = (type == BC_LEX_KEY_LENGTH) ? BC_INST_LENGTH : BC_INST_SQRT;
3904 bc_parse_push(p, *prev);
3905
Denys Vlasenko26819db2018-12-12 16:08:46 +01003906 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06003907}
Denys Vlasenko26819db2018-12-12 16:08:46 +01003908#if ERRORS_ARE_FATAL
3909# define zbc_parse_builtin(...) (zbc_parse_builtin(__VA_ARGS__), BC_STATUS_SUCCESS)
3910#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003911
Denys Vlasenko26819db2018-12-12 16:08:46 +01003912static BC_STATUS zbc_parse_scale(BcParse *p, BcInst *type, uint8_t flags)
Gavin Howard01055ba2018-11-03 11:00:21 -06003913{
3914 BcStatus s;
3915
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003916 s = zbc_lex_next(&p->l);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003917 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003918
3919 if (p->l.t.t != BC_LEX_LPAREN) {
3920 *type = BC_INST_SCALE;
3921 bc_parse_push(p, BC_INST_SCALE);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003922 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06003923 }
3924
3925 *type = BC_INST_SCALE_FUNC;
3926 flags &= ~(BC_PARSE_PRINT | BC_PARSE_REL);
3927
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003928 s = zbc_lex_next(&p->l);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003929 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003930
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01003931 s = zbc_parse_expr(p, flags, bc_parse_next_rel);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003932 if (s) RETURN_STATUS(s);
3933 if (p->l.t.t != BC_LEX_RPAREN)
3934 RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06003935 bc_parse_push(p, BC_INST_SCALE_FUNC);
3936
Denys Vlasenko26819db2018-12-12 16:08:46 +01003937 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06003938}
Denys Vlasenko26819db2018-12-12 16:08:46 +01003939#if ERRORS_ARE_FATAL
3940# define zbc_parse_scale(...) (zbc_parse_scale(__VA_ARGS__), BC_STATUS_SUCCESS)
3941#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06003942
Denys Vlasenko26819db2018-12-12 16:08:46 +01003943static BC_STATUS zbc_parse_incdec(BcParse *p, BcInst *prev, bool *paren_expr,
Gavin Howard01055ba2018-11-03 11:00:21 -06003944 size_t *nexprs, uint8_t flags)
3945{
3946 BcStatus s;
3947 BcLexType type;
3948 char inst;
3949 BcInst etype = *prev;
3950
3951 if (etype == BC_INST_VAR || etype == BC_INST_ARRAY_ELEM ||
3952 etype == BC_INST_SCALE || etype == BC_INST_LAST ||
3953 etype == BC_INST_IBASE || etype == BC_INST_OBASE)
3954 {
3955 *prev = inst = BC_INST_INC_POST + (p->l.t.t != BC_LEX_OP_INC);
3956 bc_parse_push(p, inst);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003957 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003958 }
3959 else {
Gavin Howard01055ba2018-11-03 11:00:21 -06003960 *prev = inst = BC_INST_INC_PRE + (p->l.t.t != BC_LEX_OP_INC);
3961 *paren_expr = true;
3962
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003963 s = zbc_lex_next(&p->l);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003964 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003965 type = p->l.t.t;
3966
3967 // Because we parse the next part of the expression
3968 // right here, we need to increment this.
3969 *nexprs = *nexprs + 1;
3970
3971 switch (type) {
Gavin Howard01055ba2018-11-03 11:00:21 -06003972 case BC_LEX_NAME:
Denys Vlasenko26819db2018-12-12 16:08:46 +01003973 s = zbc_parse_name(p, prev, flags | BC_PARSE_NOCALL);
Gavin Howard01055ba2018-11-03 11:00:21 -06003974 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003975 case BC_LEX_KEY_IBASE:
3976 case BC_LEX_KEY_LAST:
3977 case BC_LEX_KEY_OBASE:
Gavin Howard01055ba2018-11-03 11:00:21 -06003978 bc_parse_push(p, type - BC_LEX_KEY_IBASE + BC_INST_IBASE);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003979 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06003980 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003981 case BC_LEX_KEY_SCALE:
Denys Vlasenko9a34e892018-12-12 13:58:55 +01003982 s = zbc_lex_next(&p->l);
Denys Vlasenko26819db2018-12-12 16:08:46 +01003983 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003984 if (p->l.t.t == BC_LEX_LPAREN)
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003985 s = bc_error_bad_token();
Gavin Howard01055ba2018-11-03 11:00:21 -06003986 else
3987 bc_parse_push(p, BC_INST_SCALE);
3988 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003989 default:
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01003990 s = bc_error_bad_token();
Gavin Howard01055ba2018-11-03 11:00:21 -06003991 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06003992 }
3993
3994 if (!s) bc_parse_push(p, inst);
3995 }
3996
Denys Vlasenko26819db2018-12-12 16:08:46 +01003997 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06003998}
Denys Vlasenko26819db2018-12-12 16:08:46 +01003999#if ERRORS_ARE_FATAL
4000# define zbc_parse_incdec(...) (zbc_parse_incdec(__VA_ARGS__), BC_STATUS_SUCCESS)
4001#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004002
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004003static BC_STATUS zbc_parse_minus(BcParse *p, BcInst *prev, size_t ops_bgn,
Gavin Howard01055ba2018-11-03 11:00:21 -06004004 bool rparen, size_t *nexprs)
4005{
4006 BcStatus s;
4007 BcLexType type;
4008 BcInst etype = *prev;
4009
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004010 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004011 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004012
4013 type = rparen || etype == BC_INST_INC_POST || etype == BC_INST_DEC_POST ||
4014 (etype >= BC_INST_NUM && etype <= BC_INST_SQRT) ?
4015 BC_LEX_OP_MINUS :
4016 BC_LEX_NEG;
Denys Vlasenko0154d782018-12-14 23:32:51 +01004017 *prev = BC_TOKEN_2_INST(type);
Gavin Howard01055ba2018-11-03 11:00:21 -06004018
4019 // We can just push onto the op stack because this is the largest
4020 // precedence operator that gets pushed. Inc/dec does not.
4021 if (type != BC_LEX_OP_MINUS)
4022 bc_vec_push(&p->ops, &type);
4023 else
Denys Vlasenko7b1df3d2018-12-14 23:12:48 +01004024 bc_parse_operator(p, type, ops_bgn, nexprs);
Gavin Howard01055ba2018-11-03 11:00:21 -06004025
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004026 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004027}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004028#if ERRORS_ARE_FATAL
4029# define zbc_parse_minus(...) (zbc_parse_minus(__VA_ARGS__), BC_STATUS_SUCCESS)
4030#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004031
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004032static BC_STATUS zbc_parse_string(BcParse *p, char inst)
Gavin Howard01055ba2018-11-03 11:00:21 -06004033{
4034 char *str = xstrdup(p->l.t.v.v);
4035
4036 bc_parse_push(p, BC_INST_STR);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01004037 bc_parse_pushIndex(p, G.prog.strs.len);
4038 bc_vec_push(&G.prog.strs, &str);
Gavin Howard01055ba2018-11-03 11:00:21 -06004039 bc_parse_push(p, inst);
4040
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004041 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06004042}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004043#if ERRORS_ARE_FATAL
4044# define zbc_parse_string(...) (zbc_parse_string(__VA_ARGS__), BC_STATUS_SUCCESS)
4045#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004046
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004047static BC_STATUS zbc_parse_print(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06004048{
4049 BcStatus s;
4050 BcLexType type;
Gavin Howard01055ba2018-11-03 11:00:21 -06004051
Denys Vlasenko5d18f6b2018-12-16 21:08:30 +01004052 for (;;) {
4053 s = zbc_lex_next(&p->l);
4054 if (s) RETURN_STATUS(s);
4055 type = p->l.t.t;
Denys Vlasenkoebc41c92018-12-08 23:36:28 +01004056 if (type == BC_LEX_STR) {
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004057 s = zbc_parse_string(p, BC_INST_PRINT_POP);
Denys Vlasenkoebc41c92018-12-08 23:36:28 +01004058 } else {
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004059 s = zbc_parse_expr(p, 0, bc_parse_next_print);
Gavin Howard01055ba2018-11-03 11:00:21 -06004060 bc_parse_push(p, BC_INST_PRINT_POP);
4061 }
Denys Vlasenko5d18f6b2018-12-16 21:08:30 +01004062 if (s) RETURN_STATUS(s);
4063 if (p->l.t.t != BC_LEX_COMMA)
4064 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004065 }
4066
Denys Vlasenko5d18f6b2018-12-16 21:08:30 +01004067 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004068}
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004069#if ERRORS_ARE_FATAL
4070# define zbc_parse_print(...) (zbc_parse_print(__VA_ARGS__), BC_STATUS_SUCCESS)
4071#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004072
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004073static BC_STATUS zbc_parse_return(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06004074{
4075 BcStatus s;
4076 BcLexType t;
Gavin Howard01055ba2018-11-03 11:00:21 -06004077
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004078 dbg_lex_enter("%s:%d entered", __func__, __LINE__);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004079 s = zbc_lex_next(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004080 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004081
4082 t = p->l.t.t;
Gavin Howard01055ba2018-11-03 11:00:21 -06004083 if (t == BC_LEX_NLINE || t == BC_LEX_SCOLON)
4084 bc_parse_push(p, BC_INST_RET0);
4085 else {
Denys Vlasenkoe9519e42018-12-16 17:06:07 +01004086 bool paren = (t == BC_LEX_LPAREN);
Denys Vlasenko050b0fe2018-12-05 22:40:44 +01004087 s = bc_parse_expr_empty_ok(p, 0, bc_parse_next_expr);
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004088 if (s == BC_STATUS_PARSE_EMPTY_EXP) {
Gavin Howard01055ba2018-11-03 11:00:21 -06004089 bc_parse_push(p, BC_INST_RET0);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004090 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004091 }
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004092 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004093
4094 if (!paren || p->l.t.last != BC_LEX_RPAREN) {
Denys Vlasenkoa6f84e12018-12-06 11:10:11 +01004095 s = bc_POSIX_requires("parentheses around return expressions");
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004096 ERROR_RETURN(if (s) RETURN_STATUS(s);)
Gavin Howard01055ba2018-11-03 11:00:21 -06004097 }
4098
4099 bc_parse_push(p, BC_INST_RET);
4100 }
4101
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004102 dbg_lex_done("%s:%d done", __func__, __LINE__);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004103 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004104}
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004105#if ERRORS_ARE_FATAL
4106# define zbc_parse_return(...) (zbc_parse_return(__VA_ARGS__), BC_STATUS_SUCCESS)
4107#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004108
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004109static BC_STATUS zbc_parse_if(BcParse *p)
4110{
4111 BcStatus s;
Denys Vlasenko15850832018-12-16 21:40:54 +01004112 size_t ip_idx;
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004113 size_t *label;
4114
4115 dbg_lex_enter("%s:%d entered", __func__, __LINE__);
4116 s = zbc_lex_next(&p->l);
4117 if (s) RETURN_STATUS(s);
4118 if (p->l.t.t != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
4119
4120 s = zbc_lex_next(&p->l);
4121 if (s) RETURN_STATUS(s);
4122 s = zbc_parse_expr(p, BC_PARSE_REL, bc_parse_next_rel);
4123 if (s) RETURN_STATUS(s);
4124
4125 if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
Denys Vlasenko202dd192018-12-16 17:30:35 +01004126 // if(cond)<newline>stmt is accepted too (but not 2+ newlines)
4127 s = zbc_lex_next_and_skip_NLINE(&p->l);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004128 if (s) RETURN_STATUS(s);
4129
4130 bc_parse_push(p, BC_INST_JUMP_ZERO);
Denys Vlasenko15850832018-12-16 21:40:54 +01004131 ip_idx = p->func->labels.len;
4132 bc_parse_pushIndex(p, ip_idx);
4133 bc_vec_push(&p->func->labels, &ip_idx);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004134
Denys Vlasenkocb18b542018-12-16 20:46:15 +01004135 s = zbc_parse_stmt_fail_if_bare_NLINE(p, false, "if");
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004136 if (s) RETURN_STATUS(s);
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004137
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004138 dbg_lex("%s:%d in if after stmt: p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
4139 if (p->l.t.t == BC_LEX_KEY_ELSE) {
Denys Vlasenko15850832018-12-16 21:40:54 +01004140 size_t ip2_idx;
Denys Vlasenko74156332018-12-16 21:21:27 +01004141
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004142 s = zbc_lex_next_and_skip_NLINE(&p->l);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004143 if (s) RETURN_STATUS(s);
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004144
Denys Vlasenko15850832018-12-16 21:40:54 +01004145 ip2_idx = p->func->labels.len;
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004146
Denys Vlasenko15850832018-12-16 21:40:54 +01004147 dbg_lex("%s:%d after if() body: BC_INST_JUMP to %d", __func__, __LINE__, ip2_idx);
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004148 bc_parse_push(p, BC_INST_JUMP);
Denys Vlasenko15850832018-12-16 21:40:54 +01004149 bc_parse_pushIndex(p, ip2_idx);
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004150
Denys Vlasenko15850832018-12-16 21:40:54 +01004151 label = bc_vec_item(&p->func->labels, ip_idx);
4152 dbg_lex("%s:%d rewriting 'if_zero' label to jump to 'else': %d -> %d", __func__, __LINE__, *label, p->func->code.len);
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004153 *label = p->func->code.len;
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004154
Denys Vlasenko15850832018-12-16 21:40:54 +01004155 bc_vec_push(&p->func->labels, &ip2_idx);
4156 ip_idx = ip2_idx;
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004157
Denys Vlasenko6b5b46f2018-12-16 21:29:08 +01004158 s = zbc_parse_stmt_fail_if_bare_NLINE(p, false, "else");
Denys Vlasenkoa50576a2018-12-16 19:21:57 +01004159 if (s) RETURN_STATUS(s);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004160 }
4161
Denys Vlasenko15850832018-12-16 21:40:54 +01004162 label = bc_vec_item(&p->func->labels, ip_idx);
4163 dbg_lex("%s:%d rewriting label to jump after 'if' body: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004164 *label = p->func->code.len;
4165
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004166 dbg_lex_done("%s:%d done", __func__, __LINE__);
4167 RETURN_STATUS(s);
4168}
4169#if ERRORS_ARE_FATAL
4170# define zbc_parse_if(...) (zbc_parse_if(__VA_ARGS__), BC_STATUS_SUCCESS)
4171#endif
4172
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004173static BC_STATUS zbc_parse_while(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06004174{
4175 BcStatus s;
4176 BcInstPtr ip;
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004177 BcInstPtr *ipp;
4178 size_t *label;
4179 size_t n;
Gavin Howard01055ba2018-11-03 11:00:21 -06004180
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004181 s = zbc_lex_next(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004182 if (s) RETURN_STATUS(s);
4183 if (p->l.t.t != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004184 s = zbc_lex_next(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004185 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004186
4187 ip.idx = p->func->labels.len;
4188
4189 bc_vec_push(&p->func->labels, &p->func->code.len);
4190 bc_vec_push(&p->conds, &ip.idx);
4191
4192 ip.idx = p->func->labels.len;
4193 ip.func = 1;
4194 ip.len = 0;
4195
4196 bc_vec_push(&p->exits, &ip);
4197 bc_vec_push(&p->func->labels, &ip.idx);
4198
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004199 s = zbc_parse_expr(p, BC_PARSE_REL, bc_parse_next_rel);
4200 if (s) RETURN_STATUS(s);
4201 if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
Denys Vlasenko202dd192018-12-16 17:30:35 +01004202
4203 // while(cond)<newline>stmt is accepted too
4204 s = zbc_lex_next_and_skip_NLINE(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004205 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004206
4207 bc_parse_push(p, BC_INST_JUMP_ZERO);
4208 bc_parse_pushIndex(p, ip.idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06004209
Denys Vlasenkocb18b542018-12-16 20:46:15 +01004210 s = zbc_parse_stmt_fail_if_bare_NLINE(p, false, "while");
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004211 if (s) RETURN_STATUS(s);
4212
4213 n = *((size_t *) bc_vec_top(&p->conds));
4214 bc_parse_push(p, BC_INST_JUMP);
4215 bc_parse_pushIndex(p, n);
4216
4217 ipp = bc_vec_top(&p->exits);
4218 label = bc_vec_top(&p->conds);
4219
4220 dbg_lex("%s:%d BC_INST_JUMP to %d", __func__, __LINE__, *label);
4221 bc_parse_push(p, BC_INST_JUMP);
4222 bc_parse_pushIndex(p, *label);
4223
4224 label = bc_vec_item(&p->func->labels, ipp->idx);
4225 dbg_lex("%s:%d rewriting label: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
4226 *label = p->func->code.len;
4227
4228 bc_vec_pop(&p->exits);
4229 bc_vec_pop(&p->conds);
4230
4231 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004232}
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004233#if ERRORS_ARE_FATAL
4234# define zbc_parse_while(...) (zbc_parse_while(__VA_ARGS__), BC_STATUS_SUCCESS)
4235#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004236
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004237static BC_STATUS zbc_parse_for(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06004238{
4239 BcStatus s;
4240 BcInstPtr ip;
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004241 BcInstPtr *ipp;
4242 size_t *label;
Gavin Howard01055ba2018-11-03 11:00:21 -06004243 size_t cond_idx, exit_idx, body_idx, update_idx;
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004244 size_t n;
Gavin Howard01055ba2018-11-03 11:00:21 -06004245
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01004246 dbg_lex("%s:%d p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004247 s = zbc_lex_next(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004248 if (s) RETURN_STATUS(s);
4249 if (p->l.t.t != BC_LEX_LPAREN) RETURN_STATUS(bc_error_bad_token());
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004250 s = zbc_lex_next(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004251 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004252
4253 if (p->l.t.t != BC_LEX_SCOLON)
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004254 s = zbc_parse_expr(p, 0, bc_parse_next_for);
Gavin Howard01055ba2018-11-03 11:00:21 -06004255 else
Denys Vlasenko00646792018-12-05 18:12:27 +01004256 s = bc_POSIX_does_not_allow_empty_X_expression_in_for("init");
Gavin Howard01055ba2018-11-03 11:00:21 -06004257
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004258 if (s) RETURN_STATUS(s);
4259 if (p->l.t.t != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004260 s = zbc_lex_next(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004261 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004262
4263 cond_idx = p->func->labels.len;
4264 update_idx = cond_idx + 1;
4265 body_idx = update_idx + 1;
4266 exit_idx = body_idx + 1;
4267
4268 bc_vec_push(&p->func->labels, &p->func->code.len);
4269
4270 if (p->l.t.t != BC_LEX_SCOLON)
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004271 s = zbc_parse_expr(p, BC_PARSE_REL, bc_parse_next_for);
Gavin Howard01055ba2018-11-03 11:00:21 -06004272 else
Denys Vlasenko00646792018-12-05 18:12:27 +01004273 s = bc_POSIX_does_not_allow_empty_X_expression_in_for("condition");
Gavin Howard01055ba2018-11-03 11:00:21 -06004274
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004275 if (s) RETURN_STATUS(s);
4276 if (p->l.t.t != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06004277
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004278 s = zbc_lex_next(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004279 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004280
4281 bc_parse_push(p, BC_INST_JUMP_ZERO);
4282 bc_parse_pushIndex(p, exit_idx);
4283 bc_parse_push(p, BC_INST_JUMP);
4284 bc_parse_pushIndex(p, body_idx);
4285
4286 ip.idx = p->func->labels.len;
4287
4288 bc_vec_push(&p->conds, &update_idx);
4289 bc_vec_push(&p->func->labels, &p->func->code.len);
4290
4291 if (p->l.t.t != BC_LEX_RPAREN)
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004292 s = zbc_parse_expr(p, 0, bc_parse_next_rel);
Gavin Howard01055ba2018-11-03 11:00:21 -06004293 else
Denys Vlasenko00646792018-12-05 18:12:27 +01004294 s = bc_POSIX_does_not_allow_empty_X_expression_in_for("update");
Gavin Howard01055ba2018-11-03 11:00:21 -06004295
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004296 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004297
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004298 if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06004299 bc_parse_push(p, BC_INST_JUMP);
4300 bc_parse_pushIndex(p, cond_idx);
4301 bc_vec_push(&p->func->labels, &p->func->code.len);
4302
4303 ip.idx = exit_idx;
4304 ip.func = 1;
4305 ip.len = 0;
4306
4307 bc_vec_push(&p->exits, &ip);
4308 bc_vec_push(&p->func->labels, &ip.idx);
Denys Vlasenko202dd192018-12-16 17:30:35 +01004309
4310 // for(...)<newline>stmt is accepted as well
4311 s = zbc_lex_next_and_skip_NLINE(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004312 if (s) RETURN_STATUS(s);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004313
Denys Vlasenkocb18b542018-12-16 20:46:15 +01004314 s = zbc_parse_stmt_fail_if_bare_NLINE(p, false, "for");
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004315 if (s) RETURN_STATUS(s);
4316
4317 n = *((size_t *) bc_vec_top(&p->conds));
4318 bc_parse_push(p, BC_INST_JUMP);
4319 bc_parse_pushIndex(p, n);
4320
4321 ipp = bc_vec_top(&p->exits);
4322 label = bc_vec_top(&p->conds);
4323
4324//TODO: commonalize?
4325 dbg_lex("%s:%d BC_INST_JUMP to %d", __func__, __LINE__, *label);
4326 bc_parse_push(p, BC_INST_JUMP);
4327 bc_parse_pushIndex(p, *label);
4328
4329 label = bc_vec_item(&p->func->labels, ipp->idx);
4330 dbg_lex("%s:%d rewriting label: %d -> %d", __func__, __LINE__, *label, p->func->code.len);
4331 *label = p->func->code.len;
4332
4333 bc_vec_pop(&p->exits);
4334 bc_vec_pop(&p->conds);
Gavin Howard01055ba2018-11-03 11:00:21 -06004335
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004336 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06004337}
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004338#if ERRORS_ARE_FATAL
4339# define zbc_parse_for(...) (zbc_parse_for(__VA_ARGS__), BC_STATUS_SUCCESS)
4340#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004341
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004342static BC_STATUS zbc_parse_break_or_continue(BcParse *p, BcLexType type)
Gavin Howard01055ba2018-11-03 11:00:21 -06004343{
4344 BcStatus s;
4345 size_t i;
Gavin Howard01055ba2018-11-03 11:00:21 -06004346
Gavin Howard01055ba2018-11-03 11:00:21 -06004347 if (type == BC_LEX_KEY_BREAK) {
Denys Vlasenko563d93c2018-12-16 19:47:40 +01004348 BcInstPtr *ipp;
Gavin Howard01055ba2018-11-03 11:00:21 -06004349
Denys Vlasenko563d93c2018-12-16 19:47:40 +01004350 i = p->exits.len;
4351 for (;;) {
4352 if (i == 0) // none of the enclosing blocks is a loop
4353 RETURN_STATUS(bc_error_bad_token());
4354 ipp = bc_vec_item(&p->exits, --i);
4355 if (ipp->func != 0)
4356 break;
4357 }
4358 i = ipp->idx;
Gavin Howard01055ba2018-11-03 11:00:21 -06004359 }
4360 else
4361 i = *((size_t *) bc_vec_top(&p->conds));
4362
4363 bc_parse_push(p, BC_INST_JUMP);
4364 bc_parse_pushIndex(p, i);
4365
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004366 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004367 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004368
4369 if (p->l.t.t != BC_LEX_SCOLON && p->l.t.t != BC_LEX_NLINE)
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004370 RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06004371
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004372 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06004373}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004374#if ERRORS_ARE_FATAL
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004375# define zbc_parse_break_or_continue(...) (zbc_parse_break_or_continue(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004376#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004377
Denys Vlasenkoe9519e42018-12-16 17:06:07 +01004378static BC_STATUS zbc_parse_funcdef(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06004379{
4380 BcStatus s;
4381 bool var, comma = false;
Gavin Howard01055ba2018-11-03 11:00:21 -06004382 char *name;
4383
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004384 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004385 if (s) RETURN_STATUS(s);
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004386 if (p->l.t.t != BC_LEX_NAME)
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004387 RETURN_STATUS(bc_error("bad function definition"));
Gavin Howard01055ba2018-11-03 11:00:21 -06004388
4389 name = xstrdup(p->l.t.v.v);
4390 bc_parse_addFunc(p, name, &p->fidx);
4391
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004392 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004393 if (s) RETURN_STATUS(s);
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004394 if (p->l.t.t != BC_LEX_LPAREN)
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004395 RETURN_STATUS(bc_error("bad function definition"));
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004396 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004397 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004398
4399 while (p->l.t.t != BC_LEX_RPAREN) {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004400 if (p->l.t.t != BC_LEX_NAME)
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004401 RETURN_STATUS(bc_error("bad function definition"));
Gavin Howard01055ba2018-11-03 11:00:21 -06004402
4403 ++p->func->nparams;
4404
4405 name = xstrdup(p->l.t.v.v);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004406 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004407 if (s) goto err;
4408
4409 var = p->l.t.t != BC_LEX_LBRACKET;
4410
4411 if (!var) {
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004412 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004413 if (s) goto err;
4414
4415 if (p->l.t.t != BC_LEX_RBRACKET) {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004416 s = bc_error("bad function definition");
Gavin Howard01055ba2018-11-03 11:00:21 -06004417 goto err;
4418 }
4419
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004420 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004421 if (s) goto err;
4422 }
4423
4424 comma = p->l.t.t == BC_LEX_COMMA;
4425 if (comma) {
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004426 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004427 if (s) goto err;
4428 }
4429
Denys Vlasenko29301232018-12-11 15:29:32 +01004430 s = zbc_func_insert(p->func, name, var);
Gavin Howard01055ba2018-11-03 11:00:21 -06004431 if (s) goto err;
4432 }
4433
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004434 if (comma) RETURN_STATUS(bc_error("bad function definition"));
Gavin Howard01055ba2018-11-03 11:00:21 -06004435
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004436 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004437 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004438
4439 if (p->l.t.t != BC_LEX_LBRACE)
Denys Vlasenkoa6f84e12018-12-06 11:10:11 +01004440 s = bc_POSIX_requires("the left brace be on the same line as the function header");
Gavin Howard01055ba2018-11-03 11:00:21 -06004441
Denys Vlasenko202dd192018-12-16 17:30:35 +01004442 // Prevent "define z()<newline>" from being interpreted as function with empty stmt as body
4443 s = zbc_lex_skip_if_at_NLINE(&p->l);
4444 if (s) RETURN_STATUS(s);
Denys Vlasenkoe9519e42018-12-16 17:06:07 +01004445//TODO: GNU bc requires a {} block even if function body has single stmt, enforce this?
4446
4447 p->in_funcdef++; // to determine whether "return" stmt is allowed, and such
Denys Vlasenkocb18b542018-12-16 20:46:15 +01004448 s = zbc_parse_stmt_fail_if_bare_NLINE(p, true, "define");
Denys Vlasenkoe9519e42018-12-16 17:06:07 +01004449 p->in_funcdef--;
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004450 if (s) RETURN_STATUS(s);
4451
4452 bc_parse_push(p, BC_INST_RET0);
4453 bc_parse_updateFunc(p, BC_PROG_MAIN);
4454
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004455 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004456
4457err:
4458 free(name);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004459 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004460}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004461#if ERRORS_ARE_FATAL
Denys Vlasenkoe9519e42018-12-16 17:06:07 +01004462# define zbc_parse_funcdef(...) (zbc_parse_funcdef(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004463#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004464
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004465static BC_STATUS zbc_parse_auto(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06004466{
4467 BcStatus s;
4468 bool comma, var, one;
4469 char *name;
4470
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004471 dbg_lex_enter("%s:%d entered", __func__, __LINE__);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004472 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004473 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004474
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004475 comma = false;
Gavin Howard01055ba2018-11-03 11:00:21 -06004476 one = p->l.t.t == BC_LEX_NAME;
4477
4478 while (p->l.t.t == BC_LEX_NAME) {
Gavin Howard01055ba2018-11-03 11:00:21 -06004479 name = xstrdup(p->l.t.v.v);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004480 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004481 if (s) goto err;
4482
4483 var = p->l.t.t != BC_LEX_LBRACKET;
4484 if (!var) {
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004485 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004486 if (s) goto err;
4487
4488 if (p->l.t.t != BC_LEX_RBRACKET) {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004489 s = bc_error("bad function definition");
Gavin Howard01055ba2018-11-03 11:00:21 -06004490 goto err;
4491 }
4492
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004493 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004494 if (s) goto err;
4495 }
4496
4497 comma = p->l.t.t == BC_LEX_COMMA;
4498 if (comma) {
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004499 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004500 if (s) goto err;
4501 }
4502
Denys Vlasenko29301232018-12-11 15:29:32 +01004503 s = zbc_func_insert(p->func, name, var);
Gavin Howard01055ba2018-11-03 11:00:21 -06004504 if (s) goto err;
4505 }
4506
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004507 if (comma) RETURN_STATUS(bc_error("bad function definition"));
4508 if (!one) RETURN_STATUS(bc_error("no auto variable found"));
Gavin Howard01055ba2018-11-03 11:00:21 -06004509
4510 if (p->l.t.t != BC_LEX_NLINE && p->l.t.t != BC_LEX_SCOLON)
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004511 RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06004512
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004513 dbg_lex_done("%s:%d done", __func__, __LINE__);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004514 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06004515
4516err:
4517 free(name);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004518 dbg_lex_done("%s:%d done (ERROR)", __func__, __LINE__);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004519 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004520}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004521#if ERRORS_ARE_FATAL
4522# define zbc_parse_auto(...) (zbc_parse_auto(__VA_ARGS__), BC_STATUS_SUCCESS)
4523#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004524
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004525#undef zbc_parse_stmt_possibly_auto
4526static BC_STATUS zbc_parse_stmt_possibly_auto(BcParse *p, bool auto_allowed)
Gavin Howard01055ba2018-11-03 11:00:21 -06004527{
4528 BcStatus s = BC_STATUS_SUCCESS;
4529
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01004530 dbg_lex_enter("%s:%d entered, p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
Gavin Howard01055ba2018-11-03 11:00:21 -06004531
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004532 if (p->l.t.t == BC_LEX_NLINE) {
4533 dbg_lex_done("%s:%d done (seen BC_LEX_NLINE)", __func__, __LINE__);
4534 RETURN_STATUS(zbc_lex_next(&p->l));
4535 }
4536 if (p->l.t.t == BC_LEX_SCOLON) {
4537 dbg_lex_done("%s:%d done (seen BC_LEX_SCOLON)", __func__, __LINE__);
4538 RETURN_STATUS(zbc_lex_next(&p->l));
4539 }
Gavin Howard01055ba2018-11-03 11:00:21 -06004540
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004541 if (p->l.t.t == BC_LEX_LBRACE) {
4542 dbg_lex("%s:%d BC_LEX_LBRACE: (auto_allowed:%d)", __func__, __LINE__, auto_allowed);
4543 do {
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004544 s = zbc_lex_next(&p->l);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004545 if (s) RETURN_STATUS(s);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004546 } while (p->l.t.t == BC_LEX_NLINE);
4547 if (auto_allowed && p->l.t.t == BC_LEX_KEY_AUTO) {
4548 dbg_lex("%s:%d calling zbc_parse_auto()", __func__, __LINE__);
4549 s = zbc_parse_auto(p);
4550 if (s) RETURN_STATUS(s);
4551 }
4552 while (p->l.t.t != BC_LEX_RBRACE) {
4553 dbg_lex("%s:%d block parsing loop", __func__, __LINE__);
4554 s = zbc_parse_stmt(p);
4555 if (s) RETURN_STATUS(s);
4556 }
4557 s = zbc_lex_next(&p->l);
4558 dbg_lex_done("%s:%d done (seen BC_LEX_RBRACE)", __func__, __LINE__);
4559 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004560 }
4561
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01004562 dbg_lex("%s:%d p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
Gavin Howard01055ba2018-11-03 11:00:21 -06004563 switch (p->l.t.t) {
Gavin Howard01055ba2018-11-03 11:00:21 -06004564 case BC_LEX_OP_INC:
4565 case BC_LEX_OP_DEC:
4566 case BC_LEX_OP_MINUS:
4567 case BC_LEX_OP_BOOL_NOT:
4568 case BC_LEX_LPAREN:
4569 case BC_LEX_NAME:
4570 case BC_LEX_NUMBER:
4571 case BC_LEX_KEY_IBASE:
4572 case BC_LEX_KEY_LAST:
4573 case BC_LEX_KEY_LENGTH:
4574 case BC_LEX_KEY_OBASE:
4575 case BC_LEX_KEY_READ:
4576 case BC_LEX_KEY_SCALE:
4577 case BC_LEX_KEY_SQRT:
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004578 s = zbc_parse_expr(p, BC_PARSE_PRINT, bc_parse_next_expr);
Gavin Howard01055ba2018-11-03 11:00:21 -06004579 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004580 case BC_LEX_STR:
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004581 s = zbc_parse_string(p, BC_INST_PRINT_STR);
Gavin Howard01055ba2018-11-03 11:00:21 -06004582 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004583 case BC_LEX_KEY_BREAK:
4584 case BC_LEX_KEY_CONTINUE:
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004585 s = zbc_parse_break_or_continue(p, p->l.t.t);
Gavin Howard01055ba2018-11-03 11:00:21 -06004586 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004587 case BC_LEX_KEY_FOR:
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004588 s = zbc_parse_for(p);
Gavin Howard01055ba2018-11-03 11:00:21 -06004589 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004590 case BC_LEX_KEY_HALT:
Gavin Howard01055ba2018-11-03 11:00:21 -06004591 bc_parse_push(p, BC_INST_HALT);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004592 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004593 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004594 case BC_LEX_KEY_IF:
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004595 s = zbc_parse_if(p);
Gavin Howard01055ba2018-11-03 11:00:21 -06004596 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004597 case BC_LEX_KEY_LIMITS:
Denys Vlasenkocfdc1332018-12-03 14:02:35 +01004598 // "limits" is a compile-time command,
4599 // the output is produced at _parse time_.
Denys Vlasenko64074a12018-12-07 15:50:14 +01004600 printf(
4601 "BC_BASE_MAX = "BC_MAX_OBASE_STR "\n"
4602 "BC_DIM_MAX = "BC_MAX_DIM_STR "\n"
4603 "BC_SCALE_MAX = "BC_MAX_SCALE_STR "\n"
4604 "BC_STRING_MAX = "BC_MAX_STRING_STR"\n"
4605 "BC_NAME_MAX = "BC_MAX_NAME_STR "\n"
4606 "BC_NUM_MAX = "BC_MAX_NUM_STR "\n"
4607 "MAX Exponent = "BC_MAX_EXP_STR "\n"
4608 "Number of vars = "BC_MAX_VARS_STR "\n"
4609 );
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004610 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004611 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004612 case BC_LEX_KEY_PRINT:
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004613 s = zbc_parse_print(p);
Gavin Howard01055ba2018-11-03 11:00:21 -06004614 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004615 case BC_LEX_KEY_QUIT:
Denys Vlasenkocfdc1332018-12-03 14:02:35 +01004616 // "quit" is a compile-time command. For example,
4617 // "if (0 == 1) quit" terminates when parsing the statement,
4618 // not when it is executed
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +01004619 QUIT_OR_RETURN_TO_MAIN;
Gavin Howard01055ba2018-11-03 11:00:21 -06004620 case BC_LEX_KEY_RETURN:
Denys Vlasenkoe9519e42018-12-16 17:06:07 +01004621 if (!p->in_funcdef)
4622 RETURN_STATUS(bc_error("'return' not in a function"));
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004623 s = zbc_parse_return(p);
Gavin Howard01055ba2018-11-03 11:00:21 -06004624 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004625 case BC_LEX_KEY_WHILE:
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004626 s = zbc_parse_while(p);
Gavin Howard01055ba2018-11-03 11:00:21 -06004627 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004628 default:
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004629 s = bc_error_bad_token();
Gavin Howard01055ba2018-11-03 11:00:21 -06004630 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06004631 }
4632
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004633 if (s || G_interrupt) {
4634 bc_parse_reset(p);
4635 s = BC_STATUS_FAILURE;
4636 }
4637
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01004638 dbg_lex_done("%s:%d done", __func__, __LINE__);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004639 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004640}
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004641#if ERRORS_ARE_FATAL
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004642# define zbc_parse_stmt_possibly_auto(...) (zbc_parse_stmt_possibly_auto(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004643#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004644
Denys Vlasenko99b37622018-12-15 20:06:59 +01004645static BC_STATUS zbc_parse_stmt_or_funcdef(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06004646{
4647 BcStatus s;
4648
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01004649 dbg_lex_enter("%s:%d entered", __func__, __LINE__);
Gavin Howard01055ba2018-11-03 11:00:21 -06004650 if (p->l.t.t == BC_LEX_EOF)
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004651 s = bc_error("end of file");
Gavin Howard01055ba2018-11-03 11:00:21 -06004652 else if (p->l.t.t == BC_LEX_KEY_DEFINE) {
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01004653 dbg_lex("%s:%d p->l.t.t:BC_LEX_KEY_DEFINE", __func__, __LINE__);
Denys Vlasenkoe9519e42018-12-16 17:06:07 +01004654 s = zbc_parse_funcdef(p);
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01004655 } else {
4656 dbg_lex("%s:%d p->l.t.t:%d (not BC_LEX_KEY_DEFINE)", __func__, __LINE__, p->l.t.t);
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004657 s = zbc_parse_stmt(p);
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01004658 }
Gavin Howard01055ba2018-11-03 11:00:21 -06004659
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01004660 dbg_lex_done("%s:%d done", __func__, __LINE__);
Denys Vlasenko26819db2018-12-12 16:08:46 +01004661 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004662}
Denys Vlasenko26819db2018-12-12 16:08:46 +01004663#if ERRORS_ARE_FATAL
Denys Vlasenko99b37622018-12-15 20:06:59 +01004664# define zbc_parse_stmt_or_funcdef(...) (zbc_parse_stmt_or_funcdef(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko26819db2018-12-12 16:08:46 +01004665#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004666
Denys Vlasenkob402ff82018-12-11 15:45:15 +01004667// This is not a "z" function: can also return BC_STATUS_PARSE_EMPTY_EXP
Denys Vlasenko050b0fe2018-12-05 22:40:44 +01004668static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags, BcParseNext next)
Gavin Howard01055ba2018-11-03 11:00:21 -06004669{
4670 BcStatus s = BC_STATUS_SUCCESS;
4671 BcInst prev = BC_INST_PRINT;
4672 BcLexType top, t = p->l.t.t;
4673 size_t nexprs = 0, ops_bgn = p->ops.len;
Denys Vlasenko18c6b542018-12-07 12:57:32 +01004674 unsigned nparens, nrelops;
Gavin Howard01055ba2018-11-03 11:00:21 -06004675 bool paren_first, paren_expr, rprn, done, get_token, assign, bin_last;
4676
Denys Vlasenko17df8822018-12-14 23:00:24 +01004677 dbg_lex_enter("%s:%d entered", __func__, __LINE__);
Gavin Howard01055ba2018-11-03 11:00:21 -06004678 paren_first = p->l.t.t == BC_LEX_LPAREN;
4679 nparens = nrelops = 0;
4680 paren_expr = rprn = done = get_token = assign = false;
4681 bin_last = true;
4682
Denys Vlasenkobcb62a72018-12-05 20:17:48 +01004683 for (; !G_interrupt && !s && !done && bc_parse_exprs(t); t = p->l.t.t) {
Gavin Howard01055ba2018-11-03 11:00:21 -06004684 switch (t) {
4685
4686 case BC_LEX_OP_INC:
4687 case BC_LEX_OP_DEC:
4688 {
Denys Vlasenko26819db2018-12-12 16:08:46 +01004689 s = zbc_parse_incdec(p, &prev, &paren_expr, &nexprs, flags);
Gavin Howard01055ba2018-11-03 11:00:21 -06004690 rprn = get_token = bin_last = false;
4691 break;
4692 }
4693
4694 case BC_LEX_OP_MINUS:
4695 {
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004696 s = zbc_parse_minus(p, &prev, ops_bgn, rprn, &nexprs);
Gavin Howard01055ba2018-11-03 11:00:21 -06004697 rprn = get_token = false;
4698 bin_last = prev == BC_INST_MINUS;
4699 break;
4700 }
4701
4702 case BC_LEX_OP_ASSIGN_POWER:
4703 case BC_LEX_OP_ASSIGN_MULTIPLY:
4704 case BC_LEX_OP_ASSIGN_DIVIDE:
4705 case BC_LEX_OP_ASSIGN_MODULUS:
4706 case BC_LEX_OP_ASSIGN_PLUS:
4707 case BC_LEX_OP_ASSIGN_MINUS:
4708 case BC_LEX_OP_ASSIGN:
4709 {
4710 if (prev != BC_INST_VAR && prev != BC_INST_ARRAY_ELEM &&
4711 prev != BC_INST_SCALE && prev != BC_INST_IBASE &&
4712 prev != BC_INST_OBASE && prev != BC_INST_LAST)
4713 {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004714 s = bc_error("bad assignment:"
Denys Vlasenko0154d782018-12-14 23:32:51 +01004715 " left side must be variable"
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004716 " or array element"
Denys Vlasenko0154d782018-12-14 23:32:51 +01004717 ); // note: shared string
Gavin Howard01055ba2018-11-03 11:00:21 -06004718 break;
4719 }
4720 }
4721 // Fallthrough.
4722 case BC_LEX_OP_POWER:
4723 case BC_LEX_OP_MULTIPLY:
4724 case BC_LEX_OP_DIVIDE:
4725 case BC_LEX_OP_MODULUS:
4726 case BC_LEX_OP_PLUS:
4727 case BC_LEX_OP_REL_EQ:
4728 case BC_LEX_OP_REL_LE:
4729 case BC_LEX_OP_REL_GE:
4730 case BC_LEX_OP_REL_NE:
4731 case BC_LEX_OP_REL_LT:
4732 case BC_LEX_OP_REL_GT:
4733 case BC_LEX_OP_BOOL_NOT:
4734 case BC_LEX_OP_BOOL_OR:
4735 case BC_LEX_OP_BOOL_AND:
4736 {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004737 if (((t == BC_LEX_OP_BOOL_NOT) != bin_last)
4738 || (t != BC_LEX_OP_BOOL_NOT && prev == BC_INST_BOOL_NOT)
4739 ) {
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004740 return bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06004741 }
4742
4743 nrelops += t >= BC_LEX_OP_REL_EQ && t <= BC_LEX_OP_REL_GT;
Denys Vlasenko0154d782018-12-14 23:32:51 +01004744 prev = BC_TOKEN_2_INST(t);
Denys Vlasenko7b1df3d2018-12-14 23:12:48 +01004745 bc_parse_operator(p, t, ops_bgn, &nexprs);
4746 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004747 rprn = get_token = false;
4748 bin_last = t != BC_LEX_OP_BOOL_NOT;
4749
4750 break;
4751 }
4752
4753 case BC_LEX_LPAREN:
4754 {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004755 if (BC_PARSE_LEAF(prev, rprn))
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004756 return bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06004757 ++nparens;
4758 paren_expr = rprn = bin_last = false;
4759 get_token = true;
4760 bc_vec_push(&p->ops, &t);
4761
4762 break;
4763 }
4764
4765 case BC_LEX_RPAREN:
4766 {
4767 if (bin_last || prev == BC_INST_BOOL_NOT)
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004768 return bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06004769
4770 if (nparens == 0) {
4771 s = BC_STATUS_SUCCESS;
4772 done = true;
4773 get_token = false;
4774 break;
4775 }
Denys Vlasenko17df8822018-12-14 23:00:24 +01004776 else if (!paren_expr) {
4777 dbg_lex_done("%s:%d done (returning EMPTY_EXP)", __func__, __LINE__);
Gavin Howard01055ba2018-11-03 11:00:21 -06004778 return BC_STATUS_PARSE_EMPTY_EXP;
Denys Vlasenko17df8822018-12-14 23:00:24 +01004779 }
Gavin Howard01055ba2018-11-03 11:00:21 -06004780
4781 --nparens;
4782 paren_expr = rprn = true;
4783 get_token = bin_last = false;
4784
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004785 s = zbc_parse_rightParen(p, ops_bgn, &nexprs);
Gavin Howard01055ba2018-11-03 11:00:21 -06004786
4787 break;
4788 }
4789
4790 case BC_LEX_NAME:
4791 {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004792 if (BC_PARSE_LEAF(prev, rprn))
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004793 return bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06004794 paren_expr = true;
4795 rprn = get_token = bin_last = false;
Denys Vlasenko26819db2018-12-12 16:08:46 +01004796 s = zbc_parse_name(p, &prev, flags & ~BC_PARSE_NOCALL);
Gavin Howard01055ba2018-11-03 11:00:21 -06004797 ++nexprs;
4798
4799 break;
4800 }
4801
4802 case BC_LEX_NUMBER:
4803 {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004804 if (BC_PARSE_LEAF(prev, rprn))
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004805 return bc_error_bad_expression();
Denys Vlasenko9dc5d082018-12-16 18:43:51 +01004806 bc_parse_number(p);
4807 nexprs++;
4808 prev = BC_INST_NUM;
Gavin Howard01055ba2018-11-03 11:00:21 -06004809 paren_expr = get_token = true;
4810 rprn = bin_last = false;
4811
4812 break;
4813 }
4814
4815 case BC_LEX_KEY_IBASE:
4816 case BC_LEX_KEY_LAST:
4817 case BC_LEX_KEY_OBASE:
4818 {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004819 if (BC_PARSE_LEAF(prev, rprn))
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004820 return bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06004821 prev = (char) (t - BC_LEX_KEY_IBASE + BC_INST_IBASE);
4822 bc_parse_push(p, (char) prev);
4823
4824 paren_expr = get_token = true;
4825 rprn = bin_last = false;
4826 ++nexprs;
4827
4828 break;
4829 }
4830
4831 case BC_LEX_KEY_LENGTH:
4832 case BC_LEX_KEY_SQRT:
4833 {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004834 if (BC_PARSE_LEAF(prev, rprn))
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004835 return bc_error_bad_expression();
Denys Vlasenko26819db2018-12-12 16:08:46 +01004836 s = zbc_parse_builtin(p, t, flags, &prev);
Gavin Howard01055ba2018-11-03 11:00:21 -06004837 paren_expr = true;
4838 rprn = get_token = bin_last = false;
4839 ++nexprs;
4840
4841 break;
4842 }
4843
4844 case BC_LEX_KEY_READ:
4845 {
4846 if (BC_PARSE_LEAF(prev, rprn))
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004847 return bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06004848 else if (flags & BC_PARSE_NOREAD)
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004849 s = bc_error_nested_read_call();
Gavin Howard01055ba2018-11-03 11:00:21 -06004850 else
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004851 s = zbc_parse_read(p);
Gavin Howard01055ba2018-11-03 11:00:21 -06004852
4853 paren_expr = true;
4854 rprn = get_token = bin_last = false;
4855 ++nexprs;
4856 prev = BC_INST_READ;
4857
4858 break;
4859 }
4860
4861 case BC_LEX_KEY_SCALE:
4862 {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004863 if (BC_PARSE_LEAF(prev, rprn))
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004864 return bc_error_bad_expression();
Denys Vlasenko26819db2018-12-12 16:08:46 +01004865 s = zbc_parse_scale(p, &prev, flags);
Gavin Howard01055ba2018-11-03 11:00:21 -06004866 paren_expr = true;
4867 rprn = get_token = bin_last = false;
4868 ++nexprs;
4869 prev = BC_INST_SCALE;
4870
4871 break;
4872 }
4873
4874 default:
4875 {
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004876 s = bc_error_bad_token();
Gavin Howard01055ba2018-11-03 11:00:21 -06004877 break;
4878 }
4879 }
4880
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004881 if (!s && get_token) s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06004882 }
4883
4884 if (s) return s;
Denys Vlasenkod38af482018-12-04 19:11:02 +01004885 if (G_interrupt) return BC_STATUS_FAILURE; // ^C: stop parsing
Gavin Howard01055ba2018-11-03 11:00:21 -06004886
4887 while (p->ops.len > ops_bgn) {
4888
4889 top = BC_PARSE_TOP_OP(p);
4890 assign = top >= BC_LEX_OP_ASSIGN_POWER && top <= BC_LEX_OP_ASSIGN;
4891
4892 if (top == BC_LEX_LPAREN || top == BC_LEX_RPAREN)
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004893 return bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06004894
Denys Vlasenko0154d782018-12-14 23:32:51 +01004895 bc_parse_push(p, BC_TOKEN_2_INST(top));
Gavin Howard01055ba2018-11-03 11:00:21 -06004896
4897 nexprs -= top != BC_LEX_OP_BOOL_NOT && top != BC_LEX_NEG;
4898 bc_vec_pop(&p->ops);
4899 }
4900
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004901 if (prev == BC_INST_BOOL_NOT || nexprs != 1)
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01004902 return bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06004903
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004904//TODO: why is this needed at all?
Denys Vlasenko18c6b542018-12-07 12:57:32 +01004905 // next is BcParseNext, byte array of up to 4 BC_LEX's, packed into 32-bit word
4906 for (;;) {
4907 if (t == (next & 0x7f))
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004908 goto ok;
Denys Vlasenko18c6b542018-12-07 12:57:32 +01004909 if (next & 0x80) // last element?
4910 break;
4911 next >>= 8;
4912 }
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01004913 if (t != BC_LEX_KEY_ELSE)
4914 return bc_error_bad_expression();
Denys Vlasenko60cf7472018-12-04 20:05:28 +01004915 ok:
Gavin Howard01055ba2018-11-03 11:00:21 -06004916
4917 if (!(flags & BC_PARSE_REL) && nrelops) {
Denys Vlasenko00646792018-12-05 18:12:27 +01004918 s = bc_POSIX_does_not_allow("comparison operators outside if or loops");
Denys Vlasenko12b9eaf2018-12-11 23:50:14 +01004919 ERROR_RETURN(if (s) return s;)
Gavin Howard01055ba2018-11-03 11:00:21 -06004920 }
4921 else if ((flags & BC_PARSE_REL) && nrelops > 1) {
Denys Vlasenkoa6f84e12018-12-06 11:10:11 +01004922 s = bc_POSIX_requires("exactly one comparison operator per condition");
Denys Vlasenko12b9eaf2018-12-11 23:50:14 +01004923 ERROR_RETURN(if (s) return s;)
Gavin Howard01055ba2018-11-03 11:00:21 -06004924 }
4925
4926 if (flags & BC_PARSE_PRINT) {
4927 if (paren_first || !assign) bc_parse_push(p, BC_INST_PRINT);
4928 bc_parse_push(p, BC_INST_POP);
4929 }
4930
Denys Vlasenko17df8822018-12-14 23:00:24 +01004931 dbg_lex_done("%s:%d done", __func__, __LINE__);
Gavin Howard01055ba2018-11-03 11:00:21 -06004932 return s;
4933}
4934
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004935#undef zbc_parse_expr
4936static BC_STATUS zbc_parse_expr(BcParse *p, uint8_t flags, BcParseNext next)
Denys Vlasenko050b0fe2018-12-05 22:40:44 +01004937{
4938 BcStatus s;
4939
4940 s = bc_parse_expr_empty_ok(p, flags, next);
4941 if (s == BC_STATUS_PARSE_EMPTY_EXP)
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004942 RETURN_STATUS(bc_error("empty expression"));
4943 RETURN_STATUS(s);
Denys Vlasenko050b0fe2018-12-05 22:40:44 +01004944}
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01004945#if ERRORS_ARE_FATAL
4946# define zbc_parse_expr(...) (zbc_parse_expr(__VA_ARGS__), BC_STATUS_SUCCESS)
4947#endif
Denys Vlasenko050b0fe2018-12-05 22:40:44 +01004948
Gavin Howard01055ba2018-11-03 11:00:21 -06004949#endif // ENABLE_BC
4950
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01004951#if ENABLE_DC
Denys Vlasenkocca79a02018-12-05 21:15:46 +01004952
4953#define DC_PARSE_BUF_LEN ((int) (sizeof(uint32_t) * CHAR_BIT))
4954
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004955static BC_STATUS zdc_parse_register(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06004956{
4957 BcStatus s;
Gavin Howard01055ba2018-11-03 11:00:21 -06004958
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004959 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004960 if (s) RETURN_STATUS(s);
4961 if (p->l.t.t != BC_LEX_NAME) RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06004962
Denys Vlasenkoe6c40c42018-12-16 20:32:58 +01004963 bc_parse_pushName(p, p->l.t.v.v);
Gavin Howard01055ba2018-11-03 11:00:21 -06004964
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004965 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004966}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004967#if ERRORS_ARE_FATAL
4968# define zdc_parse_register(...) (zdc_parse_register(__VA_ARGS__), BC_STATUS_SUCCESS)
4969#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004970
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004971static BC_STATUS zdc_parse_string(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06004972{
4973 char *str, *name, b[DC_PARSE_BUF_LEN + 1];
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01004974 size_t idx, len = G.prog.strs.len;
Gavin Howard01055ba2018-11-03 11:00:21 -06004975
4976 sprintf(b, "%0*zu", DC_PARSE_BUF_LEN, len);
4977 name = xstrdup(b);
4978
4979 str = xstrdup(p->l.t.v.v);
4980 bc_parse_push(p, BC_INST_STR);
4981 bc_parse_pushIndex(p, len);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01004982 bc_vec_push(&G.prog.strs, &str);
Gavin Howard01055ba2018-11-03 11:00:21 -06004983 bc_parse_addFunc(p, name, &idx);
4984
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004985 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06004986}
Denys Vlasenko9a34e892018-12-12 13:58:55 +01004987#if ERRORS_ARE_FATAL
4988# define zdc_parse_string(...) (zdc_parse_string(__VA_ARGS__), BC_STATUS_SUCCESS)
4989#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06004990
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004991static BC_STATUS zdc_parse_mem(BcParse *p, uint8_t inst, bool name, bool store)
Gavin Howard01055ba2018-11-03 11:00:21 -06004992{
4993 BcStatus s;
4994
4995 bc_parse_push(p, inst);
4996 if (name) {
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01004997 s = zdc_parse_register(p);
4998 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06004999 }
5000
5001 if (store) {
5002 bc_parse_push(p, BC_INST_SWAP);
5003 bc_parse_push(p, BC_INST_ASSIGN);
5004 bc_parse_push(p, BC_INST_POP);
5005 }
5006
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005007 RETURN_STATUS(zbc_lex_next(&p->l));
Gavin Howard01055ba2018-11-03 11:00:21 -06005008}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005009#if ERRORS_ARE_FATAL
5010# define zdc_parse_mem(...) (zdc_parse_mem(__VA_ARGS__), BC_STATUS_SUCCESS)
5011#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005012
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005013static BC_STATUS zdc_parse_cond(BcParse *p, uint8_t inst)
Gavin Howard01055ba2018-11-03 11:00:21 -06005014{
5015 BcStatus s;
5016
5017 bc_parse_push(p, inst);
5018 bc_parse_push(p, BC_INST_EXEC_COND);
5019
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005020 s = zdc_parse_register(p);
5021 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005022
Denys Vlasenko9a34e892018-12-12 13:58:55 +01005023 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005024 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005025
5026 if (p->l.t.t == BC_LEX_ELSE) {
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005027 s = zdc_parse_register(p);
5028 if (s) RETURN_STATUS(s);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01005029 s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06005030 }
5031 else
5032 bc_parse_push(p, BC_PARSE_STREND);
5033
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005034 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005035}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005036#if ERRORS_ARE_FATAL
5037# define zdc_parse_cond(...) (zdc_parse_cond(__VA_ARGS__), BC_STATUS_SUCCESS)
5038#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005039
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005040static BC_STATUS zdc_parse_token(BcParse *p, BcLexType t, uint8_t flags)
Gavin Howard01055ba2018-11-03 11:00:21 -06005041{
5042 BcStatus s = BC_STATUS_SUCCESS;
5043 BcInst prev;
5044 uint8_t inst;
5045 bool assign, get_token = false;
5046
5047 switch (t) {
Gavin Howard01055ba2018-11-03 11:00:21 -06005048 case BC_LEX_OP_REL_EQ:
5049 case BC_LEX_OP_REL_LE:
5050 case BC_LEX_OP_REL_GE:
5051 case BC_LEX_OP_REL_NE:
5052 case BC_LEX_OP_REL_LT:
5053 case BC_LEX_OP_REL_GT:
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005054 s = zdc_parse_cond(p, t - BC_LEX_OP_REL_EQ + BC_INST_REL_EQ);
Gavin Howard01055ba2018-11-03 11:00:21 -06005055 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005056 case BC_LEX_SCOLON:
5057 case BC_LEX_COLON:
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005058 s = zdc_parse_mem(p, BC_INST_ARRAY_ELEM, true, t == BC_LEX_COLON);
Gavin Howard01055ba2018-11-03 11:00:21 -06005059 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005060 case BC_LEX_STR:
Denys Vlasenko9a34e892018-12-12 13:58:55 +01005061 s = zdc_parse_string(p);
Gavin Howard01055ba2018-11-03 11:00:21 -06005062 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005063 case BC_LEX_NEG:
5064 case BC_LEX_NUMBER:
Gavin Howard01055ba2018-11-03 11:00:21 -06005065 if (t == BC_LEX_NEG) {
Denys Vlasenko9a34e892018-12-12 13:58:55 +01005066 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005067 if (s) RETURN_STATUS(s);
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005068 if (p->l.t.t != BC_LEX_NUMBER)
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005069 RETURN_STATUS(bc_error_bad_token());
Gavin Howard01055ba2018-11-03 11:00:21 -06005070 }
Denys Vlasenko9dc5d082018-12-16 18:43:51 +01005071 bc_parse_number(p);
5072 prev = BC_INST_NUM;
Gavin Howard01055ba2018-11-03 11:00:21 -06005073 if (t == BC_LEX_NEG) bc_parse_push(p, BC_INST_NEG);
5074 get_token = true;
Gavin Howard01055ba2018-11-03 11:00:21 -06005075 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005076 case BC_LEX_KEY_READ:
Gavin Howard01055ba2018-11-03 11:00:21 -06005077 if (flags & BC_PARSE_NOREAD)
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01005078 s = bc_error_nested_read_call();
Gavin Howard01055ba2018-11-03 11:00:21 -06005079 else
5080 bc_parse_push(p, BC_INST_READ);
5081 get_token = true;
5082 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005083 case BC_LEX_OP_ASSIGN:
5084 case BC_LEX_STORE_PUSH:
Gavin Howard01055ba2018-11-03 11:00:21 -06005085 assign = t == BC_LEX_OP_ASSIGN;
5086 inst = assign ? BC_INST_VAR : BC_INST_PUSH_TO_VAR;
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005087 s = zdc_parse_mem(p, inst, true, assign);
Gavin Howard01055ba2018-11-03 11:00:21 -06005088 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005089 case BC_LEX_LOAD:
5090 case BC_LEX_LOAD_POP:
Gavin Howard01055ba2018-11-03 11:00:21 -06005091 inst = t == BC_LEX_LOAD_POP ? BC_INST_PUSH_VAR : BC_INST_LOAD;
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005092 s = zdc_parse_mem(p, inst, true, false);
Gavin Howard01055ba2018-11-03 11:00:21 -06005093 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005094 case BC_LEX_STORE_IBASE:
5095 case BC_LEX_STORE_SCALE:
5096 case BC_LEX_STORE_OBASE:
Gavin Howard01055ba2018-11-03 11:00:21 -06005097 inst = t - BC_LEX_STORE_IBASE + BC_INST_IBASE;
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005098 s = zdc_parse_mem(p, inst, false, true);
Gavin Howard01055ba2018-11-03 11:00:21 -06005099 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005100 default:
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01005101 s = bc_error_bad_token();
Gavin Howard01055ba2018-11-03 11:00:21 -06005102 get_token = true;
5103 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005104 }
5105
Denys Vlasenko9a34e892018-12-12 13:58:55 +01005106 if (!s && get_token) s = zbc_lex_next(&p->l);
Gavin Howard01055ba2018-11-03 11:00:21 -06005107
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005108 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005109}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005110#if ERRORS_ARE_FATAL
5111# define zdc_parse_token(...) (zdc_parse_token(__VA_ARGS__), BC_STATUS_SUCCESS)
5112#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005113
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005114static BC_STATUS zdc_parse_expr(BcParse *p, uint8_t flags)
Gavin Howard01055ba2018-11-03 11:00:21 -06005115{
5116 BcStatus s = BC_STATUS_SUCCESS;
5117 BcInst inst;
5118 BcLexType t;
5119
Gavin Howard01055ba2018-11-03 11:00:21 -06005120 for (t = p->l.t.t; !s && t != BC_LEX_EOF; t = p->l.t.t) {
Gavin Howard01055ba2018-11-03 11:00:21 -06005121 inst = dc_parse_insts[t];
5122
5123 if (inst != BC_INST_INVALID) {
5124 bc_parse_push(p, inst);
Denys Vlasenko9a34e892018-12-12 13:58:55 +01005125 s = zbc_lex_next(&p->l);
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005126 } else
5127 s = zdc_parse_token(p, t, flags);
Gavin Howard01055ba2018-11-03 11:00:21 -06005128 }
5129
5130 if (!s && p->l.t.t == BC_LEX_EOF && (flags & BC_PARSE_NOCALL))
5131 bc_parse_push(p, BC_INST_POP_EXEC);
5132
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005133 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005134}
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005135#if ERRORS_ARE_FATAL
5136# define zdc_parse_expr(...) (zdc_parse_expr(__VA_ARGS__), BC_STATUS_SUCCESS)
5137#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005138
Denys Vlasenkoc0ef23c2018-12-12 23:03:10 +01005139static BC_STATUS zdc_parse_parse(BcParse *p)
Gavin Howard01055ba2018-11-03 11:00:21 -06005140{
5141 BcStatus s;
5142
5143 if (p->l.t.t == BC_LEX_EOF)
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005144 s = bc_error("end of file");
Gavin Howard01055ba2018-11-03 11:00:21 -06005145 else
Denys Vlasenko8cd468f2018-12-12 14:54:38 +01005146 s = zdc_parse_expr(p, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06005147
Denys Vlasenkod38af482018-12-04 19:11:02 +01005148 if (s || G_interrupt) {
5149 bc_parse_reset(p);
5150 s = BC_STATUS_FAILURE;
5151 }
Gavin Howard01055ba2018-11-03 11:00:21 -06005152
Denys Vlasenko26819db2018-12-12 16:08:46 +01005153 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005154}
Denys Vlasenko26819db2018-12-12 16:08:46 +01005155#if ERRORS_ARE_FATAL
5156# define zdc_parse_parse(...) (zdc_parse_parse(__VA_ARGS__), BC_STATUS_SUCCESS)
5157#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005158
Gavin Howard01055ba2018-11-03 11:00:21 -06005159#endif // ENABLE_DC
5160
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01005161static BC_STATUS zcommon_parse_expr(BcParse *p, uint8_t flags)
Denys Vlasenkof6c1da52018-12-02 17:36:00 +01005162{
5163 if (IS_BC) {
Denys Vlasenko99b37622018-12-15 20:06:59 +01005164 IF_BC(RETURN_STATUS(zbc_parse_expr(p, flags, bc_parse_next_read)));
Denys Vlasenkof6c1da52018-12-02 17:36:00 +01005165 } else {
Denys Vlasenko99b37622018-12-15 20:06:59 +01005166 IF_DC(RETURN_STATUS(zdc_parse_expr(p, flags)));
Denys Vlasenkof6c1da52018-12-02 17:36:00 +01005167 }
5168}
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01005169#if ERRORS_ARE_FATAL
5170# define zcommon_parse_expr(...) (zcommon_parse_expr(__VA_ARGS__), BC_STATUS_SUCCESS)
5171#endif
Denys Vlasenkof6c1da52018-12-02 17:36:00 +01005172
Denys Vlasenkodf515392018-12-02 19:27:48 +01005173static BcVec* bc_program_search(char *id, bool var)
Gavin Howard01055ba2018-11-03 11:00:21 -06005174{
Gavin Howard01055ba2018-11-03 11:00:21 -06005175 BcId e, *ptr;
5176 BcVec *v, *map;
5177 size_t i;
5178 BcResultData data;
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01005179 int new;
Gavin Howard01055ba2018-11-03 11:00:21 -06005180
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005181 v = var ? &G.prog.vars : &G.prog.arrs;
5182 map = var ? &G.prog.var_map : &G.prog.arr_map;
Gavin Howard01055ba2018-11-03 11:00:21 -06005183
5184 e.name = id;
5185 e.idx = v->len;
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01005186 new = bc_map_insert(map, &e, &i); // 1 if insertion was successful
Gavin Howard01055ba2018-11-03 11:00:21 -06005187
5188 if (new) {
5189 bc_array_init(&data.v, var);
5190 bc_vec_push(v, &data.v);
5191 }
5192
5193 ptr = bc_vec_item(map, i);
5194 if (new) ptr->name = xstrdup(e.name);
Denys Vlasenkodf515392018-12-02 19:27:48 +01005195 return bc_vec_item(v, ptr->idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06005196}
5197
Denys Vlasenko29301232018-12-11 15:29:32 +01005198static BC_STATUS zbc_program_num(BcResult *r, BcNum **num, bool hex)
Gavin Howard01055ba2018-11-03 11:00:21 -06005199{
Gavin Howard01055ba2018-11-03 11:00:21 -06005200 switch (r->t) {
5201
5202 case BC_RESULT_STR:
5203 case BC_RESULT_TEMP:
5204 case BC_RESULT_IBASE:
5205 case BC_RESULT_SCALE:
5206 case BC_RESULT_OBASE:
5207 {
5208 *num = &r->d.n;
5209 break;
5210 }
5211
5212 case BC_RESULT_CONSTANT:
5213 {
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005214 BcStatus s;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005215 char **str = bc_vec_item(&G.prog.consts, r->d.id.idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06005216 size_t base_t, len = strlen(*str);
5217 BcNum *base;
5218
5219 bc_num_init(&r->d.n, len);
5220
5221 hex = hex && len == 1;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005222 base = hex ? &G.prog.hexb : &G.prog.ib;
5223 base_t = hex ? BC_NUM_MAX_IBASE : G.prog.ib_t;
Denys Vlasenko29301232018-12-11 15:29:32 +01005224 s = zbc_num_parse(&r->d.n, *str, base, base_t);
Gavin Howard01055ba2018-11-03 11:00:21 -06005225
5226 if (s) {
5227 bc_num_free(&r->d.n);
Denys Vlasenko29301232018-12-11 15:29:32 +01005228 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005229 }
5230
5231 *num = &r->d.n;
5232 r->t = BC_RESULT_TEMP;
5233
5234 break;
5235 }
5236
5237 case BC_RESULT_VAR:
5238 case BC_RESULT_ARRAY:
5239 case BC_RESULT_ARRAY_ELEM:
5240 {
5241 BcVec *v;
5242
Denys Vlasenkodf515392018-12-02 19:27:48 +01005243 v = bc_program_search(r->d.id.name, r->t == BC_RESULT_VAR);
Gavin Howard01055ba2018-11-03 11:00:21 -06005244
5245 if (r->t == BC_RESULT_ARRAY_ELEM) {
5246 v = bc_vec_top(v);
5247 if (v->len <= r->d.id.idx) bc_array_expand(v, r->d.id.idx + 1);
5248 *num = bc_vec_item(v, r->d.id.idx);
5249 }
5250 else
5251 *num = bc_vec_top(v);
5252
5253 break;
5254 }
5255
5256 case BC_RESULT_LAST:
5257 {
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005258 *num = &G.prog.last;
Gavin Howard01055ba2018-11-03 11:00:21 -06005259 break;
5260 }
5261
5262 case BC_RESULT_ONE:
5263 {
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005264 *num = &G.prog.one;
Gavin Howard01055ba2018-11-03 11:00:21 -06005265 break;
5266 }
5267 }
5268
Denys Vlasenko29301232018-12-11 15:29:32 +01005269 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06005270}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005271#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01005272# define zbc_program_num(...) (zbc_program_num(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005273#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005274
Denys Vlasenko29301232018-12-11 15:29:32 +01005275static BC_STATUS zbc_program_binOpPrep(BcResult **l, BcNum **ln,
Gavin Howard01055ba2018-11-03 11:00:21 -06005276 BcResult **r, BcNum **rn, bool assign)
5277{
5278 BcStatus s;
5279 bool hex;
5280 BcResultType lt, rt;
5281
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005282 if (!BC_PROG_STACK(&G.prog.results, 2))
Denys Vlasenko29301232018-12-11 15:29:32 +01005283 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Gavin Howard01055ba2018-11-03 11:00:21 -06005284
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005285 *r = bc_vec_item_rev(&G.prog.results, 0);
5286 *l = bc_vec_item_rev(&G.prog.results, 1);
Gavin Howard01055ba2018-11-03 11:00:21 -06005287
5288 lt = (*l)->t;
5289 rt = (*r)->t;
5290 hex = assign && (lt == BC_RESULT_IBASE || lt == BC_RESULT_OBASE);
5291
Denys Vlasenko29301232018-12-11 15:29:32 +01005292 s = zbc_program_num(*l, ln, false);
5293 if (s) RETURN_STATUS(s);
5294 s = zbc_program_num(*r, rn, hex);
5295 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005296
5297 // We run this again under these conditions in case any vector has been
5298 // reallocated out from under the BcNums or arrays we had.
5299 if (lt == rt && (lt == BC_RESULT_VAR || lt == BC_RESULT_ARRAY_ELEM)) {
Denys Vlasenko29301232018-12-11 15:29:32 +01005300 s = zbc_program_num(*l, ln, false);
5301 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005302 }
5303
5304 if (!BC_PROG_NUM((*l), (*ln)) && (!assign || (*l)->t != BC_RESULT_VAR))
Denys Vlasenko29301232018-12-11 15:29:32 +01005305 RETURN_STATUS(bc_error_variable_is_wrong_type());
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005306 if (!assign && !BC_PROG_NUM((*r), (*ln)))
Denys Vlasenko29301232018-12-11 15:29:32 +01005307 RETURN_STATUS(bc_error_variable_is_wrong_type());
Gavin Howard01055ba2018-11-03 11:00:21 -06005308
Denys Vlasenko29301232018-12-11 15:29:32 +01005309 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005310}
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01005311#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01005312# define zbc_program_binOpPrep(...) (zbc_program_binOpPrep(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01005313#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005314
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005315static void bc_program_binOpRetire(BcResult *r)
Gavin Howard01055ba2018-11-03 11:00:21 -06005316{
5317 r->t = BC_RESULT_TEMP;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005318 bc_vec_pop(&G.prog.results);
5319 bc_vec_pop(&G.prog.results);
5320 bc_vec_push(&G.prog.results, r);
Gavin Howard01055ba2018-11-03 11:00:21 -06005321}
5322
Denys Vlasenko29301232018-12-11 15:29:32 +01005323static BC_STATUS zbc_program_prep(BcResult **r, BcNum **n)
Gavin Howard01055ba2018-11-03 11:00:21 -06005324{
5325 BcStatus s;
5326
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005327 if (!BC_PROG_STACK(&G.prog.results, 1))
Denys Vlasenko29301232018-12-11 15:29:32 +01005328 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005329 *r = bc_vec_top(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06005330
Denys Vlasenko29301232018-12-11 15:29:32 +01005331 s = zbc_program_num(*r, n, false);
5332 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005333
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005334 if (!BC_PROG_NUM((*r), (*n)))
Denys Vlasenko29301232018-12-11 15:29:32 +01005335 RETURN_STATUS(bc_error_variable_is_wrong_type());
Gavin Howard01055ba2018-11-03 11:00:21 -06005336
Denys Vlasenko29301232018-12-11 15:29:32 +01005337 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005338}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005339#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01005340# define zbc_program_prep(...) (zbc_program_prep(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005341#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005342
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005343static void bc_program_retire(BcResult *r, BcResultType t)
Gavin Howard01055ba2018-11-03 11:00:21 -06005344{
5345 r->t = t;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005346 bc_vec_pop(&G.prog.results);
5347 bc_vec_push(&G.prog.results, r);
Gavin Howard01055ba2018-11-03 11:00:21 -06005348}
5349
Denys Vlasenko259137d2018-12-11 19:42:05 +01005350static BC_STATUS zbc_program_op(char inst)
Gavin Howard01055ba2018-11-03 11:00:21 -06005351{
5352 BcStatus s;
5353 BcResult *opd1, *opd2, res;
5354 BcNum *n1, *n2 = NULL;
5355
Denys Vlasenko29301232018-12-11 15:29:32 +01005356 s = zbc_program_binOpPrep(&opd1, &n1, &opd2, &n2, false);
Denys Vlasenko259137d2018-12-11 19:42:05 +01005357 if (s) RETURN_STATUS(s);
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01005358 bc_num_init_DEF_SIZE(&res.d.n);
Gavin Howard01055ba2018-11-03 11:00:21 -06005359
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005360 s = BC_STATUS_SUCCESS;
Denys Vlasenko26819db2018-12-12 16:08:46 +01005361 ERROR_RETURN(s =) zbc_program_ops[inst - BC_INST_POWER](n1, n2, &res.d.n, G.prog.scale);
Gavin Howard01055ba2018-11-03 11:00:21 -06005362 if (s) goto err;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005363 bc_program_binOpRetire(&res);
Gavin Howard01055ba2018-11-03 11:00:21 -06005364
Denys Vlasenko259137d2018-12-11 19:42:05 +01005365 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005366
5367err:
5368 bc_num_free(&res.d.n);
Denys Vlasenko259137d2018-12-11 19:42:05 +01005369 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005370}
Denys Vlasenko259137d2018-12-11 19:42:05 +01005371#if ERRORS_ARE_FATAL
5372# define zbc_program_op(...) (zbc_program_op(__VA_ARGS__), BC_STATUS_SUCCESS)
5373#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005374
Denys Vlasenko26819db2018-12-12 16:08:46 +01005375static BC_STATUS zbc_program_read(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06005376{
Denys Vlasenko0409ad32018-12-05 16:39:22 +01005377 const char *sv_file;
Gavin Howard01055ba2018-11-03 11:00:21 -06005378 BcStatus s;
5379 BcParse parse;
5380 BcVec buf;
5381 BcInstPtr ip;
Denys Vlasenko69171dc2018-12-12 00:29:24 +01005382 BcFunc *f;
Gavin Howard01055ba2018-11-03 11:00:21 -06005383
Denys Vlasenko69171dc2018-12-12 00:29:24 +01005384 if (G.in_read)
Denys Vlasenko26819db2018-12-12 16:08:46 +01005385 RETURN_STATUS(bc_error_nested_read_call());
Gavin Howard01055ba2018-11-03 11:00:21 -06005386
Denys Vlasenko69171dc2018-12-12 00:29:24 +01005387 f = bc_program_func(BC_PROG_READ);
Denys Vlasenko7d628012018-12-04 21:46:47 +01005388 bc_vec_pop_all(&f->code);
Gavin Howard01055ba2018-11-03 11:00:21 -06005389
Denys Vlasenko0409ad32018-12-05 16:39:22 +01005390 sv_file = G.prog.file;
5391 G.prog.file = NULL;
Denys Vlasenko69171dc2018-12-12 00:29:24 +01005392 G.in_read = 1;
Denys Vlasenko0409ad32018-12-05 16:39:22 +01005393
Denys Vlasenko82ea67f2018-12-13 19:23:45 +01005394 bc_char_vec_init(&buf);
Denys Vlasenko8a892472018-12-12 22:43:58 +01005395 bc_read_line(&buf);
Gavin Howard01055ba2018-11-03 11:00:21 -06005396
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01005397 bc_parse_create(&parse, BC_PROG_READ);
Denys Vlasenko0409ad32018-12-05 16:39:22 +01005398 bc_lex_file(&parse.l);
Gavin Howard01055ba2018-11-03 11:00:21 -06005399
Denys Vlasenkof86e9602018-12-14 17:01:56 +01005400 s = zbc_parse_text_init(&parse, buf.v);
Gavin Howard01055ba2018-11-03 11:00:21 -06005401 if (s) goto exec_err;
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01005402 s = zcommon_parse_expr(&parse, BC_PARSE_NOREAD);
Gavin Howard01055ba2018-11-03 11:00:21 -06005403 if (s) goto exec_err;
5404
5405 if (parse.l.t.t != BC_LEX_NLINE && parse.l.t.t != BC_LEX_EOF) {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005406 s = bc_error("bad read() expression");
Gavin Howard01055ba2018-11-03 11:00:21 -06005407 goto exec_err;
5408 }
5409
5410 ip.func = BC_PROG_READ;
5411 ip.idx = 0;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005412 ip.len = G.prog.results.len;
Gavin Howard01055ba2018-11-03 11:00:21 -06005413
5414 // Update this pointer, just in case.
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01005415 f = bc_program_func(BC_PROG_READ);
Gavin Howard01055ba2018-11-03 11:00:21 -06005416
5417 bc_vec_pushByte(&f->code, BC_INST_POP_EXEC);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005418 bc_vec_push(&G.prog.stack, &ip);
Gavin Howard01055ba2018-11-03 11:00:21 -06005419
5420exec_err:
5421 bc_parse_free(&parse);
Denys Vlasenko4dd36522018-12-11 22:26:38 +01005422//io_err:
Denys Vlasenko69171dc2018-12-12 00:29:24 +01005423 G.in_read = 0;
Denys Vlasenko4dd36522018-12-11 22:26:38 +01005424 G.prog.file = sv_file;
Gavin Howard01055ba2018-11-03 11:00:21 -06005425 bc_vec_free(&buf);
Denys Vlasenko26819db2018-12-12 16:08:46 +01005426 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005427}
Denys Vlasenko26819db2018-12-12 16:08:46 +01005428#if ERRORS_ARE_FATAL
5429# define zbc_program_read(...) (zbc_program_read(__VA_ARGS__), BC_STATUS_SUCCESS)
5430#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005431
5432static size_t bc_program_index(char *code, size_t *bgn)
5433{
5434 char amt = code[(*bgn)++], i = 0;
5435 size_t res = 0;
5436
5437 for (; i < amt; ++i, ++(*bgn))
5438 res |= (((size_t)((int) code[*bgn]) & UCHAR_MAX) << (i * CHAR_BIT));
5439
5440 return res;
5441}
5442
5443static char *bc_program_name(char *code, size_t *bgn)
5444{
5445 size_t i;
5446 char c, *s, *str = code + *bgn, *ptr = strchr(str, BC_PARSE_STREND);
5447
5448 s = xmalloc(ptr - str + 1);
5449 c = code[(*bgn)++];
5450
5451 for (i = 0; c != 0 && c != BC_PARSE_STREND; c = code[(*bgn)++], ++i)
5452 s[i] = c;
5453
5454 s[i] = '\0';
5455
5456 return s;
5457}
5458
Denys Vlasenko5f1b90b2018-12-08 23:18:06 +01005459static void bc_program_printString(const char *str)
Gavin Howard01055ba2018-11-03 11:00:21 -06005460{
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005461#if ENABLE_DC
Denys Vlasenko9f657e02018-12-11 19:52:25 +01005462 if (!str[0]) {
Denys Vlasenko2c6f5632018-12-11 21:21:14 +01005463 // Example: echo '[]ap' | dc
5464 // should print two bytes: 0x00, 0x0A
Denys Vlasenko00d77792018-11-30 23:13:42 +01005465 bb_putchar('\0');
Gavin Howard01055ba2018-11-03 11:00:21 -06005466 return;
5467 }
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005468#endif
Denys Vlasenko9f657e02018-12-11 19:52:25 +01005469 while (*str) {
5470 int c = *str++;
5471 if (c != '\\' || !*str)
Denys Vlasenko00d77792018-11-30 23:13:42 +01005472 bb_putchar(c);
Gavin Howard01055ba2018-11-03 11:00:21 -06005473 else {
Denys Vlasenko9f657e02018-12-11 19:52:25 +01005474 c = *str++;
Gavin Howard01055ba2018-11-03 11:00:21 -06005475 switch (c) {
Denys Vlasenko9f657e02018-12-11 19:52:25 +01005476 case 'a':
5477 bb_putchar('\a');
5478 break;
5479 case 'b':
5480 bb_putchar('\b');
5481 break;
5482 case '\\':
5483 case 'e':
5484 bb_putchar('\\');
5485 break;
5486 case 'f':
5487 bb_putchar('\f');
5488 break;
5489 case 'n':
5490 bb_putchar('\n');
5491 G.prog.nchars = SIZE_MAX;
5492 break;
5493 case 'r':
5494 bb_putchar('\r');
5495 break;
5496 case 'q':
5497 bb_putchar('"');
5498 break;
5499 case 't':
5500 bb_putchar('\t');
5501 break;
5502 default:
5503 // Just print the backslash and following character.
5504 bb_putchar('\\');
5505 ++G.prog.nchars;
5506 bb_putchar(c);
5507 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005508 }
5509 }
Denys Vlasenko9f657e02018-12-11 19:52:25 +01005510 ++G.prog.nchars;
Gavin Howard01055ba2018-11-03 11:00:21 -06005511 }
5512}
5513
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005514static void bc_num_printNewline(void)
5515{
5516 if (G.prog.nchars == G.prog.len - 1) {
5517 bb_putchar('\\');
5518 bb_putchar('\n');
5519 G.prog.nchars = 0;
5520 }
5521}
5522
5523#if ENABLE_DC
5524static FAST_FUNC void bc_num_printChar(size_t num, size_t width, bool radix)
5525{
5526 (void) radix;
5527 bb_putchar((char) num);
5528 G.prog.nchars += width;
5529}
5530#endif
5531
5532static FAST_FUNC void bc_num_printDigits(size_t num, size_t width, bool radix)
5533{
5534 size_t exp, pow;
5535
5536 bc_num_printNewline();
5537 bb_putchar(radix ? '.' : ' ');
5538 ++G.prog.nchars;
5539
5540 bc_num_printNewline();
5541 for (exp = 0, pow = 1; exp < width - 1; ++exp, pow *= 10)
5542 continue;
5543
5544 for (exp = 0; exp < width; pow /= 10, ++G.prog.nchars, ++exp) {
5545 size_t dig;
5546 bc_num_printNewline();
5547 dig = num / pow;
5548 num -= dig * pow;
5549 bb_putchar(((char) dig) + '0');
5550 }
5551}
5552
5553static FAST_FUNC void bc_num_printHex(size_t num, size_t width, bool radix)
5554{
5555 if (radix) {
5556 bc_num_printNewline();
5557 bb_putchar('.');
5558 G.prog.nchars += 1;
5559 }
5560
5561 bc_num_printNewline();
5562 bb_putchar(bb_hexdigits_upcase[num]);
5563 G.prog.nchars += width;
5564}
5565
5566static void bc_num_printDecimal(BcNum *n)
5567{
5568 size_t i, rdx = n->rdx - 1;
5569
5570 if (n->neg) bb_putchar('-');
5571 G.prog.nchars += n->neg;
5572
5573 for (i = n->len - 1; i < n->len; --i)
5574 bc_num_printHex((size_t) n->num[i], 1, i == rdx);
5575}
5576
5577static BC_STATUS zbc_num_printNum(BcNum *n, BcNum *base, size_t width, BcNumDigitOp print)
5578{
5579 BcStatus s;
5580 BcVec stack;
5581 BcNum intp, fracp, digit, frac_len;
5582 unsigned long dig, *ptr;
5583 size_t i;
5584 bool radix;
5585
5586 if (n->len == 0) {
5587 print(0, width, false);
5588 RETURN_STATUS(BC_STATUS_SUCCESS);
5589 }
5590
5591 bc_vec_init(&stack, sizeof(long), NULL);
5592 bc_num_init(&intp, n->len);
5593 bc_num_init(&fracp, n->rdx);
5594 bc_num_init(&digit, width);
5595 bc_num_init(&frac_len, BC_NUM_INT(n));
5596 bc_num_copy(&intp, n);
5597 bc_num_one(&frac_len);
5598
5599 bc_num_truncate(&intp, intp.rdx);
5600 s = zbc_num_sub(n, &intp, &fracp, 0);
5601 if (s) goto err;
5602
5603 while (intp.len != 0) {
5604 s = zbc_num_divmod(&intp, base, &intp, &digit, 0);
5605 if (s) goto err;
5606 s = zbc_num_ulong(&digit, &dig);
5607 if (s) goto err;
5608 bc_vec_push(&stack, &dig);
5609 }
5610
5611 for (i = 0; i < stack.len; ++i) {
5612 ptr = bc_vec_item_rev(&stack, i);
5613 print(*ptr, width, false);
5614 }
5615
5616 if (!n->rdx) goto err;
5617
5618 for (radix = true; frac_len.len <= n->rdx; radix = false) {
5619 s = zbc_num_mul(&fracp, base, &fracp, n->rdx);
5620 if (s) goto err;
5621 s = zbc_num_ulong(&fracp, &dig);
5622 if (s) goto err;
5623 bc_num_ulong2num(&intp, dig);
5624 s = zbc_num_sub(&fracp, &intp, &fracp, 0);
5625 if (s) goto err;
5626 print(dig, width, radix);
5627 s = zbc_num_mul(&frac_len, base, &frac_len, 0);
5628 if (s) goto err;
5629 }
5630
5631err:
5632 bc_num_free(&frac_len);
5633 bc_num_free(&digit);
5634 bc_num_free(&fracp);
5635 bc_num_free(&intp);
5636 bc_vec_free(&stack);
5637 RETURN_STATUS(s);
5638}
5639#if ERRORS_ARE_FATAL
5640# define zbc_num_printNum(...) (zbc_num_printNum(__VA_ARGS__), BC_STATUS_SUCCESS)
5641#endif
5642
5643static BC_STATUS zbc_num_printBase(BcNum *n)
5644{
5645 BcStatus s;
5646 size_t width, i;
5647 BcNumDigitOp print;
5648 bool neg = n->neg;
5649
5650 if (neg) {
5651 bb_putchar('-');
5652 G.prog.nchars++;
5653 }
5654
5655 n->neg = false;
5656
5657 if (G.prog.ob_t <= BC_NUM_MAX_IBASE) {
5658 width = 1;
5659 print = bc_num_printHex;
5660 }
5661 else {
5662 for (i = G.prog.ob_t - 1, width = 0; i != 0; i /= 10, ++width)
5663 continue;
5664 print = bc_num_printDigits;
5665 }
5666
5667 s = zbc_num_printNum(n, &G.prog.ob, width, print);
5668 n->neg = neg;
5669
5670 RETURN_STATUS(s);
5671}
5672#if ERRORS_ARE_FATAL
5673# define zbc_num_printBase(...) (zbc_num_printBase(__VA_ARGS__), BC_STATUS_SUCCESS)
5674#endif
5675
5676#if ENABLE_DC
5677static BC_STATUS zbc_num_stream(BcNum *n, BcNum *base)
5678{
5679 RETURN_STATUS(zbc_num_printNum(n, base, 1, bc_num_printChar));
5680}
5681#if ERRORS_ARE_FATAL
5682# define zbc_num_stream(...) (zbc_num_stream(__VA_ARGS__), BC_STATUS_SUCCESS)
5683#endif
5684#endif
5685
5686static BC_STATUS zbc_num_print(BcNum *n, bool newline)
5687{
5688 BcStatus s = BC_STATUS_SUCCESS;
5689
5690 bc_num_printNewline();
5691
5692 if (n->len == 0) {
5693 bb_putchar('0');
5694 ++G.prog.nchars;
5695 }
5696 else if (G.prog.ob_t == 10)
5697 bc_num_printDecimal(n);
5698 else
5699 s = zbc_num_printBase(n);
5700
5701 if (newline) {
5702 bb_putchar('\n');
5703 G.prog.nchars = 0;
5704 }
5705
5706 RETURN_STATUS(s);
5707}
5708#if ERRORS_ARE_FATAL
5709# define zbc_num_print(...) (zbc_num_print(__VA_ARGS__), BC_STATUS_SUCCESS)
5710#endif
5711
Denys Vlasenko29301232018-12-11 15:29:32 +01005712static BC_STATUS zbc_program_print(char inst, size_t idx)
Gavin Howard01055ba2018-11-03 11:00:21 -06005713{
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005714 BcStatus s;
Gavin Howard01055ba2018-11-03 11:00:21 -06005715 BcResult *r;
Denys Vlasenko44d79d82018-12-10 12:33:40 +01005716 BcNum *num;
Gavin Howard01055ba2018-11-03 11:00:21 -06005717 bool pop = inst != BC_INST_PRINT;
5718
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005719 if (!BC_PROG_STACK(&G.prog.results, idx + 1))
Denys Vlasenko29301232018-12-11 15:29:32 +01005720 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Gavin Howard01055ba2018-11-03 11:00:21 -06005721
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005722 r = bc_vec_item_rev(&G.prog.results, idx);
Denys Vlasenko44d79d82018-12-10 12:33:40 +01005723 num = NULL; // is this NULL necessary?
Denys Vlasenko29301232018-12-11 15:29:32 +01005724 s = zbc_program_num(r, &num, false);
5725 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005726
5727 if (BC_PROG_NUM(r, num)) {
Denys Vlasenko29301232018-12-11 15:29:32 +01005728 s = zbc_num_print(num, !pop);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005729 if (!s) bc_num_copy(&G.prog.last, num);
Gavin Howard01055ba2018-11-03 11:00:21 -06005730 }
5731 else {
Denys Vlasenko44d79d82018-12-10 12:33:40 +01005732 char *str;
Gavin Howard01055ba2018-11-03 11:00:21 -06005733
5734 idx = (r->t == BC_RESULT_STR) ? r->d.id.idx : num->rdx;
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01005735 str = *bc_program_str(idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06005736
5737 if (inst == BC_INST_PRINT_STR) {
Denys Vlasenko44d79d82018-12-10 12:33:40 +01005738 for (;;) {
5739 char c = *str++;
5740 if (c == '\0') break;
Denys Vlasenko00d77792018-11-30 23:13:42 +01005741 bb_putchar(c);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005742 ++G.prog.nchars;
Denys Vlasenko44d79d82018-12-10 12:33:40 +01005743 if (c == '\n') G.prog.nchars = 0;
Gavin Howard01055ba2018-11-03 11:00:21 -06005744 }
5745 }
5746 else {
Denys Vlasenko5f1b90b2018-12-08 23:18:06 +01005747 bc_program_printString(str);
Denys Vlasenko00d77792018-11-30 23:13:42 +01005748 if (inst == BC_INST_PRINT) bb_putchar('\n');
Gavin Howard01055ba2018-11-03 11:00:21 -06005749 }
5750 }
5751
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005752 if (!s && pop) bc_vec_pop(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06005753
Denys Vlasenko29301232018-12-11 15:29:32 +01005754 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005755}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005756#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01005757# define zbc_program_print(...) (zbc_program_print(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005758#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005759
Denys Vlasenko29301232018-12-11 15:29:32 +01005760static BC_STATUS zbc_program_negate(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06005761{
5762 BcStatus s;
5763 BcResult res, *ptr;
5764 BcNum *num = NULL;
5765
Denys Vlasenko29301232018-12-11 15:29:32 +01005766 s = zbc_program_prep(&ptr, &num);
5767 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005768
5769 bc_num_init(&res.d.n, num->len);
5770 bc_num_copy(&res.d.n, num);
5771 if (res.d.n.len) res.d.n.neg = !res.d.n.neg;
5772
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005773 bc_program_retire(&res, BC_RESULT_TEMP);
Gavin Howard01055ba2018-11-03 11:00:21 -06005774
Denys Vlasenko29301232018-12-11 15:29:32 +01005775 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005776}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005777#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01005778# define zbc_program_negate(...) (zbc_program_negate(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01005779#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005780
Denys Vlasenko728e7c92018-12-11 19:37:00 +01005781static BC_STATUS zbc_program_logical(char inst)
Gavin Howard01055ba2018-11-03 11:00:21 -06005782{
5783 BcStatus s;
5784 BcResult *opd1, *opd2, res;
5785 BcNum *n1, *n2;
Denys Vlasenko16494f52018-12-12 00:50:23 +01005786 ssize_t cond;
Gavin Howard01055ba2018-11-03 11:00:21 -06005787
Denys Vlasenko29301232018-12-11 15:29:32 +01005788 s = zbc_program_binOpPrep(&opd1, &n1, &opd2, &n2, false);
Denys Vlasenko728e7c92018-12-11 19:37:00 +01005789 if (s) RETURN_STATUS(s);
Denys Vlasenko09d8df82018-12-11 19:29:35 +01005790
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01005791 bc_num_init_DEF_SIZE(&res.d.n);
Gavin Howard01055ba2018-11-03 11:00:21 -06005792
5793 if (inst == BC_INST_BOOL_AND)
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005794 cond = bc_num_cmp(n1, &G.prog.zero) && bc_num_cmp(n2, &G.prog.zero);
Gavin Howard01055ba2018-11-03 11:00:21 -06005795 else if (inst == BC_INST_BOOL_OR)
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005796 cond = bc_num_cmp(n1, &G.prog.zero) || bc_num_cmp(n2, &G.prog.zero);
Gavin Howard01055ba2018-11-03 11:00:21 -06005797 else {
Denys Vlasenko16494f52018-12-12 00:50:23 +01005798 cond = bc_num_cmp(n1, n2);
Gavin Howard01055ba2018-11-03 11:00:21 -06005799 switch (inst) {
Denys Vlasenko09d8df82018-12-11 19:29:35 +01005800 case BC_INST_REL_EQ:
Denys Vlasenko16494f52018-12-12 00:50:23 +01005801 cond = (cond == 0);
Denys Vlasenko09d8df82018-12-11 19:29:35 +01005802 break;
5803 case BC_INST_REL_LE:
Denys Vlasenko16494f52018-12-12 00:50:23 +01005804 cond = (cond <= 0);
Denys Vlasenko09d8df82018-12-11 19:29:35 +01005805 break;
5806 case BC_INST_REL_GE:
Denys Vlasenko16494f52018-12-12 00:50:23 +01005807 cond = (cond >= 0);
Denys Vlasenko09d8df82018-12-11 19:29:35 +01005808 break;
5809 case BC_INST_REL_LT:
Denys Vlasenko16494f52018-12-12 00:50:23 +01005810 cond = (cond < 0);
Denys Vlasenko09d8df82018-12-11 19:29:35 +01005811 break;
5812 case BC_INST_REL_GT:
Denys Vlasenko16494f52018-12-12 00:50:23 +01005813 cond = (cond > 0);
5814 break;
5815 default: // = case BC_INST_REL_NE:
5816 //cond = (cond != 0); - not needed
Denys Vlasenko09d8df82018-12-11 19:29:35 +01005817 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06005818 }
5819 }
5820
Denys Vlasenko09d8df82018-12-11 19:29:35 +01005821 if (cond) bc_num_one(&res.d.n);
5822 //else bc_num_zero(&res.d.n); - already is
Gavin Howard01055ba2018-11-03 11:00:21 -06005823
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005824 bc_program_binOpRetire(&res);
Gavin Howard01055ba2018-11-03 11:00:21 -06005825
Denys Vlasenko728e7c92018-12-11 19:37:00 +01005826 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005827}
Denys Vlasenko728e7c92018-12-11 19:37:00 +01005828#if ERRORS_ARE_FATAL
5829# define zbc_program_logical(...) (zbc_program_logical(__VA_ARGS__), BC_STATUS_SUCCESS)
5830#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005831
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005832#if ENABLE_DC
Denys Vlasenko29301232018-12-11 15:29:32 +01005833static BC_STATUS zbc_program_assignStr(BcResult *r, BcVec *v,
Gavin Howard01055ba2018-11-03 11:00:21 -06005834 bool push)
5835{
5836 BcNum n2;
5837 BcResult res;
5838
5839 memset(&n2, 0, sizeof(BcNum));
5840 n2.rdx = res.d.id.idx = r->d.id.idx;
5841 res.t = BC_RESULT_STR;
5842
5843 if (!push) {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005844 if (!BC_PROG_STACK(&G.prog.results, 2))
Denys Vlasenko29301232018-12-11 15:29:32 +01005845 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Gavin Howard01055ba2018-11-03 11:00:21 -06005846 bc_vec_pop(v);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005847 bc_vec_pop(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06005848 }
5849
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005850 bc_vec_pop(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06005851
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005852 bc_vec_push(&G.prog.results, &res);
Gavin Howard01055ba2018-11-03 11:00:21 -06005853 bc_vec_push(v, &n2);
5854
Denys Vlasenko29301232018-12-11 15:29:32 +01005855 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06005856}
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01005857#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01005858# define zbc_program_assignStr(...) (zbc_program_assignStr(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01005859#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005860#endif // ENABLE_DC
5861
Denys Vlasenko29301232018-12-11 15:29:32 +01005862static BC_STATUS zbc_program_copyToVar(char *name, bool var)
Gavin Howard01055ba2018-11-03 11:00:21 -06005863{
5864 BcStatus s;
5865 BcResult *ptr, r;
5866 BcVec *v;
5867 BcNum *n;
5868
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005869 if (!BC_PROG_STACK(&G.prog.results, 1))
Denys Vlasenko29301232018-12-11 15:29:32 +01005870 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Gavin Howard01055ba2018-11-03 11:00:21 -06005871
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005872 ptr = bc_vec_top(&G.prog.results);
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005873 if ((ptr->t == BC_RESULT_ARRAY) != !var)
Denys Vlasenko29301232018-12-11 15:29:32 +01005874 RETURN_STATUS(bc_error_variable_is_wrong_type());
Denys Vlasenkodf515392018-12-02 19:27:48 +01005875 v = bc_program_search(name, var);
Gavin Howard01055ba2018-11-03 11:00:21 -06005876
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005877#if ENABLE_DC
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005878 if (ptr->t == BC_RESULT_STR && !var)
Denys Vlasenko29301232018-12-11 15:29:32 +01005879 RETURN_STATUS(bc_error_variable_is_wrong_type());
5880 if (ptr->t == BC_RESULT_STR)
5881 RETURN_STATUS(zbc_program_assignStr(ptr, v, true));
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005882#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005883
Denys Vlasenko29301232018-12-11 15:29:32 +01005884 s = zbc_program_num(ptr, &n, false);
5885 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005886
5887 // Do this once more to make sure that pointers were not invalidated.
Denys Vlasenkodf515392018-12-02 19:27:48 +01005888 v = bc_program_search(name, var);
Gavin Howard01055ba2018-11-03 11:00:21 -06005889
5890 if (var) {
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01005891 bc_num_init_DEF_SIZE(&r.d.n);
Gavin Howard01055ba2018-11-03 11:00:21 -06005892 bc_num_copy(&r.d.n, n);
5893 }
5894 else {
5895 bc_array_init(&r.d.v, true);
5896 bc_array_copy(&r.d.v, (BcVec *) n);
5897 }
5898
5899 bc_vec_push(v, &r.d);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005900 bc_vec_pop(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06005901
Denys Vlasenko29301232018-12-11 15:29:32 +01005902 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005903}
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01005904#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01005905# define zbc_program_copyToVar(...) (zbc_program_copyToVar(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01005906#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005907
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005908static BC_STATUS zbc_program_assign(char inst)
Gavin Howard01055ba2018-11-03 11:00:21 -06005909{
5910 BcStatus s;
5911 BcResult *left, *right, res;
5912 BcNum *l = NULL, *r = NULL;
Gavin Howard01055ba2018-11-03 11:00:21 -06005913 bool assign = inst == BC_INST_ASSIGN, ib, sc;
5914
Denys Vlasenko29301232018-12-11 15:29:32 +01005915 s = zbc_program_binOpPrep(&left, &l, &right, &r, assign);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005916 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005917
5918 ib = left->t == BC_RESULT_IBASE;
5919 sc = left->t == BC_RESULT_SCALE;
5920
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005921#if ENABLE_DC
Gavin Howard01055ba2018-11-03 11:00:21 -06005922
5923 if (right->t == BC_RESULT_STR) {
5924
5925 BcVec *v;
5926
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005927 if (left->t != BC_RESULT_VAR)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005928 RETURN_STATUS(bc_error_variable_is_wrong_type());
Denys Vlasenkodf515392018-12-02 19:27:48 +01005929 v = bc_program_search(left->d.id.name, true);
Gavin Howard01055ba2018-11-03 11:00:21 -06005930
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005931 RETURN_STATUS(zbc_program_assignStr(right, v, false));
Gavin Howard01055ba2018-11-03 11:00:21 -06005932 }
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005933#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005934
5935 if (left->t == BC_RESULT_CONSTANT || left->t == BC_RESULT_TEMP)
Denys Vlasenko259137d2018-12-11 19:42:05 +01005936 RETURN_STATUS(bc_error("bad assignment:"
Denys Vlasenko0154d782018-12-14 23:32:51 +01005937 " left side must be variable"
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005938 " or array element"
Denys Vlasenko0154d782018-12-14 23:32:51 +01005939 )); // note: shared string
Gavin Howard01055ba2018-11-03 11:00:21 -06005940
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005941#if ENABLE_BC
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005942 if (inst == BC_INST_ASSIGN_DIVIDE && !bc_num_cmp(r, &G.prog.zero))
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005943 RETURN_STATUS(bc_error("divide by zero"));
Gavin Howard01055ba2018-11-03 11:00:21 -06005944
5945 if (assign)
5946 bc_num_copy(l, r);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005947 else {
5948 s = BC_STATUS_SUCCESS;
Denys Vlasenko26819db2018-12-12 16:08:46 +01005949 ERROR_RETURN(s =) zbc_program_ops[inst - BC_INST_ASSIGN_POWER](l, r, l, G.prog.scale);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005950 }
5951 if (s) RETURN_STATUS(s);
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005952#else
Gavin Howard01055ba2018-11-03 11:00:21 -06005953 bc_num_copy(l, r);
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01005954#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06005955
5956 if (ib || sc || left->t == BC_RESULT_OBASE) {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005957 static const char *const msg[] = {
Denys Vlasenko64074a12018-12-07 15:50:14 +01005958 "bad ibase; must be [2,16]", //BC_RESULT_IBASE
5959 "bad scale; must be [0,"BC_MAX_SCALE_STR"]", //BC_RESULT_SCALE
5960 NULL, //can't happen //BC_RESULT_LAST
5961 NULL, //can't happen //BC_RESULT_CONSTANT
5962 NULL, //can't happen //BC_RESULT_ONE
5963 "bad obase; must be [2,"BC_MAX_OBASE_STR"]", //BC_RESULT_OBASE
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005964 };
Gavin Howard01055ba2018-11-03 11:00:21 -06005965 size_t *ptr;
Denys Vlasenkoffdcebd2018-12-07 15:10:05 +01005966 unsigned long val, max;
Gavin Howard01055ba2018-11-03 11:00:21 -06005967
Denys Vlasenko29301232018-12-11 15:29:32 +01005968 s = zbc_num_ulong(l, &val);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005969 if (s) RETURN_STATUS(s);
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005970 s = left->t - BC_RESULT_IBASE;
Gavin Howard01055ba2018-11-03 11:00:21 -06005971 if (sc) {
5972 max = BC_MAX_SCALE;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005973 ptr = &G.prog.scale;
Gavin Howard01055ba2018-11-03 11:00:21 -06005974 }
5975 else {
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005976 if (val < BC_NUM_MIN_BASE)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005977 RETURN_STATUS(bc_error(msg[s]));
Gavin Howard01055ba2018-11-03 11:00:21 -06005978 max = ib ? BC_NUM_MAX_IBASE : BC_MAX_OBASE;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005979 ptr = ib ? &G.prog.ib_t : &G.prog.ob_t;
Gavin Howard01055ba2018-11-03 11:00:21 -06005980 }
5981
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005982 if (val > max)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005983 RETURN_STATUS(bc_error(msg[s]));
Denys Vlasenko60cf7472018-12-04 20:05:28 +01005984 if (!sc)
5985 bc_num_copy(ib ? &G.prog.ib : &G.prog.ob, l);
Gavin Howard01055ba2018-11-03 11:00:21 -06005986
5987 *ptr = (size_t) val;
5988 s = BC_STATUS_SUCCESS;
5989 }
5990
5991 bc_num_init(&res.d.n, l->len);
5992 bc_num_copy(&res.d.n, l);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01005993 bc_program_binOpRetire(&res);
Gavin Howard01055ba2018-11-03 11:00:21 -06005994
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005995 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06005996}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01005997#if ERRORS_ARE_FATAL
5998# define zbc_program_assign(...) (zbc_program_assign(__VA_ARGS__), BC_STATUS_SUCCESS)
5999#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006000
Denys Vlasenko416ce762018-12-02 20:57:17 +01006001#if !ENABLE_DC
6002#define bc_program_pushVar(code, bgn, pop, copy) \
6003 bc_program_pushVar(code, bgn)
6004// for bc, 'pop' and 'copy' are always false
6005#endif
Denys Vlasenkob402ff82018-12-11 15:45:15 +01006006static BC_STATUS bc_program_pushVar(char *code, size_t *bgn,
Gavin Howard01055ba2018-11-03 11:00:21 -06006007 bool pop, bool copy)
6008{
Gavin Howard01055ba2018-11-03 11:00:21 -06006009 BcResult r;
6010 char *name = bc_program_name(code, bgn);
Gavin Howard01055ba2018-11-03 11:00:21 -06006011
6012 r.t = BC_RESULT_VAR;
6013 r.d.id.name = name;
6014
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006015#if ENABLE_DC
Denys Vlasenko416ce762018-12-02 20:57:17 +01006016 {
6017 BcVec *v = bc_program_search(name, true);
6018 BcNum *num = bc_vec_top(v);
Gavin Howard01055ba2018-11-03 11:00:21 -06006019
Denys Vlasenko416ce762018-12-02 20:57:17 +01006020 if (pop || copy) {
Gavin Howard01055ba2018-11-03 11:00:21 -06006021
Denys Vlasenko416ce762018-12-02 20:57:17 +01006022 if (!BC_PROG_STACK(v, 2 - copy)) {
6023 free(name);
Denys Vlasenkob402ff82018-12-11 15:45:15 +01006024 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Denys Vlasenko416ce762018-12-02 20:57:17 +01006025 }
6026
Gavin Howard01055ba2018-11-03 11:00:21 -06006027 free(name);
Denys Vlasenko416ce762018-12-02 20:57:17 +01006028 name = NULL;
6029
6030 if (!BC_PROG_STR(num)) {
6031
6032 r.t = BC_RESULT_TEMP;
6033
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01006034 bc_num_init_DEF_SIZE(&r.d.n);
Denys Vlasenko416ce762018-12-02 20:57:17 +01006035 bc_num_copy(&r.d.n, num);
6036 }
6037 else {
6038 r.t = BC_RESULT_STR;
6039 r.d.id.idx = num->rdx;
6040 }
6041
6042 if (!copy) bc_vec_pop(v);
Gavin Howard01055ba2018-11-03 11:00:21 -06006043 }
Gavin Howard01055ba2018-11-03 11:00:21 -06006044 }
6045#endif // ENABLE_DC
6046
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006047 bc_vec_push(&G.prog.results, &r);
Gavin Howard01055ba2018-11-03 11:00:21 -06006048
Denys Vlasenkob402ff82018-12-11 15:45:15 +01006049 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06006050}
Denys Vlasenkob402ff82018-12-11 15:45:15 +01006051#if ERRORS_ARE_FATAL
6052# define zbc_program_pushVar(...) (bc_program_pushVar(__VA_ARGS__), BC_STATUS_SUCCESS)
6053#else
6054# define zbc_program_pushVar(...) bc_program_pushVar(__VA_ARGS__)
6055#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006056
Denys Vlasenko29301232018-12-11 15:29:32 +01006057static BC_STATUS zbc_program_pushArray(char *code, size_t *bgn,
Gavin Howard01055ba2018-11-03 11:00:21 -06006058 char inst)
6059{
6060 BcStatus s = BC_STATUS_SUCCESS;
6061 BcResult r;
6062 BcNum *num;
6063
6064 r.d.id.name = bc_program_name(code, bgn);
6065
6066 if (inst == BC_INST_ARRAY) {
6067 r.t = BC_RESULT_ARRAY;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006068 bc_vec_push(&G.prog.results, &r);
Gavin Howard01055ba2018-11-03 11:00:21 -06006069 }
6070 else {
6071
6072 BcResult *operand;
6073 unsigned long temp;
6074
Denys Vlasenko29301232018-12-11 15:29:32 +01006075 s = zbc_program_prep(&operand, &num);
Gavin Howard01055ba2018-11-03 11:00:21 -06006076 if (s) goto err;
Denys Vlasenko29301232018-12-11 15:29:32 +01006077 s = zbc_num_ulong(num, &temp);
Gavin Howard01055ba2018-11-03 11:00:21 -06006078 if (s) goto err;
6079
6080 if (temp > BC_MAX_DIM) {
Denys Vlasenko64074a12018-12-07 15:50:14 +01006081 s = bc_error("array too long; must be [1,"BC_MAX_DIM_STR"]");
Gavin Howard01055ba2018-11-03 11:00:21 -06006082 goto err;
6083 }
6084
6085 r.d.id.idx = (size_t) temp;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006086 bc_program_retire(&r, BC_RESULT_ARRAY_ELEM);
Gavin Howard01055ba2018-11-03 11:00:21 -06006087 }
6088
6089err:
6090 if (s) free(r.d.id.name);
Denys Vlasenko29301232018-12-11 15:29:32 +01006091 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006092}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01006093#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01006094# define zbc_program_pushArray(...) (zbc_program_pushArray(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01006095#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006096
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006097#if ENABLE_BC
Denys Vlasenko29301232018-12-11 15:29:32 +01006098static BC_STATUS zbc_program_incdec(char inst)
Gavin Howard01055ba2018-11-03 11:00:21 -06006099{
6100 BcStatus s;
6101 BcResult *ptr, res, copy;
6102 BcNum *num = NULL;
6103 char inst2 = inst;
6104
Denys Vlasenko29301232018-12-11 15:29:32 +01006105 s = zbc_program_prep(&ptr, &num);
6106 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006107
6108 if (inst == BC_INST_INC_POST || inst == BC_INST_DEC_POST) {
6109 copy.t = BC_RESULT_TEMP;
6110 bc_num_init(&copy.d.n, num->len);
6111 bc_num_copy(&copy.d.n, num);
6112 }
6113
6114 res.t = BC_RESULT_ONE;
6115 inst = inst == BC_INST_INC_PRE || inst == BC_INST_INC_POST ?
6116 BC_INST_ASSIGN_PLUS :
6117 BC_INST_ASSIGN_MINUS;
6118
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006119 bc_vec_push(&G.prog.results, &res);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006120 s = zbc_program_assign(inst);
6121 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006122
6123 if (inst2 == BC_INST_INC_POST || inst2 == BC_INST_DEC_POST) {
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006124 bc_vec_pop(&G.prog.results);
6125 bc_vec_push(&G.prog.results, &copy);
Gavin Howard01055ba2018-11-03 11:00:21 -06006126 }
6127
Denys Vlasenko29301232018-12-11 15:29:32 +01006128 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006129}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01006130#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01006131# define zbc_program_incdec(...) (zbc_program_incdec(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01006132#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006133
Denys Vlasenko29301232018-12-11 15:29:32 +01006134static BC_STATUS zbc_program_call(char *code, size_t *idx)
Gavin Howard01055ba2018-11-03 11:00:21 -06006135{
Gavin Howard01055ba2018-11-03 11:00:21 -06006136 BcInstPtr ip;
6137 size_t i, nparams = bc_program_index(code, idx);
6138 BcFunc *func;
Gavin Howard01055ba2018-11-03 11:00:21 -06006139 BcId *a;
6140 BcResultData param;
6141 BcResult *arg;
6142
6143 ip.idx = 0;
6144 ip.func = bc_program_index(code, idx);
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006145 func = bc_program_func(ip.func);
Gavin Howard01055ba2018-11-03 11:00:21 -06006146
Denys Vlasenko04a1c762018-12-03 21:10:57 +01006147 if (func->code.len == 0) {
Denys Vlasenko29301232018-12-11 15:29:32 +01006148 RETURN_STATUS(bc_error("undefined function"));
Denys Vlasenko04a1c762018-12-03 21:10:57 +01006149 }
6150 if (nparams != func->nparams) {
Denys Vlasenko29301232018-12-11 15:29:32 +01006151 RETURN_STATUS(bc_error_fmt("function has %u parameters, but called with %u", func->nparams, nparams));
Denys Vlasenko04a1c762018-12-03 21:10:57 +01006152 }
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006153 ip.len = G.prog.results.len - nparams;
Gavin Howard01055ba2018-11-03 11:00:21 -06006154
6155 for (i = 0; i < nparams; ++i) {
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01006156 BcStatus s;
Gavin Howard01055ba2018-11-03 11:00:21 -06006157
6158 a = bc_vec_item(&func->autos, nparams - 1 - i);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006159 arg = bc_vec_top(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006160
6161 if ((!a->idx) != (arg->t == BC_RESULT_ARRAY) || arg->t == BC_RESULT_STR)
Denys Vlasenko29301232018-12-11 15:29:32 +01006162 RETURN_STATUS(bc_error_variable_is_wrong_type());
Gavin Howard01055ba2018-11-03 11:00:21 -06006163
Denys Vlasenko29301232018-12-11 15:29:32 +01006164 s = zbc_program_copyToVar(a->name, a->idx);
6165 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006166 }
6167
6168 for (; i < func->autos.len; ++i) {
Denys Vlasenkodf515392018-12-02 19:27:48 +01006169 BcVec *v;
Gavin Howard01055ba2018-11-03 11:00:21 -06006170
6171 a = bc_vec_item(&func->autos, i);
Denys Vlasenkodf515392018-12-02 19:27:48 +01006172 v = bc_program_search(a->name, a->idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06006173
6174 if (a->idx) {
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01006175 bc_num_init_DEF_SIZE(&param.n);
Gavin Howard01055ba2018-11-03 11:00:21 -06006176 bc_vec_push(v, &param.n);
6177 }
6178 else {
6179 bc_array_init(&param.v, true);
6180 bc_vec_push(v, &param.v);
6181 }
6182 }
6183
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006184 bc_vec_push(&G.prog.stack, &ip);
Gavin Howard01055ba2018-11-03 11:00:21 -06006185
Denys Vlasenko29301232018-12-11 15:29:32 +01006186 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06006187}
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01006188#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01006189# define zbc_program_call(...) (zbc_program_call(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01006190#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006191
Denys Vlasenko29301232018-12-11 15:29:32 +01006192static BC_STATUS zbc_program_return(char inst)
Gavin Howard01055ba2018-11-03 11:00:21 -06006193{
Gavin Howard01055ba2018-11-03 11:00:21 -06006194 BcResult res;
6195 BcFunc *f;
6196 size_t i;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006197 BcInstPtr *ip = bc_vec_top(&G.prog.stack);
Gavin Howard01055ba2018-11-03 11:00:21 -06006198
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006199 if (!BC_PROG_STACK(&G.prog.results, ip->len + inst == BC_INST_RET))
Denys Vlasenko29301232018-12-11 15:29:32 +01006200 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Gavin Howard01055ba2018-11-03 11:00:21 -06006201
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006202 f = bc_program_func(ip->func);
Gavin Howard01055ba2018-11-03 11:00:21 -06006203 res.t = BC_RESULT_TEMP;
6204
6205 if (inst == BC_INST_RET) {
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01006206 BcStatus s;
Gavin Howard01055ba2018-11-03 11:00:21 -06006207 BcNum *num;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006208 BcResult *operand = bc_vec_top(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006209
Denys Vlasenko29301232018-12-11 15:29:32 +01006210 s = zbc_program_num(operand, &num, false);
6211 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006212 bc_num_init(&res.d.n, num->len);
6213 bc_num_copy(&res.d.n, num);
6214 }
6215 else {
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01006216 bc_num_init_DEF_SIZE(&res.d.n);
Denys Vlasenko3129f702018-12-09 12:04:44 +01006217 //bc_num_zero(&res.d.n); - already is
Gavin Howard01055ba2018-11-03 11:00:21 -06006218 }
6219
6220 // We need to pop arguments as well, so this takes that into account.
6221 for (i = 0; i < f->autos.len; ++i) {
Gavin Howard01055ba2018-11-03 11:00:21 -06006222 BcVec *v;
6223 BcId *a = bc_vec_item(&f->autos, i);
6224
Denys Vlasenkodf515392018-12-02 19:27:48 +01006225 v = bc_program_search(a->name, a->idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06006226 bc_vec_pop(v);
6227 }
6228
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006229 bc_vec_npop(&G.prog.results, G.prog.results.len - ip->len);
6230 bc_vec_push(&G.prog.results, &res);
6231 bc_vec_pop(&G.prog.stack);
Gavin Howard01055ba2018-11-03 11:00:21 -06006232
Denys Vlasenko29301232018-12-11 15:29:32 +01006233 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06006234}
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01006235#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01006236# define zbc_program_return(...) (zbc_program_return(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01006237#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006238#endif // ENABLE_BC
6239
6240static unsigned long bc_program_scale(BcNum *n)
6241{
6242 return (unsigned long) n->rdx;
6243}
6244
6245static unsigned long bc_program_len(BcNum *n)
6246{
Denys Vlasenkoa7f1a362018-12-10 12:57:01 +01006247 size_t len = n->len;
Gavin Howard01055ba2018-11-03 11:00:21 -06006248
Denys Vlasenkoa7f1a362018-12-10 12:57:01 +01006249 if (n->rdx != len) return len;
6250 for (;;) {
6251 if (len == 0) break;
6252 len--;
6253 if (n->num[len] != 0) break;
6254 }
Gavin Howard01055ba2018-11-03 11:00:21 -06006255 return len;
6256}
6257
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006258static BC_STATUS zbc_program_builtin(char inst)
Gavin Howard01055ba2018-11-03 11:00:21 -06006259{
6260 BcStatus s;
6261 BcResult *opnd;
6262 BcNum *num = NULL;
6263 BcResult res;
6264 bool len = inst == BC_INST_LENGTH;
6265
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006266 if (!BC_PROG_STACK(&G.prog.results, 1))
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006267 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006268 opnd = bc_vec_top(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006269
Denys Vlasenko29301232018-12-11 15:29:32 +01006270 s = zbc_program_num(opnd, &num, false);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006271 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006272
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006273#if ENABLE_DC
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006274 if (!BC_PROG_NUM(opnd, num) && !len)
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006275 RETURN_STATUS(bc_error_variable_is_wrong_type());
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006276#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006277
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01006278 bc_num_init_DEF_SIZE(&res.d.n);
Gavin Howard01055ba2018-11-03 11:00:21 -06006279
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01006280 if (inst == BC_INST_SQRT) s = zbc_num_sqrt(num, &res.d.n, G.prog.scale);
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006281#if ENABLE_BC
Gavin Howard01055ba2018-11-03 11:00:21 -06006282 else if (len != 0 && opnd->t == BC_RESULT_ARRAY) {
Denys Vlasenkoe3b4f232018-12-02 18:44:40 +01006283 bc_num_ulong2num(&res.d.n, (unsigned long) ((BcVec *) num)->len);
Gavin Howard01055ba2018-11-03 11:00:21 -06006284 }
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006285#endif
6286#if ENABLE_DC
Gavin Howard01055ba2018-11-03 11:00:21 -06006287 else if (len != 0 && !BC_PROG_NUM(opnd, num)) {
Gavin Howard01055ba2018-11-03 11:00:21 -06006288 char **str;
6289 size_t idx = opnd->t == BC_RESULT_STR ? opnd->d.id.idx : num->rdx;
6290
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006291 str = bc_program_str(idx);
Denys Vlasenkoe3b4f232018-12-02 18:44:40 +01006292 bc_num_ulong2num(&res.d.n, strlen(*str));
Gavin Howard01055ba2018-11-03 11:00:21 -06006293 }
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006294#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006295 else {
Denys Vlasenko5ba55f12018-12-10 15:37:14 +01006296 bc_num_ulong2num(&res.d.n, len ? bc_program_len(num) : bc_program_scale(num));
Gavin Howard01055ba2018-11-03 11:00:21 -06006297 }
6298
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006299 bc_program_retire(&res, BC_RESULT_TEMP);
Gavin Howard01055ba2018-11-03 11:00:21 -06006300
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006301 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006302}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006303#if ERRORS_ARE_FATAL
6304# define zbc_program_builtin(...) (zbc_program_builtin(__VA_ARGS__), BC_STATUS_SUCCESS)
6305#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006306
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006307#if ENABLE_DC
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006308static BC_STATUS zbc_program_divmod(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06006309{
6310 BcStatus s;
6311 BcResult *opd1, *opd2, res, res2;
6312 BcNum *n1, *n2 = NULL;
6313
Denys Vlasenko29301232018-12-11 15:29:32 +01006314 s = zbc_program_binOpPrep(&opd1, &n1, &opd2, &n2, false);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006315 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006316
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01006317 bc_num_init_DEF_SIZE(&res.d.n);
Gavin Howard01055ba2018-11-03 11:00:21 -06006318 bc_num_init(&res2.d.n, n2->len);
6319
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01006320 s = zbc_num_divmod(n1, n2, &res2.d.n, &res.d.n, G.prog.scale);
Gavin Howard01055ba2018-11-03 11:00:21 -06006321 if (s) goto err;
6322
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006323 bc_program_binOpRetire(&res2);
Gavin Howard01055ba2018-11-03 11:00:21 -06006324 res.t = BC_RESULT_TEMP;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006325 bc_vec_push(&G.prog.results, &res);
Gavin Howard01055ba2018-11-03 11:00:21 -06006326
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006327 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006328
6329err:
6330 bc_num_free(&res2.d.n);
6331 bc_num_free(&res.d.n);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006332 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006333}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006334#if ERRORS_ARE_FATAL
6335# define zbc_program_divmod(...) (zbc_program_divmod(__VA_ARGS__), BC_STATUS_SUCCESS)
6336#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006337
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006338static BC_STATUS zbc_program_modexp(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06006339{
6340 BcStatus s;
6341 BcResult *r1, *r2, *r3, res;
6342 BcNum *n1, *n2, *n3;
6343
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006344 if (!BC_PROG_STACK(&G.prog.results, 3))
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006345 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Denys Vlasenko29301232018-12-11 15:29:32 +01006346 s = zbc_program_binOpPrep(&r2, &n2, &r3, &n3, false);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006347 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006348
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006349 r1 = bc_vec_item_rev(&G.prog.results, 2);
Denys Vlasenko29301232018-12-11 15:29:32 +01006350 s = zbc_program_num(r1, &n1, false);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006351 if (s) RETURN_STATUS(s);
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006352 if (!BC_PROG_NUM(r1, n1))
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006353 RETURN_STATUS(bc_error_variable_is_wrong_type());
Gavin Howard01055ba2018-11-03 11:00:21 -06006354
6355 // Make sure that the values have their pointers updated, if necessary.
6356 if (r1->t == BC_RESULT_VAR || r1->t == BC_RESULT_ARRAY_ELEM) {
6357
6358 if (r1->t == r2->t) {
Denys Vlasenko29301232018-12-11 15:29:32 +01006359 s = zbc_program_num(r2, &n2, false);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006360 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006361 }
6362
6363 if (r1->t == r3->t) {
Denys Vlasenko29301232018-12-11 15:29:32 +01006364 s = zbc_program_num(r3, &n3, false);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006365 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006366 }
6367 }
6368
6369 bc_num_init(&res.d.n, n3->len);
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01006370 s = zbc_num_modexp(n1, n2, n3, &res.d.n);
Gavin Howard01055ba2018-11-03 11:00:21 -06006371 if (s) goto err;
6372
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006373 bc_vec_pop(&G.prog.results);
6374 bc_program_binOpRetire(&res);
Gavin Howard01055ba2018-11-03 11:00:21 -06006375
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006376 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006377
6378err:
6379 bc_num_free(&res.d.n);
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006380 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006381}
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006382#if ERRORS_ARE_FATAL
6383# define zbc_program_modexp(...) (zbc_program_modexp(__VA_ARGS__), BC_STATUS_SUCCESS)
6384#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006385
Denys Vlasenkoe3b4f232018-12-02 18:44:40 +01006386static void bc_program_stackLen(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06006387{
Gavin Howard01055ba2018-11-03 11:00:21 -06006388 BcResult res;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006389 size_t len = G.prog.results.len;
Gavin Howard01055ba2018-11-03 11:00:21 -06006390
6391 res.t = BC_RESULT_TEMP;
6392
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01006393 bc_num_init_DEF_SIZE(&res.d.n);
Denys Vlasenkoe3b4f232018-12-02 18:44:40 +01006394 bc_num_ulong2num(&res.d.n, len);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006395 bc_vec_push(&G.prog.results, &res);
Gavin Howard01055ba2018-11-03 11:00:21 -06006396}
6397
Denys Vlasenkoc008a732018-12-11 20:57:53 +01006398static BC_STATUS zbc_program_asciify(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06006399{
6400 BcStatus s;
6401 BcResult *r, res;
Denys Vlasenko4a024c72018-12-09 13:21:54 +01006402 BcNum *num, n;
Gavin Howard01055ba2018-11-03 11:00:21 -06006403 char *str, *str2, c;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006404 size_t len = G.prog.strs.len, idx;
Gavin Howard01055ba2018-11-03 11:00:21 -06006405 unsigned long val;
6406
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006407 if (!BC_PROG_STACK(&G.prog.results, 1))
Denys Vlasenkoc008a732018-12-11 20:57:53 +01006408 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006409 r = bc_vec_top(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006410
Denys Vlasenko4a024c72018-12-09 13:21:54 +01006411 num = NULL; // TODO: is this NULL needed?
Denys Vlasenko29301232018-12-11 15:29:32 +01006412 s = zbc_program_num(r, &num, false);
Denys Vlasenkoc008a732018-12-11 20:57:53 +01006413 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006414
6415 if (BC_PROG_NUM(r, num)) {
6416
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01006417 bc_num_init_DEF_SIZE(&n);
Gavin Howard01055ba2018-11-03 11:00:21 -06006418 bc_num_copy(&n, num);
6419 bc_num_truncate(&n, n.rdx);
6420
Denys Vlasenko1aeacef2018-12-11 19:12:13 +01006421 s = zbc_num_mod(&n, &G.prog.strmb, &n, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06006422 if (s) goto num_err;
Denys Vlasenko29301232018-12-11 15:29:32 +01006423 s = zbc_num_ulong(&n, &val);
Gavin Howard01055ba2018-11-03 11:00:21 -06006424 if (s) goto num_err;
6425
6426 c = (char) val;
6427
6428 bc_num_free(&n);
6429 }
6430 else {
6431 idx = (r->t == BC_RESULT_STR) ? r->d.id.idx : num->rdx;
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006432 str2 = *bc_program_str(idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06006433 c = str2[0];
6434 }
6435
Denys Vlasenkofa35e592018-12-10 20:17:24 +01006436 str = xzalloc(2);
Gavin Howard01055ba2018-11-03 11:00:21 -06006437 str[0] = c;
Denys Vlasenkofa35e592018-12-10 20:17:24 +01006438 //str[1] = '\0'; - already is
Gavin Howard01055ba2018-11-03 11:00:21 -06006439
6440 str2 = xstrdup(str);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006441 bc_program_addFunc(str2, &idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06006442
6443 if (idx != len + BC_PROG_REQ_FUNCS) {
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006444 for (idx = 0; idx < G.prog.strs.len; ++idx) {
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006445 if (strcmp(*bc_program_str(idx), str) == 0) {
Gavin Howard01055ba2018-11-03 11:00:21 -06006446 len = idx;
6447 break;
6448 }
6449 }
6450
6451 free(str);
6452 }
6453 else
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006454 bc_vec_push(&G.prog.strs, &str);
Gavin Howard01055ba2018-11-03 11:00:21 -06006455
6456 res.t = BC_RESULT_STR;
6457 res.d.id.idx = len;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006458 bc_vec_pop(&G.prog.results);
6459 bc_vec_push(&G.prog.results, &res);
Gavin Howard01055ba2018-11-03 11:00:21 -06006460
Denys Vlasenkoc008a732018-12-11 20:57:53 +01006461 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06006462
6463num_err:
6464 bc_num_free(&n);
Denys Vlasenkoc008a732018-12-11 20:57:53 +01006465 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006466}
Denys Vlasenkoc008a732018-12-11 20:57:53 +01006467#if ERRORS_ARE_FATAL
6468# define zbc_program_asciify(...) (zbc_program_asciify(__VA_ARGS__), BC_STATUS_SUCCESS)
6469#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006470
Denys Vlasenko29301232018-12-11 15:29:32 +01006471static BC_STATUS zbc_program_printStream(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06006472{
6473 BcStatus s;
6474 BcResult *r;
6475 BcNum *n = NULL;
6476 size_t idx;
6477 char *str;
6478
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006479 if (!BC_PROG_STACK(&G.prog.results, 1))
Denys Vlasenko29301232018-12-11 15:29:32 +01006480 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006481 r = bc_vec_top(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006482
Denys Vlasenko29301232018-12-11 15:29:32 +01006483 s = zbc_program_num(r, &n, false);
6484 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006485
6486 if (BC_PROG_NUM(r, n))
Denys Vlasenko29301232018-12-11 15:29:32 +01006487 s = zbc_num_stream(n, &G.prog.strmb);
Gavin Howard01055ba2018-11-03 11:00:21 -06006488 else {
6489 idx = (r->t == BC_RESULT_STR) ? r->d.id.idx : n->rdx;
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006490 str = *bc_program_str(idx);
Denys Vlasenko00d77792018-11-30 23:13:42 +01006491 printf("%s", str);
Gavin Howard01055ba2018-11-03 11:00:21 -06006492 }
6493
Denys Vlasenko29301232018-12-11 15:29:32 +01006494 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006495}
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01006496#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01006497# define zbc_program_printStream(...) (zbc_program_printStream(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenko628bf1b2018-12-10 20:41:05 +01006498#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006499
Denys Vlasenko29301232018-12-11 15:29:32 +01006500static BC_STATUS zbc_program_nquit(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06006501{
6502 BcStatus s;
6503 BcResult *opnd;
6504 BcNum *num = NULL;
6505 unsigned long val;
6506
Denys Vlasenko29301232018-12-11 15:29:32 +01006507 s = zbc_program_prep(&opnd, &num);
6508 if (s) RETURN_STATUS(s);
6509 s = zbc_num_ulong(num, &val);
6510 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006511
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006512 bc_vec_pop(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006513
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006514 if (G.prog.stack.len < val)
Denys Vlasenko29301232018-12-11 15:29:32 +01006515 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Denys Vlasenkoe873ff92018-12-06 00:29:22 +01006516 if (G.prog.stack.len == val) {
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +01006517 QUIT_OR_RETURN_TO_MAIN;
Denys Vlasenkoe873ff92018-12-06 00:29:22 +01006518 }
Gavin Howard01055ba2018-11-03 11:00:21 -06006519
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006520 bc_vec_npop(&G.prog.stack, val);
Gavin Howard01055ba2018-11-03 11:00:21 -06006521
Denys Vlasenko29301232018-12-11 15:29:32 +01006522 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006523}
Denys Vlasenkofa35e592018-12-10 20:17:24 +01006524#if ERRORS_ARE_FATAL
Denys Vlasenko29301232018-12-11 15:29:32 +01006525# define zbc_program_nquit(...) (zbc_program_nquit(__VA_ARGS__), BC_STATUS_SUCCESS)
Denys Vlasenkofa35e592018-12-10 20:17:24 +01006526#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006527
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006528static BC_STATUS zbc_program_execStr(char *code, size_t *bgn,
Gavin Howard01055ba2018-11-03 11:00:21 -06006529 bool cond)
6530{
6531 BcStatus s = BC_STATUS_SUCCESS;
6532 BcResult *r;
6533 char **str;
6534 BcFunc *f;
6535 BcParse prs;
6536 BcInstPtr ip;
6537 size_t fidx, sidx;
Gavin Howard01055ba2018-11-03 11:00:21 -06006538
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006539 if (!BC_PROG_STACK(&G.prog.results, 1))
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006540 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Gavin Howard01055ba2018-11-03 11:00:21 -06006541
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006542 r = bc_vec_top(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006543
6544 if (cond) {
Denys Vlasenko5ec4b492018-12-09 02:54:06 +01006545 BcNum *n = n; // for compiler
6546 bool exec;
6547 char *name;
6548 char *then_name = bc_program_name(code, bgn);
6549 char *else_name = NULL;
Gavin Howard01055ba2018-11-03 11:00:21 -06006550
6551 if (code[*bgn] == BC_PARSE_STREND)
6552 (*bgn) += 1;
6553 else
6554 else_name = bc_program_name(code, bgn);
6555
6556 exec = r->d.n.len != 0;
Denys Vlasenko5ec4b492018-12-09 02:54:06 +01006557 name = then_name;
6558 if (!exec && else_name != NULL) {
Gavin Howard01055ba2018-11-03 11:00:21 -06006559 exec = true;
6560 name = else_name;
6561 }
6562
6563 if (exec) {
Denys Vlasenkodf515392018-12-02 19:27:48 +01006564 BcVec *v;
6565 v = bc_program_search(name, true);
Gavin Howard01055ba2018-11-03 11:00:21 -06006566 n = bc_vec_top(v);
6567 }
6568
6569 free(then_name);
6570 free(else_name);
6571
6572 if (!exec) goto exit;
6573 if (!BC_PROG_STR(n)) {
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01006574 s = bc_error_variable_is_wrong_type();
Gavin Howard01055ba2018-11-03 11:00:21 -06006575 goto exit;
6576 }
6577
6578 sidx = n->rdx;
Denys Vlasenko5ec4b492018-12-09 02:54:06 +01006579 } else {
6580 if (r->t == BC_RESULT_STR) {
Gavin Howard01055ba2018-11-03 11:00:21 -06006581 sidx = r->d.id.idx;
Denys Vlasenko5ec4b492018-12-09 02:54:06 +01006582 } else if (r->t == BC_RESULT_VAR) {
6583 BcNum *n;
Denys Vlasenko29301232018-12-11 15:29:32 +01006584 s = zbc_program_num(r, &n, false);
Gavin Howard01055ba2018-11-03 11:00:21 -06006585 if (s || !BC_PROG_STR(n)) goto exit;
6586 sidx = n->rdx;
Denys Vlasenko5ec4b492018-12-09 02:54:06 +01006587 } else
Gavin Howard01055ba2018-11-03 11:00:21 -06006588 goto exit;
6589 }
6590
6591 fidx = sidx + BC_PROG_REQ_FUNCS;
6592
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006593 str = bc_program_str(sidx);
6594 f = bc_program_func(fidx);
Gavin Howard01055ba2018-11-03 11:00:21 -06006595
6596 if (f->code.len == 0) {
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01006597 bc_parse_create(&prs, fidx);
Denys Vlasenkof86e9602018-12-14 17:01:56 +01006598 s = zbc_parse_text_init(&prs, *str);
Gavin Howard01055ba2018-11-03 11:00:21 -06006599 if (s) goto err;
Denys Vlasenkoae0faf92018-12-12 15:19:54 +01006600 s = zcommon_parse_expr(&prs, BC_PARSE_NOCALL);
Gavin Howard01055ba2018-11-03 11:00:21 -06006601 if (s) goto err;
6602
6603 if (prs.l.t.t != BC_LEX_EOF) {
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01006604 s = bc_error_bad_expression();
Gavin Howard01055ba2018-11-03 11:00:21 -06006605 goto err;
6606 }
6607
6608 bc_parse_free(&prs);
6609 }
6610
6611 ip.idx = 0;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006612 ip.len = G.prog.results.len;
Gavin Howard01055ba2018-11-03 11:00:21 -06006613 ip.func = fidx;
6614
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006615 bc_vec_pop(&G.prog.results);
6616 bc_vec_push(&G.prog.stack, &ip);
Gavin Howard01055ba2018-11-03 11:00:21 -06006617
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006618 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06006619
6620err:
6621 bc_parse_free(&prs);
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006622 f = bc_program_func(fidx);
Denys Vlasenko7d628012018-12-04 21:46:47 +01006623 bc_vec_pop_all(&f->code);
Gavin Howard01055ba2018-11-03 11:00:21 -06006624exit:
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006625 bc_vec_pop(&G.prog.results);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006626 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006627}
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006628#if ERRORS_ARE_FATAL
6629# define zbc_program_execStr(...) (zbc_program_execStr(__VA_ARGS__), BC_STATUS_SUCCESS)
6630#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006631#endif // ENABLE_DC
6632
Denys Vlasenkoe3b4f232018-12-02 18:44:40 +01006633static void bc_program_pushGlobal(char inst)
Gavin Howard01055ba2018-11-03 11:00:21 -06006634{
Gavin Howard01055ba2018-11-03 11:00:21 -06006635 BcResult res;
6636 unsigned long val;
6637
6638 res.t = inst - BC_INST_IBASE + BC_RESULT_IBASE;
6639 if (inst == BC_INST_IBASE)
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006640 val = (unsigned long) G.prog.ib_t;
Gavin Howard01055ba2018-11-03 11:00:21 -06006641 else if (inst == BC_INST_SCALE)
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006642 val = (unsigned long) G.prog.scale;
Gavin Howard01055ba2018-11-03 11:00:21 -06006643 else
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006644 val = (unsigned long) G.prog.ob_t;
Gavin Howard01055ba2018-11-03 11:00:21 -06006645
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01006646 bc_num_init_DEF_SIZE(&res.d.n);
Denys Vlasenkoe3b4f232018-12-02 18:44:40 +01006647 bc_num_ulong2num(&res.d.n, val);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006648 bc_vec_push(&G.prog.results, &res);
Gavin Howard01055ba2018-11-03 11:00:21 -06006649}
6650
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006651static void bc_program_addFunc(char *name, size_t *idx)
Gavin Howard01055ba2018-11-03 11:00:21 -06006652{
Gavin Howard01055ba2018-11-03 11:00:21 -06006653 BcId entry, *entry_ptr;
6654 BcFunc f;
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01006655 int inserted;
Gavin Howard01055ba2018-11-03 11:00:21 -06006656
6657 entry.name = name;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006658 entry.idx = G.prog.fns.len;
Gavin Howard01055ba2018-11-03 11:00:21 -06006659
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01006660 inserted = bc_map_insert(&G.prog.fn_map, &entry, idx);
6661 if (!inserted) free(name);
Gavin Howard01055ba2018-11-03 11:00:21 -06006662
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006663 entry_ptr = bc_vec_item(&G.prog.fn_map, *idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06006664 *idx = entry_ptr->idx;
6665
Denys Vlasenkoa02f8442018-12-03 20:35:16 +01006666 if (!inserted) {
Gavin Howard01055ba2018-11-03 11:00:21 -06006667
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006668 BcFunc *func = bc_program_func(entry_ptr->idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06006669
6670 // We need to reset these, so the function can be repopulated.
6671 func->nparams = 0;
Denys Vlasenko7d628012018-12-04 21:46:47 +01006672 bc_vec_pop_all(&func->autos);
6673 bc_vec_pop_all(&func->code);
6674 bc_vec_pop_all(&func->labels);
Gavin Howard01055ba2018-11-03 11:00:21 -06006675 }
6676 else {
6677 bc_func_init(&f);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006678 bc_vec_push(&G.prog.fns, &f);
Gavin Howard01055ba2018-11-03 11:00:21 -06006679 }
6680}
6681
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006682static BC_STATUS zbc_program_exec(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06006683{
Gavin Howard01055ba2018-11-03 11:00:21 -06006684 BcResult r, *ptr;
6685 BcNum *num;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006686 BcInstPtr *ip = bc_vec_top(&G.prog.stack);
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006687 BcFunc *func = bc_program_func(ip->func);
Gavin Howard01055ba2018-11-03 11:00:21 -06006688 char *code = func->code.v;
Gavin Howard01055ba2018-11-03 11:00:21 -06006689
Denys Vlasenko927a7d62018-12-09 02:24:14 +01006690 while (ip->idx < func->code.len) {
Denys Vlasenkofa35e592018-12-10 20:17:24 +01006691 BcStatus s = BC_STATUS_SUCCESS;
Gavin Howard01055ba2018-11-03 11:00:21 -06006692 char inst = code[(ip->idx)++];
6693
Denys Vlasenko99b37622018-12-15 20:06:59 +01006694 dbg_exec("inst:%d", inst);
Gavin Howard01055ba2018-11-03 11:00:21 -06006695 switch (inst) {
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006696#if ENABLE_BC
Denys Vlasenkofd51e0c2018-12-15 15:07:14 +01006697 case BC_INST_JUMP_ZERO: {
6698 bool zero;
Denys Vlasenko99b37622018-12-15 20:06:59 +01006699 dbg_exec("BC_INST_JUMP_ZERO:");
Denys Vlasenko29301232018-12-11 15:29:32 +01006700 s = zbc_program_prep(&ptr, &num);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006701 if (s) RETURN_STATUS(s);
Denys Vlasenkofd51e0c2018-12-15 15:07:14 +01006702 zero = (bc_num_cmp(num, &G.prog.zero) == 0);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006703 bc_vec_pop(&G.prog.results);
Denys Vlasenkofd51e0c2018-12-15 15:07:14 +01006704 if (!zero) {
6705 bc_program_index(code, &ip->idx);
6706 break;
6707 }
6708 // else: fall through
6709 }
Denys Vlasenko927a7d62018-12-09 02:24:14 +01006710 case BC_INST_JUMP: {
Denys Vlasenko927a7d62018-12-09 02:24:14 +01006711 size_t idx = bc_program_index(code, &ip->idx);
Denys Vlasenkofd51e0c2018-12-15 15:07:14 +01006712 size_t *addr = bc_vec_item(&func->labels, idx);
Denys Vlasenko99b37622018-12-15 20:06:59 +01006713 dbg_exec("BC_INST_JUMP: to %ld", (long)*addr);
Denys Vlasenkofd51e0c2018-12-15 15:07:14 +01006714 ip->idx = *addr;
Gavin Howard01055ba2018-11-03 11:00:21 -06006715 break;
6716 }
Gavin Howard01055ba2018-11-03 11:00:21 -06006717 case BC_INST_CALL:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006718 dbg_exec("BC_INST_CALL:");
Denys Vlasenko29301232018-12-11 15:29:32 +01006719 s = zbc_program_call(code, &ip->idx);
Gavin Howard01055ba2018-11-03 11:00:21 -06006720 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006721 case BC_INST_INC_PRE:
6722 case BC_INST_DEC_PRE:
6723 case BC_INST_INC_POST:
6724 case BC_INST_DEC_POST:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006725 dbg_exec("BC_INST_INCDEC:");
Denys Vlasenko29301232018-12-11 15:29:32 +01006726 s = zbc_program_incdec(inst);
Gavin Howard01055ba2018-11-03 11:00:21 -06006727 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006728 case BC_INST_HALT:
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01006729 dbg_exec("BC_INST_HALT:");
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +01006730 QUIT_OR_RETURN_TO_MAIN;
Gavin Howard01055ba2018-11-03 11:00:21 -06006731 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006732 case BC_INST_RET:
6733 case BC_INST_RET0:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006734 dbg_exec("BC_INST_RET[0]:");
Denys Vlasenko29301232018-12-11 15:29:32 +01006735 s = zbc_program_return(inst);
Gavin Howard01055ba2018-11-03 11:00:21 -06006736 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006737 case BC_INST_BOOL_OR:
6738 case BC_INST_BOOL_AND:
6739#endif // ENABLE_BC
6740 case BC_INST_REL_EQ:
6741 case BC_INST_REL_LE:
6742 case BC_INST_REL_GE:
6743 case BC_INST_REL_NE:
6744 case BC_INST_REL_LT:
6745 case BC_INST_REL_GT:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006746 dbg_exec("BC_INST_BOOL:");
Denys Vlasenko728e7c92018-12-11 19:37:00 +01006747 s = zbc_program_logical(inst);
Gavin Howard01055ba2018-11-03 11:00:21 -06006748 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006749 case BC_INST_READ:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006750 dbg_exec("BC_INST_READ:");
Denys Vlasenko26819db2018-12-12 16:08:46 +01006751 s = zbc_program_read();
Gavin Howard01055ba2018-11-03 11:00:21 -06006752 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006753 case BC_INST_VAR:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006754 dbg_exec("BC_INST_VAR:");
Denys Vlasenkob402ff82018-12-11 15:45:15 +01006755 s = zbc_program_pushVar(code, &ip->idx, false, false);
Gavin Howard01055ba2018-11-03 11:00:21 -06006756 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006757 case BC_INST_ARRAY_ELEM:
6758 case BC_INST_ARRAY:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006759 dbg_exec("BC_INST_ARRAY[_ELEM]:");
Denys Vlasenko29301232018-12-11 15:29:32 +01006760 s = zbc_program_pushArray(code, &ip->idx, inst);
Gavin Howard01055ba2018-11-03 11:00:21 -06006761 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006762 case BC_INST_LAST:
Gavin Howard01055ba2018-11-03 11:00:21 -06006763 r.t = BC_RESULT_LAST;
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006764 bc_vec_push(&G.prog.results, &r);
Gavin Howard01055ba2018-11-03 11:00:21 -06006765 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006766 case BC_INST_IBASE:
6767 case BC_INST_SCALE:
6768 case BC_INST_OBASE:
Denys Vlasenkoe3b4f232018-12-02 18:44:40 +01006769 bc_program_pushGlobal(inst);
Gavin Howard01055ba2018-11-03 11:00:21 -06006770 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006771 case BC_INST_SCALE_FUNC:
6772 case BC_INST_LENGTH:
6773 case BC_INST_SQRT:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006774 dbg_exec("BC_INST_builtin:");
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006775 s = zbc_program_builtin(inst);
Gavin Howard01055ba2018-11-03 11:00:21 -06006776 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006777 case BC_INST_NUM:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006778 dbg_exec("BC_INST_NUM:");
Gavin Howard01055ba2018-11-03 11:00:21 -06006779 r.t = BC_RESULT_CONSTANT;
6780 r.d.id.idx = bc_program_index(code, &ip->idx);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006781 bc_vec_push(&G.prog.results, &r);
Gavin Howard01055ba2018-11-03 11:00:21 -06006782 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006783 case BC_INST_POP:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006784 dbg_exec("BC_INST_POP:");
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006785 if (!BC_PROG_STACK(&G.prog.results, 1))
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01006786 s = bc_error_stack_has_too_few_elements();
Gavin Howard01055ba2018-11-03 11:00:21 -06006787 else
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006788 bc_vec_pop(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006789 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006790 case BC_INST_POP_EXEC:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006791 dbg_exec("BC_INST_POP_EXEC:");
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006792 bc_vec_pop(&G.prog.stack);
Gavin Howard01055ba2018-11-03 11:00:21 -06006793 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006794 case BC_INST_PRINT:
6795 case BC_INST_PRINT_POP:
6796 case BC_INST_PRINT_STR:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006797 dbg_exec("BC_INST_PRINTxyz:");
Denys Vlasenko29301232018-12-11 15:29:32 +01006798 s = zbc_program_print(inst, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06006799 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006800 case BC_INST_STR:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006801 dbg_exec("BC_INST_STR:");
Gavin Howard01055ba2018-11-03 11:00:21 -06006802 r.t = BC_RESULT_STR;
6803 r.d.id.idx = bc_program_index(code, &ip->idx);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006804 bc_vec_push(&G.prog.results, &r);
Gavin Howard01055ba2018-11-03 11:00:21 -06006805 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006806 case BC_INST_POWER:
6807 case BC_INST_MULTIPLY:
6808 case BC_INST_DIVIDE:
6809 case BC_INST_MODULUS:
6810 case BC_INST_PLUS:
6811 case BC_INST_MINUS:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006812 dbg_exec("BC_INST_binaryop:");
Denys Vlasenko259137d2018-12-11 19:42:05 +01006813 s = zbc_program_op(inst);
Gavin Howard01055ba2018-11-03 11:00:21 -06006814 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006815 case BC_INST_BOOL_NOT:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006816 dbg_exec("BC_INST_BOOL_NOT:");
Denys Vlasenko29301232018-12-11 15:29:32 +01006817 s = zbc_program_prep(&ptr, &num);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006818 if (s) RETURN_STATUS(s);
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01006819 bc_num_init_DEF_SIZE(&r.d.n);
Denys Vlasenko927a7d62018-12-09 02:24:14 +01006820 if (!bc_num_cmp(num, &G.prog.zero))
6821 bc_num_one(&r.d.n);
Denys Vlasenko3129f702018-12-09 12:04:44 +01006822 //else bc_num_zero(&r.d.n); - already is
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006823 bc_program_retire(&r, BC_RESULT_TEMP);
Gavin Howard01055ba2018-11-03 11:00:21 -06006824 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006825 case BC_INST_NEG:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006826 dbg_exec("BC_INST_NEG:");
Denys Vlasenko29301232018-12-11 15:29:32 +01006827 s = zbc_program_negate();
Gavin Howard01055ba2018-11-03 11:00:21 -06006828 break;
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006829#if ENABLE_BC
Gavin Howard01055ba2018-11-03 11:00:21 -06006830 case BC_INST_ASSIGN_POWER:
6831 case BC_INST_ASSIGN_MULTIPLY:
6832 case BC_INST_ASSIGN_DIVIDE:
6833 case BC_INST_ASSIGN_MODULUS:
6834 case BC_INST_ASSIGN_PLUS:
6835 case BC_INST_ASSIGN_MINUS:
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006836#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006837 case BC_INST_ASSIGN:
Denys Vlasenko99b37622018-12-15 20:06:59 +01006838 dbg_exec("BC_INST_ASSIGNxyz:");
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006839 s = zbc_program_assign(inst);
Gavin Howard01055ba2018-11-03 11:00:21 -06006840 break;
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01006841#if ENABLE_DC
Gavin Howard01055ba2018-11-03 11:00:21 -06006842 case BC_INST_MODEXP:
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006843 s = zbc_program_modexp();
Gavin Howard01055ba2018-11-03 11:00:21 -06006844 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006845 case BC_INST_DIVMOD:
Denys Vlasenko7f4daa42018-12-11 19:04:44 +01006846 s = zbc_program_divmod();
Gavin Howard01055ba2018-11-03 11:00:21 -06006847 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006848 case BC_INST_EXECUTE:
6849 case BC_INST_EXEC_COND:
Denys Vlasenkofd51e0c2018-12-15 15:07:14 +01006850 s = zbc_program_execStr(code, &ip->idx, inst == BC_INST_EXEC_COND);
Gavin Howard01055ba2018-11-03 11:00:21 -06006851 break;
Denys Vlasenko927a7d62018-12-09 02:24:14 +01006852 case BC_INST_PRINT_STACK: {
6853 size_t idx;
6854 for (idx = 0; idx < G.prog.results.len; ++idx) {
Denys Vlasenko29301232018-12-11 15:29:32 +01006855 s = zbc_program_print(BC_INST_PRINT, idx);
Denys Vlasenko927a7d62018-12-09 02:24:14 +01006856 if (s) break;
6857 }
Gavin Howard01055ba2018-11-03 11:00:21 -06006858 break;
6859 }
Gavin Howard01055ba2018-11-03 11:00:21 -06006860 case BC_INST_CLEAR_STACK:
Denys Vlasenko7d628012018-12-04 21:46:47 +01006861 bc_vec_pop_all(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006862 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006863 case BC_INST_STACK_LEN:
Denys Vlasenkoe3b4f232018-12-02 18:44:40 +01006864 bc_program_stackLen();
Gavin Howard01055ba2018-11-03 11:00:21 -06006865 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006866 case BC_INST_DUPLICATE:
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006867 if (!BC_PROG_STACK(&G.prog.results, 1))
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006868 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006869 ptr = bc_vec_top(&G.prog.results);
Gavin Howard01055ba2018-11-03 11:00:21 -06006870 bc_result_copy(&r, ptr);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006871 bc_vec_push(&G.prog.results, &r);
Gavin Howard01055ba2018-11-03 11:00:21 -06006872 break;
Denys Vlasenko927a7d62018-12-09 02:24:14 +01006873 case BC_INST_SWAP: {
Gavin Howard01055ba2018-11-03 11:00:21 -06006874 BcResult *ptr2;
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006875 if (!BC_PROG_STACK(&G.prog.results, 2))
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006876 RETURN_STATUS(bc_error_stack_has_too_few_elements());
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006877 ptr = bc_vec_item_rev(&G.prog.results, 0);
6878 ptr2 = bc_vec_item_rev(&G.prog.results, 1);
Gavin Howard01055ba2018-11-03 11:00:21 -06006879 memcpy(&r, ptr, sizeof(BcResult));
6880 memcpy(ptr, ptr2, sizeof(BcResult));
6881 memcpy(ptr2, &r, sizeof(BcResult));
Gavin Howard01055ba2018-11-03 11:00:21 -06006882 break;
6883 }
Gavin Howard01055ba2018-11-03 11:00:21 -06006884 case BC_INST_ASCIIFY:
Denys Vlasenkoc008a732018-12-11 20:57:53 +01006885 s = zbc_program_asciify();
Gavin Howard01055ba2018-11-03 11:00:21 -06006886 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006887 case BC_INST_PRINT_STREAM:
Denys Vlasenko29301232018-12-11 15:29:32 +01006888 s = zbc_program_printStream();
Gavin Howard01055ba2018-11-03 11:00:21 -06006889 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006890 case BC_INST_LOAD:
Denys Vlasenko927a7d62018-12-09 02:24:14 +01006891 case BC_INST_PUSH_VAR: {
Gavin Howard01055ba2018-11-03 11:00:21 -06006892 bool copy = inst == BC_INST_LOAD;
Denys Vlasenkob402ff82018-12-11 15:45:15 +01006893 s = zbc_program_pushVar(code, &ip->idx, true, copy);
Gavin Howard01055ba2018-11-03 11:00:21 -06006894 break;
6895 }
Denys Vlasenko927a7d62018-12-09 02:24:14 +01006896 case BC_INST_PUSH_TO_VAR: {
Gavin Howard01055ba2018-11-03 11:00:21 -06006897 char *name = bc_program_name(code, &ip->idx);
Denys Vlasenko29301232018-12-11 15:29:32 +01006898 s = zbc_program_copyToVar(name, true);
Gavin Howard01055ba2018-11-03 11:00:21 -06006899 free(name);
6900 break;
6901 }
Gavin Howard01055ba2018-11-03 11:00:21 -06006902 case BC_INST_QUIT:
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01006903 dbg_exec("BC_INST_NEG:");
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006904 if (G.prog.stack.len <= 2)
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +01006905 QUIT_OR_RETURN_TO_MAIN;
Denys Vlasenkocfdc1332018-12-03 14:02:35 +01006906 bc_vec_npop(&G.prog.stack, 2);
Gavin Howard01055ba2018-11-03 11:00:21 -06006907 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006908 case BC_INST_NQUIT:
Denys Vlasenko29301232018-12-11 15:29:32 +01006909 s = zbc_program_nquit();
Gavin Howard01055ba2018-11-03 11:00:21 -06006910 break;
Gavin Howard01055ba2018-11-03 11:00:21 -06006911#endif // ENABLE_DC
6912 }
6913
Denys Vlasenkod38af482018-12-04 19:11:02 +01006914 if (s || G_interrupt) {
6915 bc_program_reset();
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006916 RETURN_STATUS(s);
Denys Vlasenkod38af482018-12-04 19:11:02 +01006917 }
Gavin Howard01055ba2018-11-03 11:00:21 -06006918
6919 // If the stack has changed, pointers may be invalid.
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01006920 ip = bc_vec_top(&G.prog.stack);
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006921 func = bc_program_func(ip->func);
Gavin Howard01055ba2018-11-03 11:00:21 -06006922 code = func->code.v;
6923 }
6924
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006925 RETURN_STATUS(BC_STATUS_SUCCESS);
Gavin Howard01055ba2018-11-03 11:00:21 -06006926}
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006927#if ERRORS_ARE_FATAL
6928# define zbc_program_exec(...) (zbc_program_exec(__VA_ARGS__), BC_STATUS_SUCCESS)
6929#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006930
Denys Vlasenko1ff1c702018-12-06 00:46:09 +01006931static unsigned bc_vm_envLen(const char *var)
Gavin Howard01055ba2018-11-03 11:00:21 -06006932{
Denys Vlasenko1ff1c702018-12-06 00:46:09 +01006933 char *lenv;
6934 unsigned len;
Gavin Howard01055ba2018-11-03 11:00:21 -06006935
Denys Vlasenko1ff1c702018-12-06 00:46:09 +01006936 lenv = getenv(var);
6937 len = BC_NUM_PRINT_WIDTH;
Gavin Howard01055ba2018-11-03 11:00:21 -06006938 if (!lenv) return len;
6939
Denys Vlasenko1ff1c702018-12-06 00:46:09 +01006940 len = bb_strtou(lenv, NULL, 10) - 1;
6941 if (errno || len < 2 || len >= INT_MAX)
Gavin Howard01055ba2018-11-03 11:00:21 -06006942 len = BC_NUM_PRINT_WIDTH;
6943
6944 return len;
6945}
6946
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006947static BC_STATUS zbc_vm_process(const char *text)
Gavin Howard01055ba2018-11-03 11:00:21 -06006948{
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01006949 BcStatus s;
Gavin Howard01055ba2018-11-03 11:00:21 -06006950
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01006951 dbg_lex_enter("%s:%d entered", __func__, __LINE__);
6952 s = zbc_parse_text_init(&G.prs, text);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006953 if (s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006954
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01006955 while (G.prs.l.t.t != BC_LEX_EOF) {
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01006956 dbg_lex("%s:%d G.prs.l.t.t:%d", __func__, __LINE__, G.prs.l.t.t);
Denys Vlasenkoc0ef23c2018-12-12 23:03:10 +01006957 ERROR_RETURN(s =) zcommon_parse(&G.prs);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006958 if (s) RETURN_STATUS(s);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006959 s = zbc_program_exec();
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01006960 if (s) {
Denys Vlasenkod38af482018-12-04 19:11:02 +01006961 bc_program_reset();
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01006962 break;
6963 }
6964 fflush_and_check();
Gavin Howard01055ba2018-11-03 11:00:21 -06006965 }
6966
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01006967 dbg_lex_done("%s:%d done", __func__, __LINE__);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006968 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06006969}
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006970#if ERRORS_ARE_FATAL
6971# define zbc_vm_process(...) (zbc_vm_process(__VA_ARGS__), BC_STATUS_SUCCESS)
6972#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06006973
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006974static BC_STATUS zbc_vm_file(const char *file)
Gavin Howard01055ba2018-11-03 11:00:21 -06006975{
Denys Vlasenko0fe270e2018-12-13 19:58:58 +01006976 // So far bc/dc have no way to include a file from another file,
6977 // therefore we know G.prog.file == NULL on entry
6978 //const char *sv_file;
Gavin Howard01055ba2018-11-03 11:00:21 -06006979 char *data;
Denys Vlasenko0409ad32018-12-05 16:39:22 +01006980 BcStatus s;
Gavin Howard01055ba2018-11-03 11:00:21 -06006981 BcFunc *main_func;
6982 BcInstPtr *ip;
6983
Denys Vlasenkodf515392018-12-02 19:27:48 +01006984 data = bc_read_file(file);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006985 if (!data) RETURN_STATUS(bc_error_fmt("file '%s' is not text", file));
Gavin Howard01055ba2018-11-03 11:00:21 -06006986
Denys Vlasenko0fe270e2018-12-13 19:58:58 +01006987 //sv_file = G.prog.file;
Denys Vlasenko0409ad32018-12-05 16:39:22 +01006988 G.prog.file = file;
6989 bc_lex_file(&G.prs.l);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01006990 s = zbc_vm_process(data);
Gavin Howard01055ba2018-11-03 11:00:21 -06006991 if (s) goto err;
6992
Denys Vlasenko8fa1e8e2018-12-09 00:03:57 +01006993 main_func = bc_program_func(BC_PROG_MAIN);
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01006994 ip = bc_vec_item(&G.prog.stack, 0);
Gavin Howard01055ba2018-11-03 11:00:21 -06006995
Denys Vlasenko60cf7472018-12-04 20:05:28 +01006996 if (main_func->code.len < ip->idx)
Denys Vlasenko24fb2cd2018-12-05 16:03:46 +01006997 s = bc_error_fmt("file '%s' is not executable", file);
Gavin Howard01055ba2018-11-03 11:00:21 -06006998
6999err:
Denys Vlasenko0fe270e2018-12-13 19:58:58 +01007000 //G.prog.file = sv_file;
7001 G.prog.file = NULL;
Gavin Howard01055ba2018-11-03 11:00:21 -06007002 free(data);
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01007003 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06007004}
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01007005#if ERRORS_ARE_FATAL
7006# define zbc_vm_file(...) (zbc_vm_file(__VA_ARGS__), BC_STATUS_SUCCESS)
7007#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06007008
Denys Vlasenko19f11072018-12-12 22:48:19 +01007009static BC_STATUS zbc_vm_stdin(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06007010{
Denys Vlasenkoa0c421c2018-12-02 20:16:52 +01007011 BcStatus s;
Gavin Howard01055ba2018-11-03 11:00:21 -06007012
Denys Vlasenko0fe270e2018-12-13 19:58:58 +01007013 //G.prog.file = NULL; - already is
Denys Vlasenko0409ad32018-12-05 16:39:22 +01007014 bc_lex_file(&G.prs.l);
Gavin Howard01055ba2018-11-03 11:00:21 -06007015
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01007016 G.use_stdin = 1;
Denys Vlasenkoe9519e42018-12-16 17:06:07 +01007017 do {
7018 s = zbc_vm_process("");
7019 // We do not stop looping on errors here.
7020 // Example: start interactive bc and enter "return".
7021 // It should say "'return' not in a function"
7022 // but should not exit.
7023 } while (G.use_stdin);
Denys Vlasenko19f11072018-12-12 22:48:19 +01007024 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06007025}
Denys Vlasenko19f11072018-12-12 22:48:19 +01007026#if ERRORS_ARE_FATAL
7027# define zbc_vm_stdin(...) (zbc_vm_stdin(__VA_ARGS__), BC_STATUS_SUCCESS)
7028#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06007029
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007030#if ENABLE_BC
Denys Vlasenko57b69182018-12-14 00:12:13 +01007031static void bc_vm_info(void)
7032{
7033 printf("%s "BB_VER"\n"
7034 "Copyright (c) 2018 Gavin D. Howard and contributors\n"
7035 , applet_name);
7036}
7037
7038static void bc_args(char **argv)
7039{
7040 unsigned opts;
7041 int i;
7042
7043 GETOPT_RESET();
7044#if ENABLE_FEATURE_BC_LONG_OPTIONS
7045 opts = option_mask32 |= getopt32long(argv, "wvsqli",
7046 "warn\0" No_argument "w"
7047 "version\0" No_argument "v"
7048 "standard\0" No_argument "s"
7049 "quiet\0" No_argument "q"
7050 "mathlib\0" No_argument "l"
7051 "interactive\0" No_argument "i"
7052 );
7053#else
7054 opts = option_mask32 |= getopt32(argv, "wvsqli");
7055#endif
7056 if (getenv("POSIXLY_CORRECT"))
7057 option_mask32 |= BC_FLAG_S;
7058
7059 if (opts & BC_FLAG_V) {
7060 bc_vm_info();
7061 exit(0);
7062 }
7063
7064 for (i = optind; argv[i]; ++i)
7065 bc_vec_push(&G.files, argv + i);
7066}
7067
7068static void bc_vm_envArgs(void)
7069{
7070 BcVec v;
7071 char *buf;
7072 char *env_args = getenv("BC_ENV_ARGS");
7073
7074 if (!env_args) return;
7075
7076 G.env_args = xstrdup(env_args);
7077 buf = G.env_args;
7078
7079 bc_vec_init(&v, sizeof(char *), NULL);
7080
7081 while (*(buf = skip_whitespace(buf)) != '\0') {
7082 bc_vec_push(&v, &buf);
7083 buf = skip_non_whitespace(buf);
7084 if (!*buf)
7085 break;
7086 *buf++ = '\0';
7087 }
7088
7089 // NULL terminate, and pass argv[] so that first arg is argv[1]
7090 if (sizeof(int) == sizeof(char*)) {
7091 bc_vec_push(&v, &const_int_0);
7092 } else {
7093 static char *const nullptr = NULL;
7094 bc_vec_push(&v, &nullptr);
7095 }
7096 bc_args(((char **)v.v) - 1);
7097
7098 bc_vec_free(&v);
7099}
7100
7101static const char bc_lib[] ALIGN1 = {
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007102 "scale=20"
7103"\n" "define e(x){"
7104"\n" "auto b,s,n,r,d,i,p,f,v"
Denys Vlasenko203210e2018-12-14 09:53:50 +01007105////////////////"if(x<0)return(1/e(-x))" // and drop 'n' and x<0 logic below
7106//^^^^^^^^^^^^^^^^ this would work, and is even more precise than GNU bc:
7107//e(-.998896): GNU:.36828580434569428695
7108// above code:.36828580434569428696
7109// actual value:.3682858043456942869594...
7110// but for now let's be "GNU compatible"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007111"\n" "b=ibase"
7112"\n" "ibase=A"
7113"\n" "if(x<0){"
7114"\n" "n=1"
7115"\n" "x=-x"
7116"\n" "}"
7117"\n" "s=scale"
Denys Vlasenko146a79d2018-12-16 21:46:11 +01007118"\n" "r=6+s+.44*x"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007119"\n" "scale=scale(x)+1"
7120"\n" "while(x>1){"
7121"\n" "d+=1"
7122"\n" "x/=2"
7123"\n" "scale+=1"
7124"\n" "}"
7125"\n" "scale=r"
7126"\n" "r=x+1"
7127"\n" "p=x"
7128"\n" "f=v=1"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007129"\n" "for(i=2;v;++i){"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007130"\n" "p*=x"
7131"\n" "f*=i"
7132"\n" "v=p/f"
7133"\n" "r+=v"
7134"\n" "}"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007135"\n" "while(d--)r*=r"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007136"\n" "scale=s"
7137"\n" "ibase=b"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007138"\n" "if(n)return(1/r)"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007139"\n" "return(r/1)"
7140"\n" "}"
7141"\n" "define l(x){"
7142"\n" "auto b,s,r,p,a,q,i,v"
7143"\n" "b=ibase"
7144"\n" "ibase=A"
7145"\n" "if(x<=0){"
7146"\n" "r=(1-10^scale)/1"
7147"\n" "ibase=b"
7148"\n" "return(r)"
7149"\n" "}"
7150"\n" "s=scale"
7151"\n" "scale+=6"
7152"\n" "p=2"
7153"\n" "while(x>=2){"
7154"\n" "p*=2"
7155"\n" "x=sqrt(x)"
7156"\n" "}"
Denys Vlasenko146a79d2018-12-16 21:46:11 +01007157"\n" "while(x<=.5){"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007158"\n" "p*=2"
7159"\n" "x=sqrt(x)"
7160"\n" "}"
7161"\n" "r=a=(x-1)/(x+1)"
7162"\n" "q=a*a"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007163"\n" "v=1"
7164"\n" "for(i=3;v;i+=2){"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007165"\n" "a*=q"
7166"\n" "v=a/i"
7167"\n" "r+=v"
7168"\n" "}"
7169"\n" "r*=p"
7170"\n" "scale=s"
7171"\n" "ibase=b"
7172"\n" "return(r/1)"
7173"\n" "}"
7174"\n" "define s(x){"
Denys Vlasenko240d7ee2018-12-14 11:27:09 +01007175"\n" "auto b,s,r,a,q,i"
7176"\n" "if(x<0)return(-s(-x))"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007177"\n" "b=ibase"
7178"\n" "ibase=A"
7179"\n" "s=scale"
7180"\n" "scale=1.1*s+2"
7181"\n" "a=a(1)"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007182"\n" "scale=0"
7183"\n" "q=(x/a+2)/4"
Denys Vlasenko203210e2018-12-14 09:53:50 +01007184"\n" "x-=4*q*a"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007185"\n" "if(q%2)x=-x"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007186"\n" "scale=s+2"
7187"\n" "r=a=x"
7188"\n" "q=-x*x"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007189"\n" "for(i=3;a;i+=2){"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007190"\n" "a*=q/(i*(i-1))"
7191"\n" "r+=a"
7192"\n" "}"
7193"\n" "scale=s"
7194"\n" "ibase=b"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007195"\n" "return(r/1)"
7196"\n" "}"
7197"\n" "define c(x){"
7198"\n" "auto b,s"
7199"\n" "b=ibase"
7200"\n" "ibase=A"
7201"\n" "s=scale"
7202"\n" "scale*=1.2"
7203"\n" "x=s(2*a(1)+x)"
7204"\n" "scale=s"
7205"\n" "ibase=b"
7206"\n" "return(x/1)"
7207"\n" "}"
7208"\n" "define a(x){"
7209"\n" "auto b,s,r,n,a,m,t,f,i,u"
7210"\n" "b=ibase"
7211"\n" "ibase=A"
7212"\n" "n=1"
7213"\n" "if(x<0){"
7214"\n" "n=-1"
7215"\n" "x=-x"
7216"\n" "}"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007217"\n" "if(scale<65){"
7218"\n" "if(x==1)return(.7853981633974483096156608458198757210492923498437764552437361480/n)"
7219"\n" "if(x==.2)return(.1973955598498807583700497651947902934475851037878521015176889402/n)"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007220"\n" "}"
7221"\n" "s=scale"
7222"\n" "if(x>.2){"
7223"\n" "scale+=5"
7224"\n" "a=a(.2)"
7225"\n" "}"
7226"\n" "scale=s+3"
7227"\n" "while(x>.2){"
7228"\n" "m+=1"
7229"\n" "x=(x-.2)/(1+.2*x)"
7230"\n" "}"
7231"\n" "r=u=x"
7232"\n" "f=-x*x"
7233"\n" "t=1"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007234"\n" "for(i=3;t;i+=2){"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007235"\n" "u*=f"
7236"\n" "t=u/i"
7237"\n" "r+=t"
7238"\n" "}"
7239"\n" "scale=s"
7240"\n" "ibase=b"
7241"\n" "return((m*a+r)/n)"
7242"\n" "}"
7243"\n" "define j(n,x){"
7244"\n" "auto b,s,o,a,i,v,f"
7245"\n" "b=ibase"
7246"\n" "ibase=A"
7247"\n" "s=scale"
7248"\n" "scale=0"
7249"\n" "n/=1"
7250"\n" "if(n<0){"
7251"\n" "n=-n"
Denys Vlasenko203210e2018-12-14 09:53:50 +01007252"\n" "o=n%2"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007253"\n" "}"
7254"\n" "a=1"
7255"\n" "for(i=2;i<=n;++i)a*=i"
7256"\n" "scale=1.5*s"
7257"\n" "a=(x^n)/2^n/a"
7258"\n" "r=v=1"
7259"\n" "f=-x*x/4"
Denys Vlasenkoc06537d2018-12-14 10:10:37 +01007260"\n" "scale+=length(a)-scale(a)"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007261"\n" "for(i=1;v;++i){"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007262"\n" "v=v*f/i/(n+i)"
7263"\n" "r+=v"
7264"\n" "}"
7265"\n" "scale=s"
7266"\n" "ibase=b"
Denys Vlasenko3ac0c212018-12-14 01:01:01 +01007267"\n" "if(o)a=-a"
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007268"\n" "return(a*r/1)"
7269"\n" "}"
7270};
7271#endif // ENABLE_BC
7272
Denys Vlasenko19f11072018-12-12 22:48:19 +01007273static BC_STATUS zbc_vm_exec(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06007274{
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007275 BcStatus s;
Gavin Howard01055ba2018-11-03 11:00:21 -06007276 size_t i;
7277
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01007278#if ENABLE_BC
Denys Vlasenkod70d4a02018-12-04 20:58:40 +01007279 if (option_mask32 & BC_FLAG_L) {
Denys Vlasenko0ad36c42018-12-05 16:21:43 +01007280 // We know that internal library is not buggy,
7281 // thus error checking is normally disabled.
7282# define DEBUG_LIB 0
Denys Vlasenko0409ad32018-12-05 16:39:22 +01007283 bc_lex_file(&G.prs.l);
Denys Vlasenko2ea53a42018-12-14 17:51:17 +01007284 s = zbc_vm_process(bc_lib);
Denys Vlasenko19f11072018-12-12 22:48:19 +01007285 if (DEBUG_LIB && s) RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06007286 }
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01007287#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06007288
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007289 s = BC_STATUS_SUCCESS;
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01007290 for (i = 0; !s && i < G.files.len; ++i)
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01007291 s = zbc_vm_file(*((char **) bc_vec_item(&G.files, i)));
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007292 if (ENABLE_FEATURE_CLEAN_UP && s && !G_ttyin) {
7293 // Debug config, non-interactive mode:
7294 // return all the way back to main.
7295 // Non-debug builds do not come here, they exit.
Denys Vlasenko19f11072018-12-12 22:48:19 +01007296 RETURN_STATUS(s);
Denys Vlasenko9b70f192018-12-04 20:51:40 +01007297 }
Gavin Howard01055ba2018-11-03 11:00:21 -06007298
Denys Vlasenko91cde952018-12-10 20:56:08 +01007299 if (IS_BC || (option_mask32 & BC_FLAG_I))
Denys Vlasenko19f11072018-12-12 22:48:19 +01007300 s = zbc_vm_stdin();
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007301
Denys Vlasenko19f11072018-12-12 22:48:19 +01007302 RETURN_STATUS(s);
Gavin Howard01055ba2018-11-03 11:00:21 -06007303}
Denys Vlasenko19f11072018-12-12 22:48:19 +01007304#if ERRORS_ARE_FATAL
7305# define zbc_vm_exec(...) (zbc_vm_exec(__VA_ARGS__), BC_STATUS_SUCCESS)
7306#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06007307
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007308#if ENABLE_FEATURE_CLEAN_UP
Denys Vlasenkoe873ff92018-12-06 00:29:22 +01007309static void bc_program_free(void)
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007310{
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01007311 bc_num_free(&G.prog.ib);
7312 bc_num_free(&G.prog.ob);
7313 bc_num_free(&G.prog.hexb);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007314# if ENABLE_DC
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01007315 bc_num_free(&G.prog.strmb);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007316# endif
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01007317 bc_vec_free(&G.prog.fns);
7318 bc_vec_free(&G.prog.fn_map);
7319 bc_vec_free(&G.prog.vars);
7320 bc_vec_free(&G.prog.var_map);
7321 bc_vec_free(&G.prog.arrs);
7322 bc_vec_free(&G.prog.arr_map);
7323 bc_vec_free(&G.prog.strs);
7324 bc_vec_free(&G.prog.consts);
7325 bc_vec_free(&G.prog.results);
7326 bc_vec_free(&G.prog.stack);
7327 bc_num_free(&G.prog.last);
7328 bc_num_free(&G.prog.zero);
7329 bc_num_free(&G.prog.one);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01007330 bc_vec_free(&G.stdin_buffer);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007331}
7332
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01007333static void bc_vm_free(void)
Gavin Howard01055ba2018-11-03 11:00:21 -06007334{
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01007335 bc_vec_free(&G.files);
Denys Vlasenkoa1d3ca22018-12-02 18:26:38 +01007336 bc_program_free();
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01007337 bc_parse_free(&G.prs);
7338 free(G.env_args);
Gavin Howard01055ba2018-11-03 11:00:21 -06007339}
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007340#endif
7341
Denys Vlasenko1ff1c702018-12-06 00:46:09 +01007342static void bc_program_init(void)
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007343{
7344 size_t idx;
7345 BcInstPtr ip;
7346
Denys Vlasenko82269122018-12-14 16:30:56 +01007347 // memset(&G.prog, 0, sizeof(G.prog)); - already is
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007348 memset(&ip, 0, sizeof(BcInstPtr));
7349
Denys Vlasenko82269122018-12-14 16:30:56 +01007350 // G.prog.nchars = G.prog.scale = 0; - already is
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01007351 bc_num_init_DEF_SIZE(&G.prog.ib);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007352 bc_num_ten(&G.prog.ib);
7353 G.prog.ib_t = 10;
7354
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01007355 bc_num_init_DEF_SIZE(&G.prog.ob);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007356 bc_num_ten(&G.prog.ob);
7357 G.prog.ob_t = 10;
7358
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01007359 bc_num_init_DEF_SIZE(&G.prog.hexb);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007360 bc_num_ten(&G.prog.hexb);
7361 G.prog.hexb.num[0] = 6;
7362
7363#if ENABLE_DC
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01007364 bc_num_init_DEF_SIZE(&G.prog.strmb);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007365 bc_num_ulong2num(&G.prog.strmb, UCHAR_MAX + 1);
7366#endif
7367
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01007368 bc_num_init_DEF_SIZE(&G.prog.last);
Denys Vlasenko3129f702018-12-09 12:04:44 +01007369 //bc_num_zero(&G.prog.last); - already is
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007370
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01007371 bc_num_init_DEF_SIZE(&G.prog.zero);
Denys Vlasenko3129f702018-12-09 12:04:44 +01007372 //bc_num_zero(&G.prog.zero); - already is
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007373
Denys Vlasenkoe20e00d2018-12-09 11:44:20 +01007374 bc_num_init_DEF_SIZE(&G.prog.one);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007375 bc_num_one(&G.prog.one);
7376
7377 bc_vec_init(&G.prog.fns, sizeof(BcFunc), bc_func_free);
Denys Vlasenkocb9a99f2018-12-04 21:54:33 +01007378 bc_vec_init(&G.prog.fn_map, sizeof(BcId), bc_id_free);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007379
Denys Vlasenko1f67e932018-12-03 00:08:59 +01007380 bc_program_addFunc(xstrdup("(main)"), &idx);
7381 bc_program_addFunc(xstrdup("(read)"), &idx);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007382
7383 bc_vec_init(&G.prog.vars, sizeof(BcVec), bc_vec_free);
Denys Vlasenkocb9a99f2018-12-04 21:54:33 +01007384 bc_vec_init(&G.prog.var_map, sizeof(BcId), bc_id_free);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007385
7386 bc_vec_init(&G.prog.arrs, sizeof(BcVec), bc_vec_free);
Denys Vlasenkocb9a99f2018-12-04 21:54:33 +01007387 bc_vec_init(&G.prog.arr_map, sizeof(BcId), bc_id_free);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007388
7389 bc_vec_init(&G.prog.strs, sizeof(char *), bc_string_free);
7390 bc_vec_init(&G.prog.consts, sizeof(char *), bc_string_free);
7391 bc_vec_init(&G.prog.results, sizeof(BcResult), bc_result_free);
7392 bc_vec_init(&G.prog.stack, sizeof(BcInstPtr), NULL);
7393 bc_vec_push(&G.prog.stack, &ip);
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01007394
7395 bc_char_vec_init(&G.stdin_buffer);
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007396}
Gavin Howard01055ba2018-11-03 11:00:21 -06007397
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007398static int bc_vm_init(const char *env_len)
Gavin Howard01055ba2018-11-03 11:00:21 -06007399{
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007400#if ENABLE_FEATURE_EDITING
7401 G.line_input_state = new_line_input_t(DO_HISTORY);
7402#endif
7403 G.prog.len = bc_vm_envLen(env_len);
7404
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01007405 bc_vec_init(&G.files, sizeof(char *), NULL);
Denys Vlasenko5f263f42018-12-13 22:49:59 +01007406 IF_BC(if (IS_BC) bc_vm_envArgs();)
Denys Vlasenko1ff1c702018-12-06 00:46:09 +01007407 bc_program_init();
Denys Vlasenkoc2265f52018-12-12 23:10:08 +01007408 bc_parse_create(&G.prs, BC_PROG_MAIN);
Gavin Howard01055ba2018-11-03 11:00:21 -06007409
Denys Vlasenko89e785a2018-12-13 16:35:52 +01007410//TODO: in GNU bc, the check is (isatty(0) && isatty(1)),
7411//-i option unconditionally enables this regardless of isatty():
Denys Vlasenko1a6a4822018-12-06 09:20:32 +01007412 if (isatty(0)) {
Denys Vlasenkod38af482018-12-04 19:11:02 +01007413#if ENABLE_FEATURE_BC_SIGNALS
Denys Vlasenko1a6a4822018-12-06 09:20:32 +01007414 G_ttyin = 1;
Denys Vlasenko17c54722018-12-04 21:21:32 +01007415 // With SA_RESTART, most system calls will restart
7416 // (IOW: they won't fail with EINTR).
7417 // In particular, this means ^C won't cause
7418 // stdout to get into "error state" if SIGINT hits
7419 // within write() syscall.
Denys Vlasenko89e785a2018-12-13 16:35:52 +01007420 //
7421 // The downside is that ^C while tty input is taken
Denys Vlasenko17c54722018-12-04 21:21:32 +01007422 // will only be handled after [Enter] since read()
7423 // from stdin is not interrupted by ^C either,
7424 // it restarts, thus fgetc() does not return on ^C.
Denys Vlasenko89e785a2018-12-13 16:35:52 +01007425 // (This problem manifests only if line editing is disabled)
Denys Vlasenko17c54722018-12-04 21:21:32 +01007426 signal_SA_RESTART_empty_mask(SIGINT, record_signo);
7427
7428 // Without SA_RESTART, this exhibits a bug:
7429 // "while (1) print 1" and try ^C-ing it.
7430 // Intermittently, instead of returning to input line,
7431 // you'll get "output error: Interrupted system call"
7432 // and exit.
7433 //signal_no_SA_RESTART_empty_mask(SIGINT, record_signo);
Denys Vlasenkod38af482018-12-04 19:11:02 +01007434#endif
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007435 return 1; // "tty"
Denys Vlasenkod38af482018-12-04 19:11:02 +01007436 }
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007437 return 0; // "not a tty"
7438}
Denys Vlasenko1ff1c702018-12-06 00:46:09 +01007439
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007440static BcStatus bc_vm_run(void)
7441{
Denys Vlasenko19f11072018-12-12 22:48:19 +01007442 BcStatus st = zbc_vm_exec();
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007443#if ENABLE_FEATURE_CLEAN_UP
Denys Vlasenkoc7a7ce02018-12-06 23:06:57 +01007444 if (G_exiting) // it was actually "halt" or "quit"
7445 st = EXIT_SUCCESS;
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01007446 bc_vm_free();
Denys Vlasenko95f93bd2018-12-06 10:29:12 +01007447# if ENABLE_FEATURE_EDITING
7448 free_line_input_t(G.line_input_state);
7449# endif
Denys Vlasenkoe873ff92018-12-06 00:29:22 +01007450 FREE_G();
Denys Vlasenko785e4b32018-12-02 17:18:52 +01007451#endif
Denys Vlasenkod1d29b42018-12-16 16:03:03 +01007452 dbg_exec("exiting with exitcode %d", st);
Gavin Howard01055ba2018-11-03 11:00:21 -06007453 return st;
7454}
7455
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01007456#if ENABLE_BC
Denys Vlasenko5a9fef52018-12-02 14:35:32 +01007457int bc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
Denys Vlasenko1ff1c702018-12-06 00:46:09 +01007458int bc_main(int argc UNUSED_PARAM, char **argv)
Gavin Howard01055ba2018-11-03 11:00:21 -06007459{
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007460 int is_tty;
7461
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01007462 INIT_G();
Gavin Howard01055ba2018-11-03 11:00:21 -06007463
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007464 is_tty = bc_vm_init("BC_LINE_LENGTH");
7465
7466 bc_args(argv);
7467
7468 if (is_tty && !(option_mask32 & BC_FLAG_Q))
7469 bc_vm_info();
7470
7471 return bc_vm_run();
Gavin Howard01055ba2018-11-03 11:00:21 -06007472}
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01007473#endif
Gavin Howard01055ba2018-11-03 11:00:21 -06007474
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01007475#if ENABLE_DC
Denys Vlasenko5a9fef52018-12-02 14:35:32 +01007476int dc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
Denys Vlasenko1ff1c702018-12-06 00:46:09 +01007477int dc_main(int argc UNUSED_PARAM, char **argv)
Gavin Howard01055ba2018-11-03 11:00:21 -06007478{
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007479 int noscript;
7480
Denys Vlasenko6d9146a2018-12-02 15:48:37 +01007481 INIT_G();
Denys Vlasenko82269122018-12-14 16:30:56 +01007482
7483 // TODO: dc (GNU bc 1.07.1) 1.4.1 seems to use width
7484 // 1 char wider than bc from the same package.
7485 // Both default width, and xC_LINE_LENGTH=N are wider:
7486 // "DC_LINE_LENGTH=5 dc -e'123456 p'" prints:
Denys Vlasenko0a238142018-12-14 16:48:34 +01007487 // |1234\ |
7488 // |56 |
Denys Vlasenko82269122018-12-14 16:30:56 +01007489 // "echo '123456' | BC_LINE_LENGTH=5 bc" prints:
Denys Vlasenko0a238142018-12-14 16:48:34 +01007490 // |123\ |
7491 // |456 |
Denys Vlasenko82269122018-12-14 16:30:56 +01007492 // Do the same, or it's a bug?
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007493 bc_vm_init("DC_LINE_LENGTH");
Gavin Howard01055ba2018-11-03 11:00:21 -06007494
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007495 // Run -e'SCRIPT' and -fFILE in order of appearance, then handle FILEs
7496 noscript = BC_FLAG_I;
7497 for (;;) {
7498 int n = getopt(argc, argv, "e:f:x");
7499 if (n <= 0)
7500 break;
7501 switch (n) {
7502 case 'e':
7503 noscript = 0;
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01007504 n = zbc_vm_process(optarg);
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007505 if (n) return n;
7506 break;
7507 case 'f':
7508 noscript = 0;
Denys Vlasenkod6ad3662018-12-12 21:39:10 +01007509 n = zbc_vm_file(optarg);
7510 if (n) return n;
Denys Vlasenko6d0be102018-12-06 18:41:59 +01007511 break;
7512 case 'x':
7513 option_mask32 |= DC_FLAG_X;
7514 break;
7515 default:
7516 bb_show_usage();
7517 }
7518 }
7519 argv += optind;
7520
7521 while (*argv) {
7522 noscript = 0;
7523 bc_vec_push(&G.files, argv++);
7524 }
7525
7526 option_mask32 |= noscript; // set BC_FLAG_I if we need to interpret stdin
7527
7528 return bc_vm_run();
Gavin Howard01055ba2018-11-03 11:00:21 -06007529}
Denys Vlasenkoef869ec2018-12-02 18:49:16 +01007530#endif
Denys Vlasenko9ca9ef22018-12-06 11:31:14 +01007531
7532#endif // not DC_SMALL