contrib/bc/src/dc_lex.c

   1 /*
   2  * *****************************************************************************
   3  *
   4  * SPDX-License-Identifier: BSD-2-Clause
   5  *
   6  * Copyright (c) 2018-2021 Gavin D. Howard and contributors.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * * Redistributions of source code must retain the above copyright notice, this
  12  *   list of conditions and the following disclaimer.
  13  *
  14  * * Redistributions in binary form must reproduce the above copyright notice,
  15  *   this list of conditions and the following disclaimer in the documentation
  16  *   and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * *****************************************************************************
  31  *
  32  * The lexer for dc.
  33  *
  34  */
  35
  36 #if DC_ENABLED
  37
  38 #include <ctype.h>
  39
  40 #include <dc.h>
  41 #include <vm.h>
  42
  43 bool
  44 dc_lex_negCommand(BcLex* l)
  45 {
  46         char c = l->buf[l->i];
  47         return !BC_LEX_NUM_CHAR(c, false, false);
  48 }
  49
  50 /**
  51  * Processes a dc command that needs a register. This is where the
  52  * extended-register extension is implemented.
  53  * @param l  The lexer.
  54  */
  55 static void
  56 dc_lex_register(BcLex* l)
  57 {
  58         // If extended register is enabled and the character is whitespace...
  59         if (DC_X && isspace(l->buf[l->i - 1]))
  60         {
  61                 char c;
  62
  63                 // Eat the whitespace.
  64                 bc_lex_whitespace(l);
  65                 c = l->buf[l->i];
  66
  67                 // Check for a letter or underscore.
  68                 if (BC_ERR(!isalpha(c) && c != '_'))
  69                 {
  70                         bc_lex_verr(l, BC_ERR_PARSE_CHAR, c);
  71                 }
  72
  73                 // Parse a normal identifier.
  74                 l->i += 1;
  75                 bc_lex_name(l);
  76         }
  77         else
  78         {
  79                 // I don't allow newlines because newlines are used for controlling when
  80                 // execution happens, and allowing newlines would just be complex.
  81                 if (BC_ERR(l->buf[l->i - 1] == '\n'))
  82                 {
  83                         bc_lex_verr(l, BC_ERR_PARSE_CHAR, l->buf[l->i - 1]);
  84                 }
  85
  86                 // Set the lexer string and token.
  87                 bc_vec_popAll(&l->str);
  88                 bc_vec_pushByte(&l->str, (uchar) l->buf[l->i - 1]);
  89                 bc_vec_pushByte(&l->str, '\0');
  90                 l->t = BC_LEX_NAME;
  91         }
  92 }
  93
  94 /**
  95  * Parses a dc string. Since dc's strings need to check for balanced brackets,
  96  * we can't just parse bc and dc strings with different start and end
  97  * characters. Oh, and dc strings need to check for escaped brackets.
  98  * @param l  The lexer.
  99  */
 100 static void
 101 dc_lex_string(BcLex* l)
 102 {
 103         size_t depth, nls, i;
 104         char c;
 105         bool got_more;
 106
 107         // Set the token and clear the string.
 108         l->t = BC_LEX_STR;
 109         bc_vec_popAll(&l->str);
 110
 111         do
 112         {
 113                 depth = 1;
 114                 nls = 0;
 115                 got_more = false;
 116
 117                 assert(!l->is_stdin || l->buf == vm.buffer.v);
 118
 119                 // This is the meat. As long as we don't run into the NUL byte, and we
 120                 // have "depth", which means we haven't completely balanced brackets
 121                 // yet, we continue eating the string.
 122                 for (i = l->i; (c = l->buf[i]) && depth; ++i)
 123                 {
 124                         // Check for escaped brackets and set the depths as appropriate.
 125                         if (c == '\\')
 126                         {
 127                                 c = l->buf[++i];
 128                                 if (!c) break;
 129                         }
 130                         else
 131                         {
 132                                 depth += (c == '[');
 133                                 depth -= (c == ']');
 134                         }
 135
 136                         // We want to adjust the line in the lexer as necessary.
 137                         nls += (c == '\n');
 138
 139                         if (depth) bc_vec_push(&l->str, &c);
 140                 }
 141
 142                 if (BC_ERR(c == '\0' && depth))
 143                 {
 144                         if (!vm.eof && (l->is_stdin || l->is_exprs))
 145                         {
 146                                 got_more = bc_lex_readLine(l);
 147                         }
 148                         if (got_more) bc_vec_popAll(&l->str);
 149                 }
 150         }
 151         while (got_more && depth);
 152
 153         // Obviously, if we didn't balance, that's an error.
 154         if (BC_ERR(c == '\0' && depth))
 155         {
 156                 l->i = i;
 157                 bc_lex_err(l, BC_ERR_PARSE_STRING);
 158         }
 159
 160         bc_vec_pushByte(&l->str, '\0');
 161
 162         l->i = i;
 163         l->line += nls;
 164 }
 165
 166 /**
 167  * Lexes a dc token. This is the dc implementation of BcLexNext.
 168  * @param l  The lexer.
 169  */
 170 void
 171 dc_lex_token(BcLex* l)
 172 {
 173         char c = l->buf[l->i++], c2;
 174         size_t i;
 175
 176         BC_SIG_ASSERT_LOCKED;
 177
 178         // If the last token was a command that needs a register, we need to parse a
 179         // register, so do so.
 180         for (i = 0; i < dc_lex_regs_len; ++i)
 181         {
 182                 // If the token is a register token, take care of it and return.
 183                 if (l->last == dc_lex_regs[i])
 184                 {
 185                         dc_lex_register(l);
 186                         return;
 187                 }
 188         }
 189
 190         // These lines are for tokens that easily correspond to one character. We
 191         // just set the token.
 192         if (c >= '"' && c <= '~' &&
 193             (l->t = dc_lex_tokens[(c - '"')]) != BC_LEX_INVALID)
 194         {
 195                 return;
 196         }
 197
 198         // This is the workhorse of the lexer when more complicated things are
 199         // needed.
 200         switch (c)
 201         {
 202                 case '\0':
 203                 case '\n':
 204                 case '\t':
 205                 case '\v':
 206                 case '\f':
 207                 case '\r':
 208                 case ' ':
 209                 {
 210                         bc_lex_commonTokens(l, c);
 211                         break;
 212                 }
 213
 214                 // We don't have the ! command, so we always expect certain things
 215                 // after the exclamation point.
 216                 case '!':
 217                 {
 218                         c2 = l->buf[l->i];
 219
 220                         if (c2 == '=') l->t = BC_LEX_OP_REL_NE;
 221                         else if (c2 == '<') l->t = BC_LEX_OP_REL_LE;
 222                         else if (c2 == '>') l->t = BC_LEX_OP_REL_GE;
 223                         else bc_lex_invalidChar(l, c);
 224
 225                         l->i += 1;
 226
 227                         break;
 228                 }
 229
 230                 case '#':
 231                 {
 232                         bc_lex_lineComment(l);
 233                         break;
 234                 }
 235
 236                 case '.':
 237                 {
 238                         c2 = l->buf[l->i];
 239
 240                         // If the character after is a number, this dot is part of a number.
 241                         // Otherwise, it's the BSD dot (equivalent to last).
 242                         if (BC_NO_ERR(BC_LEX_NUM_CHAR(c2, true, false)))
 243                         {
 244                                 bc_lex_number(l, c);
 245                         }
 246                         else bc_lex_invalidChar(l, c);
 247
 248                         break;
 249                 }
 250
 251                 case '0':
 252                 case '1':
 253                 case '2':
 254                 case '3':
 255                 case '4':
 256                 case '5':
 257                 case '6':
 258                 case '7':
 259                 case '8':
 260                 case '9':
 261                 case 'A':
 262                 case 'B':
 263                 case 'C':
 264                 case 'D':
 265                 case 'E':
 266                 case 'F':
 267                 {
 268                         bc_lex_number(l, c);
 269                         break;
 270                 }
 271
 272                 case 'g':
 273                 {
 274                         c2 = l->buf[l->i];
 275
 276                         if (c2 == 'l') l->t = BC_LEX_KW_LINE_LENGTH;
 277                         else if (c2 == 'z') l->t = BC_LEX_KW_LEADING_ZERO;
 278                         else bc_lex_invalidChar(l, c2);
 279
 280                         l->i += 1;
 281
 282                         break;
 283                 }
 284
 285                 case '[':
 286                 {
 287                         dc_lex_string(l);
 288                         break;
 289                 }
 290
 291                 default:
 292                 {
 293                         bc_lex_invalidChar(l, c);
 294                 }
 295         }
 296 }
 297 #endif // DC_ENABLED