Gavin Howard | 5715b04 | 2018-02-12 16:11:42 -0700 | [diff] [blame] | 1 | /* |
Gavin Howard | b5904bf | 2018-02-20 13:28:18 -0700 | [diff] [blame] | 2 | * ***************************************************************************** |
Gavin Howard | 5715b04 | 2018-02-12 16:11:42 -0700 | [diff] [blame] | 3 | * |
Gavin Howard | b5904bf | 2018-02-20 13:28:18 -0700 | [diff] [blame] | 4 | * Copyright 2018 Gavin D. Howard |
Gavin Howard | 5715b04 | 2018-02-12 16:11:42 -0700 | [diff] [blame] | 5 | * |
| 6 | * Permission to use, copy, modify, and/or distribute this software for any |
| 7 | * purpose with or without fee is hereby granted. |
| 8 | * |
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH |
| 10 | * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
| 11 | * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, |
| 12 | * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM |
| 13 | * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR |
| 14 | * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| 15 | * PERFORMANCE OF THIS SOFTWARE. |
| 16 | * |
Gavin Howard | b5904bf | 2018-02-20 13:28:18 -0700 | [diff] [blame] | 17 | * ***************************************************************************** |
Gavin Howard | 5715b04 | 2018-02-12 16:11:42 -0700 | [diff] [blame] | 18 | * |
Gavin Howard | d2a0525 | 2018-09-27 14:00:40 -0600 | [diff] [blame] | 19 | * Common code for the lexers. |
Gavin Howard | 5715b04 | 2018-02-12 16:11:42 -0700 | [diff] [blame] | 20 | * |
| 21 | */ |
| 22 | |
Gavin Howard | 27fdfb9 | 2018-03-21 07:56:59 -0600 | [diff] [blame] | 23 | #include <assert.h> |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 24 | #include <ctype.h> |
| 25 | #include <stdbool.h> |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 26 | #include <string.h> |
| 27 | |
Gavin Howard | 2949306 | 2018-03-20 19:57:37 -0600 | [diff] [blame] | 28 | #include <status.h> |
Gavin Howard | 3ba6c8d | 2018-02-15 12:23:35 -0700 | [diff] [blame] | 29 | #include <lex.h> |
Gavin Howard | d555167 | 2018-09-22 19:52:42 -0600 | [diff] [blame] | 30 | #include <vm.h> |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 31 | |
Gavin Howard | 50c8c2d | 2018-12-27 11:58:34 -0700 | [diff] [blame] | 32 | BcStatus bc_lex_invalidChar(BcLex *l, char c) { |
| 33 | l->t = BC_LEX_INVALID; |
Gavin Howard | 03cd112 | 2018-12-31 14:08:15 -0700 | [diff] [blame] | 34 | return bc_lex_verr(l, BC_ERROR_PARSE_CHAR, c); |
Gavin Howard | 50c8c2d | 2018-12-27 11:58:34 -0700 | [diff] [blame] | 35 | } |
| 36 | |
Gavin Howard | ed5c831 | 2018-09-27 12:04:08 -0600 | [diff] [blame] | 37 | void bc_lex_lineComment(BcLex *l) { |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 38 | l->t = BC_LEX_WHITESPACE; |
Gavin Howard | 5c14da6 | 2019-02-16 23:47:48 -0700 | [diff] [blame] | 39 | while (l->i < l->len && l->buf[l->i] != '\n') l->i += 1; |
Gavin Howard | ed5c831 | 2018-09-27 12:04:08 -0600 | [diff] [blame] | 40 | } |
| 41 | |
Gavin Howard | 52446f2 | 2018-12-13 11:39:22 -0700 | [diff] [blame] | 42 | BcStatus bc_lex_comment(BcLex *l) { |
| 43 | |
| 44 | size_t i, nlines = 0; |
| 45 | const char *buf = l->buf; |
| 46 | bool end = false; |
| 47 | char c; |
| 48 | |
Gavin Howard | 5c14da6 | 2019-02-16 23:47:48 -0700 | [diff] [blame] | 49 | l->i += 1; |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 50 | l->t = BC_LEX_WHITESPACE; |
Gavin Howard | 52446f2 | 2018-12-13 11:39:22 -0700 | [diff] [blame] | 51 | |
Gavin Howard | 5c14da6 | 2019-02-16 23:47:48 -0700 | [diff] [blame] | 52 | for (i = l->i; !end; i += !end) { |
Gavin Howard | 52446f2 | 2018-12-13 11:39:22 -0700 | [diff] [blame] | 53 | |
Gavin Howard | 1ab22d2 | 2019-01-03 13:32:17 -0700 | [diff] [blame] | 54 | for (; (c = buf[i]) && c != '*'; ++i) nlines += (c == '\n'); |
Gavin Howard | 52446f2 | 2018-12-13 11:39:22 -0700 | [diff] [blame] | 55 | |
Gavin Howard | 1ab22d2 | 2019-01-03 13:32:17 -0700 | [diff] [blame] | 56 | if (!c || buf[i + 1] == '\0') { |
Gavin Howard | 52446f2 | 2018-12-13 11:39:22 -0700 | [diff] [blame] | 57 | l->i = i; |
Gavin Howard | 03cd112 | 2018-12-31 14:08:15 -0700 | [diff] [blame] | 58 | return bc_lex_err(l, BC_ERROR_PARSE_COMMENT); |
Gavin Howard | 52446f2 | 2018-12-13 11:39:22 -0700 | [diff] [blame] | 59 | } |
| 60 | |
| 61 | end = buf[i + 1] == '/'; |
| 62 | } |
| 63 | |
| 64 | l->i = i + 2; |
| 65 | l->line += nlines; |
| 66 | |
| 67 | return BC_STATUS_SUCCESS; |
| 68 | } |
| 69 | |
Gavin Howard | 364df3b | 2018-09-28 09:48:19 -0600 | [diff] [blame] | 70 | void bc_lex_whitespace(BcLex *l) { |
| 71 | char c; |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 72 | l->t = BC_LEX_WHITESPACE; |
Gavin Howard | 53eba8b | 2018-10-31 15:14:37 -0600 | [diff] [blame] | 73 | for (c = l->buf[l->i]; c != '\n' && isspace(c); c = l->buf[++l->i]); |
Gavin Howard | 364df3b | 2018-09-28 09:48:19 -0600 | [diff] [blame] | 74 | } |
| 75 | |
Gavin Howard | 3ae1f8e | 2019-02-15 11:56:25 -0700 | [diff] [blame] | 76 | void bc_lex_commonTokens(BcLex *l, char c) { |
| 77 | if (!c) l->t = BC_LEX_EOF; |
| 78 | else if (c == '\n') l->t = BC_LEX_NLINE; |
| 79 | else bc_lex_whitespace(l); |
| 80 | } |
| 81 | |
Gavin Howard | 7ad5a66 | 2019-02-19 14:40:46 -0700 | [diff] [blame^] | 82 | static size_t bc_lex_num(BcLex *l, char start, bool int_only) { |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 83 | |
Gavin Howard | 53eba8b | 2018-10-31 15:14:37 -0600 | [diff] [blame] | 84 | const char *buf = l->buf + l->i; |
Gavin Howard | 8dd307e | 2019-01-08 23:05:19 -0700 | [diff] [blame] | 85 | size_t i; |
Gavin Howard | 7ad5a66 | 2019-02-19 14:40:46 -0700 | [diff] [blame^] | 86 | char c; |
Gavin Howard | 94f1410 | 2019-01-11 09:39:57 -0700 | [diff] [blame] | 87 | bool last_pt, pt = (start == '.'); |
Gavin Howard | f2a4049 | 2018-03-05 11:27:29 -0700 | [diff] [blame] | 88 | |
Gavin Howard | 7ad5a66 | 2019-02-19 14:40:46 -0700 | [diff] [blame^] | 89 | for (i = 0; (c = buf[i]) && (BC_LEX_NUM_CHAR(c, pt, int_only) || |
Gavin Howard | 8dd307e | 2019-01-08 23:05:19 -0700 | [diff] [blame] | 90 | (c == '\\' && buf[i + 1] == '\n')); ++i) |
| 91 | { |
Gavin Howard | 25f6088 | 2019-01-11 09:20:51 -0700 | [diff] [blame] | 92 | if (c == '\\') { |
| 93 | |
| 94 | if (buf[i + 1] == '\n') { |
| 95 | |
| 96 | i += 2; |
| 97 | |
| 98 | // Make sure to eat whitespace at the beginning of the line. |
Gavin Howard | 7ad5a66 | 2019-02-19 14:40:46 -0700 | [diff] [blame^] | 99 | while(isspace(buf[i]) && buf[i] != '\n') i += 1; |
Gavin Howard | 25f6088 | 2019-01-11 09:20:51 -0700 | [diff] [blame] | 100 | |
| 101 | c = buf[i]; |
| 102 | |
Gavin Howard | 7ad5a66 | 2019-02-19 14:40:46 -0700 | [diff] [blame^] | 103 | if (!BC_LEX_NUM_CHAR(c, pt, int_only)) break; |
Gavin Howard | 25f6088 | 2019-01-11 09:20:51 -0700 | [diff] [blame] | 104 | } |
| 105 | else break; |
Gavin Howard | 6373820 | 2018-09-26 15:34:20 -0600 | [diff] [blame] | 106 | } |
Gavin Howard | 8dd307e | 2019-01-08 23:05:19 -0700 | [diff] [blame] | 107 | |
Gavin Howard | 94f1410 | 2019-01-11 09:39:57 -0700 | [diff] [blame] | 108 | last_pt = (c == '.'); |
Gavin Howard | 25f6088 | 2019-01-11 09:20:51 -0700 | [diff] [blame] | 109 | if (pt && last_pt) break; |
Gavin Howard | 94f1410 | 2019-01-11 09:39:57 -0700 | [diff] [blame] | 110 | pt = pt || last_pt; |
Gavin Howard | 07732ec | 2018-02-27 15:40:02 -0700 | [diff] [blame] | 111 | |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 112 | bc_vec_push(&l->str, &c); |
Gavin Howard | 6373820 | 2018-09-26 15:34:20 -0600 | [diff] [blame] | 113 | } |
Gavin Howard | 07732ec | 2018-02-27 15:40:02 -0700 | [diff] [blame] | 114 | |
Gavin Howard | 7ad5a66 | 2019-02-19 14:40:46 -0700 | [diff] [blame^] | 115 | return i; |
| 116 | } |
| 117 | |
| 118 | BcStatus bc_lex_number(BcLex *l, char start) { |
| 119 | |
| 120 | l->t = BC_LEX_NUMBER; |
| 121 | |
| 122 | bc_vec_npop(&l->str, l->str.len); |
| 123 | bc_vec_push(&l->str, &start); |
| 124 | |
| 125 | l->i += bc_lex_num(l, start, false); |
| 126 | #if BC_ENABLE_EXTRA_MATH |
| 127 | { |
| 128 | char c = l->buf[l->i]; |
| 129 | |
| 130 | if (c == 'e') { |
| 131 | |
| 132 | bc_vec_push(&l->str, &c); |
| 133 | l->i += 1; |
| 134 | c = l->buf[l->i]; |
| 135 | |
| 136 | if (c == BC_LEX_NEG_CHAR) { |
| 137 | bc_vec_push(&l->str, &c); |
| 138 | l->i += 1; |
| 139 | c = l->buf[l->i]; |
| 140 | } |
| 141 | |
| 142 | if (!BC_LEX_NUM_CHAR(c, false, true)) |
| 143 | return bc_lex_verr(l, BC_ERROR_PARSE_CHAR, c); |
| 144 | |
| 145 | l->i += bc_lex_num(l, 0, true); |
| 146 | } |
| 147 | } |
| 148 | #endif // BC_ENABLE_EXTRA_MATH |
| 149 | |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 150 | bc_vec_pushByte(&l->str, '\0'); |
Gavin Howard | 7ad5a66 | 2019-02-19 14:40:46 -0700 | [diff] [blame^] | 151 | |
| 152 | return BC_STATUS_SUCCESS; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 153 | } |
| 154 | |
Gavin Howard | 5c14da6 | 2019-02-16 23:47:48 -0700 | [diff] [blame] | 155 | void bc_lex_name(BcLex *l) { |
Gavin Howard | 8412ba8 | 2018-10-04 13:03:24 -0600 | [diff] [blame] | 156 | |
Gavin Howard | 88c2530 | 2018-10-17 13:32:23 -0600 | [diff] [blame] | 157 | size_t i = 0; |
Gavin Howard | 53eba8b | 2018-10-31 15:14:37 -0600 | [diff] [blame] | 158 | const char *buf = l->buf + l->i - 1; |
Gavin Howard | 88c2530 | 2018-10-17 13:32:23 -0600 | [diff] [blame] | 159 | char c = buf[i]; |
Gavin Howard | 8412ba8 | 2018-10-04 13:03:24 -0600 | [diff] [blame] | 160 | |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 161 | l->t = BC_LEX_NAME; |
Gavin Howard | 8412ba8 | 2018-10-04 13:03:24 -0600 | [diff] [blame] | 162 | |
Gavin Howard | 9a4b6cd | 2018-10-23 15:13:30 -0600 | [diff] [blame] | 163 | while ((c >= 'a' && c <= 'z') || isdigit(c) || c == '_') c = buf[++i]; |
Gavin Howard | 8412ba8 | 2018-10-04 13:03:24 -0600 | [diff] [blame] | 164 | |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 165 | bc_vec_string(&l->str, i, buf); |
Gavin Howard | 8412ba8 | 2018-10-04 13:03:24 -0600 | [diff] [blame] | 166 | |
| 167 | // Increment the index. We minus 1 because it has already been incremented. |
Gavin Howard | 53eba8b | 2018-10-31 15:14:37 -0600 | [diff] [blame] | 168 | l->i += i - 1; |
Gavin Howard | 8412ba8 | 2018-10-04 13:03:24 -0600 | [diff] [blame] | 169 | } |
| 170 | |
Gavin Howard | 48354e8 | 2019-01-02 18:15:56 -0700 | [diff] [blame] | 171 | void bc_lex_init(BcLex *l) { |
Gavin Howard | 6373820 | 2018-09-26 15:34:20 -0600 | [diff] [blame] | 172 | assert(l); |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 173 | bc_vec_init(&l->str, sizeof(char), NULL); |
Gavin Howard | 6918504 | 2018-09-10 15:46:20 -0600 | [diff] [blame] | 174 | } |
| 175 | |
Gavin Howard | 6373820 | 2018-09-26 15:34:20 -0600 | [diff] [blame] | 176 | void bc_lex_free(BcLex *l) { |
| 177 | assert(l); |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 178 | bc_vec_free(&l->str); |
Gavin Howard | 6918504 | 2018-09-10 15:46:20 -0600 | [diff] [blame] | 179 | } |
| 180 | |
Gavin Howard | 6373820 | 2018-09-26 15:34:20 -0600 | [diff] [blame] | 181 | void bc_lex_file(BcLex *l, const char *file) { |
| 182 | assert(l && file); |
| 183 | l->line = 1; |
Gavin Howard | 7536dcf | 2018-12-15 19:27:09 -0700 | [diff] [blame] | 184 | vm->file = file; |
Gavin Howard | 8a596d4 | 2018-01-15 15:46:01 -0700 | [diff] [blame] | 185 | } |
| 186 | |
Gavin Howard | 364df3b | 2018-09-28 09:48:19 -0600 | [diff] [blame] | 187 | BcStatus bc_lex_next(BcLex *l) { |
| 188 | |
| 189 | BcStatus s; |
| 190 | |
| 191 | assert(l); |
| 192 | |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 193 | l->last = l->t; |
Gavin Howard | 5615879 | 2019-01-14 12:03:14 -0700 | [diff] [blame] | 194 | l->line += (l->i != 0 && l->buf[l->i - 1] == '\n'); |
Gavin Howard | 7536dcf | 2018-12-15 19:27:09 -0700 | [diff] [blame] | 195 | |
Gavin Howard | 03cd112 | 2018-12-31 14:08:15 -0700 | [diff] [blame] | 196 | if (l->last == BC_LEX_EOF) return bc_lex_err(l, BC_ERROR_PARSE_EOF); |
Gavin Howard | 364df3b | 2018-09-28 09:48:19 -0600 | [diff] [blame] | 197 | |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 198 | l->t = BC_LEX_EOF; |
Gavin Howard | c39fd49 | 2018-10-04 10:07:03 -0600 | [diff] [blame] | 199 | |
Gavin Howard | f9b86ee | 2018-12-28 13:18:27 -0700 | [diff] [blame] | 200 | if (l->i == l->len) return BC_STATUS_SUCCESS; |
Gavin Howard | 364df3b | 2018-09-28 09:48:19 -0600 | [diff] [blame] | 201 | |
Gavin Howard | 364df3b | 2018-09-28 09:48:19 -0600 | [diff] [blame] | 202 | // Loop until failure or we don't have whitespace. This |
| 203 | // is so the parser doesn't get inundated with whitespace. |
Gavin Howard | 53eba8b | 2018-10-31 15:14:37 -0600 | [diff] [blame] | 204 | do { |
Gavin Howard | 48354e8 | 2019-01-02 18:15:56 -0700 | [diff] [blame] | 205 | s = vm->next(l); |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 206 | } while (!s && l->t == BC_LEX_WHITESPACE); |
Gavin Howard | 364df3b | 2018-09-28 09:48:19 -0600 | [diff] [blame] | 207 | |
| 208 | return s; |
Gavin Howard | 3575392 | 2018-03-21 19:22:08 -0600 | [diff] [blame] | 209 | } |
Gavin Howard | c9a9c47 | 2018-10-02 17:23:01 -0600 | [diff] [blame] | 210 | |
| 211 | BcStatus bc_lex_text(BcLex *l, const char *text) { |
| 212 | assert(l && text); |
Gavin Howard | 890d0c0 | 2018-10-30 16:34:50 -0600 | [diff] [blame] | 213 | l->buf = text; |
Gavin Howard | 53eba8b | 2018-10-31 15:14:37 -0600 | [diff] [blame] | 214 | l->i = 0; |
Gavin Howard | c9a9c47 | 2018-10-02 17:23:01 -0600 | [diff] [blame] | 215 | l->len = strlen(text); |
Gavin Howard | ad47731 | 2018-12-24 15:51:35 -0700 | [diff] [blame] | 216 | l->t = l->last = BC_LEX_INVALID; |
Gavin Howard | c9a9c47 | 2018-10-02 17:23:01 -0600 | [diff] [blame] | 217 | return bc_lex_next(l); |
| 218 | } |