1/*
2 * *****************************************************************************
3 *
4 * SPDX-License-Identifier: BSD-2-Clause
5 *
6 * Copyright (c) 2018-2021 Gavin D. Howard and contributors.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 *
11 * * Redistributions of source code must retain the above copyright notice, this
12 *   list of conditions and the following disclaimer.
13 *
14 * * Redistributions in binary form must reproduce the above copyright notice,
15 *   this list of conditions and the following disclaimer in the documentation
16 *   and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 *
30 * *****************************************************************************
31 *
32 * Definitions for bc.
33 *
34 */
35
36#ifndef BC_BC_H
37#define BC_BC_H
38
39#if BC_ENABLED
40
41#include <limits.h>
42#include <stdbool.h>
43
44#include <status.h>
45#include <lex.h>
46#include <parse.h>
47
48void bc_main(int argc, char **argv);
49
50extern const char bc_help[];
51extern const char bc_lib[];
52extern const char* bc_lib_name;
53
54#if BC_ENABLE_EXTRA_MATH
55extern const char bc_lib2[];
56extern const char* bc_lib2_name;
57#endif // BC_ENABLE_EXTRA_MATH
58
59typedef struct BcLexKeyword {
60	uchar data;
61	const char name[9];
62} BcLexKeyword;
63
64#define BC_LEX_CHAR_MSB(bit) ((bit) << (CHAR_BIT - 1))
65
66#define BC_LEX_KW_POSIX(kw) ((kw)->data & (BC_LEX_CHAR_MSB(1)))
67#define BC_LEX_KW_LEN(kw) ((size_t) ((kw)->data & ~(BC_LEX_CHAR_MSB(1))))
68
69#define BC_LEX_KW_ENTRY(a, b, c) \
70	{ .data = ((b) & ~(BC_LEX_CHAR_MSB(1))) | BC_LEX_CHAR_MSB(c), .name = a }
71
72extern const BcLexKeyword bc_lex_kws[];
73extern const size_t bc_lex_kws_len;
74
75void bc_lex_token(BcLex *l);
76
77#define BC_PARSE_TOP_FLAG_PTR(p) ((uint16_t*) bc_vec_top(&(p)->flags))
78#define BC_PARSE_TOP_FLAG(p) (*(BC_PARSE_TOP_FLAG_PTR(p)))
79
80#define BC_PARSE_FLAG_BRACE (UINTMAX_C(1)<<0)
81#define BC_PARSE_BRACE(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_BRACE)
82
83#define BC_PARSE_FLAG_FUNC_INNER (UINTMAX_C(1)<<1)
84#define BC_PARSE_FUNC_INNER(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_FUNC_INNER)
85
86#define BC_PARSE_FLAG_FUNC (UINTMAX_C(1)<<2)
87#define BC_PARSE_FUNC(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_FUNC)
88
89#define BC_PARSE_FLAG_BODY (UINTMAX_C(1)<<3)
90#define BC_PARSE_BODY(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_BODY)
91
92#define BC_PARSE_FLAG_LOOP (UINTMAX_C(1)<<4)
93#define BC_PARSE_LOOP(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_LOOP)
94
95#define BC_PARSE_FLAG_LOOP_INNER (UINTMAX_C(1)<<5)
96#define BC_PARSE_LOOP_INNER(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_LOOP_INNER)
97
98#define BC_PARSE_FLAG_IF (UINTMAX_C(1)<<6)
99#define BC_PARSE_IF(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_IF)
100
101#define BC_PARSE_FLAG_ELSE (UINTMAX_C(1)<<7)
102#define BC_PARSE_ELSE(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_ELSE)
103
104#define BC_PARSE_FLAG_IF_END (UINTMAX_C(1)<<8)
105#define BC_PARSE_IF_END(p) (BC_PARSE_TOP_FLAG(p) & BC_PARSE_FLAG_IF_END)
106
107#define BC_PARSE_NO_EXEC(p) ((p)->flags.len != 1 || BC_PARSE_TOP_FLAG(p) != 0)
108
109#define BC_PARSE_DELIMITER(t) \
110	((t) == BC_LEX_SCOLON || (t) == BC_LEX_NLINE || (t) == BC_LEX_EOF)
111
112#define BC_PARSE_BLOCK_STMT(f) \
113	((f) & (BC_PARSE_FLAG_ELSE | BC_PARSE_FLAG_LOOP_INNER))
114
115#define BC_PARSE_OP(p, l) (((p) & ~(BC_LEX_CHAR_MSB(1))) | (BC_LEX_CHAR_MSB(l)))
116
117#define BC_PARSE_OP_DATA(t) bc_parse_ops[((t) - BC_LEX_OP_INC)]
118#define BC_PARSE_OP_LEFT(op) (BC_PARSE_OP_DATA(op) & BC_LEX_CHAR_MSB(1))
119#define BC_PARSE_OP_PREC(op) (BC_PARSE_OP_DATA(op) & ~(BC_LEX_CHAR_MSB(1)))
120
121#define BC_PARSE_EXPR_ENTRY(e1, e2, e3, e4, e5, e6, e7, e8)  \
122	((UINTMAX_C(e1) << 7) | (UINTMAX_C(e2) << 6) | (UINTMAX_C(e3) << 5) | \
123	 (UINTMAX_C(e4) << 4) | (UINTMAX_C(e5) << 3) | (UINTMAX_C(e6) << 2) | \
124	 (UINTMAX_C(e7) << 1) | (UINTMAX_C(e8) << 0))
125
126#define BC_PARSE_EXPR(i) \
127	(bc_parse_exprs[(((i) & (uchar) ~(0x07)) >> 3)] & (1 << (7 - ((i) & 0x07))))
128
129#define BC_PARSE_TOP_OP(p) (*((BcLexType*) bc_vec_top(&(p)->ops)))
130#define BC_PARSE_LEAF(prev, bin_last, rparen) \
131	(!(bin_last) && ((rparen) || bc_parse_inst_isLeaf(prev)))
132
133#if BC_ENABLE_EXTRA_MATH && BC_ENABLE_RAND
134#define BC_PARSE_INST_VAR(t) \
135	((t) >= BC_INST_VAR && (t) <= BC_INST_SEED && (t) != BC_INST_ARRAY)
136#else // BC_ENABLE_EXTRA_MATH && BC_ENABLE_RAND
137#define BC_PARSE_INST_VAR(t) \
138	((t) >= BC_INST_VAR && (t) <= BC_INST_SCALE && (t) != BC_INST_ARRAY)
139#endif // BC_ENABLE_EXTRA_MATH && BC_ENABLE_RAND
140
141#define BC_PARSE_PREV_PREFIX(p) \
142	((p) >= BC_INST_NEG && (p) <= BC_INST_BOOL_NOT)
143#define BC_PARSE_OP_PREFIX(t) ((t) == BC_LEX_OP_BOOL_NOT || (t) == BC_LEX_NEG)
144
145// We can calculate the conversion between tokens and exprs by subtracting the
146// position of the first operator in the lex enum and adding the position of
147// the first in the expr enum. Note: This only works for binary operators.
148#define BC_PARSE_TOKEN_INST(t) ((uchar) ((t) - BC_LEX_NEG + BC_INST_NEG))
149
150typedef enum BcParseStatus {
151
152	BC_PARSE_STATUS_SUCCESS,
153	BC_PARSE_STATUS_EMPTY_EXPR,
154
155} BcParseStatus;
156
157void bc_parse_expr(BcParse *p, uint8_t flags);
158
159void bc_parse_parse(BcParse *p);
160void bc_parse_expr_status(BcParse *p, uint8_t flags, BcParseNext next);
161
162extern const char bc_sig_msg[];
163extern const uchar bc_sig_msg_len;
164
165extern const char* const bc_parse_const1;
166extern const uint8_t bc_parse_exprs[];
167extern const uchar bc_parse_ops[];
168extern const BcParseNext bc_parse_next_expr;
169extern const BcParseNext bc_parse_next_param;
170extern const BcParseNext bc_parse_next_print;
171extern const BcParseNext bc_parse_next_rel;
172extern const BcParseNext bc_parse_next_elem;
173extern const BcParseNext bc_parse_next_for;
174extern const BcParseNext bc_parse_next_read;
175
176#else // BC_ENABLED
177
178#define BC_PARSE_NO_EXEC(p) (0)
179
180#endif // BC_ENABLED
181
182#endif // BC_BC_H
183