sys/ddb/db_lex.c

   1 /*-
   2  * SPDX-License-Identifier: MIT-CMU
   3  *
   4  * Mach Operating System
   5  * Copyright (c) 1991,1990 Carnegie Mellon University
   6  * All Rights Reserved.
   7  *
   8  * Permission to use, copy, modify and distribute this software and its
   9  * documentation is hereby granted, provided that both the copyright
  10  * notice and this permission notice appear in all copies of the
  11  * software, derivative works or modified versions, and any portions
  12  * thereof, and that both notices appear in supporting documentation.
  13  *
  14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
  15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  16  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  17  *
  18  * Carnegie Mellon requests users of this software to return to
  19  *
  20  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  21  *  School of Computer Science
  22  *  Carnegie Mellon University
  23  *  Pittsburgh PA 15213-3890
  24  *
  25  * any improvements or extensions that they make and grant Carnegie the
  26  * rights to redistribute these changes.
  27  */
  28 /*
  29  *      Author: David B. Golub, Carnegie Mellon University
  30  *      Date:   7/90
  31  */
  32 /*
  33  * Lexical analyzer.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #include <sys/param.h>
  40 #include <sys/libkern.h>
  41 #include <sys/lock.h>
  42
  43 #include <ddb/ddb.h>
  44 #include <ddb/db_lex.h>
  45
  46 static char     db_line[DB_MAXLINE];
  47 static char *   db_lp, *db_endlp;
  48
  49 static int      db_lex(int);
  50 static void     db_flush_line(void);
  51 static int      db_read_char(void);
  52 static void     db_unread_char(int);
  53
  54 int
  55 db_read_line(void)
  56 {
  57         int     i;
  58
  59         i = db_readline(db_line, sizeof(db_line));
  60         if (i == 0)
  61             return (0); /* EOI */
  62         db_lp = db_line;
  63         db_endlp = db_lp + i;
  64         return (i);
  65 }
  66
  67 /*
  68  * Simulate a line of input into DDB.
  69  */
  70 void
  71 db_inject_line(const char *command)
  72 {
  73
  74         strlcpy(db_line, command, sizeof(db_line));
  75         db_lp = db_line;
  76         db_endlp = db_lp + strlen(command);
  77 }
  78
  79 /*
  80  * In rare cases, we may want to pull the remainder of the line input
  81  * verbatim, rather than lexing it.  For example, when assigning literal
  82  * values associated with scripts.  In that case, return a static pointer to
  83  * the current location in the input buffer.  The caller must be aware that
  84  * the contents are not stable if other lex/input calls are made.
  85  */
  86 char *
  87 db_get_line(void)
  88 {
  89
  90         return (db_lp);
  91 }
  92
  93 static void
  94 db_flush_line()
  95 {
  96         db_lp = db_line;
  97         db_endlp = db_line;
  98 }
  99
 100 static int      db_look_char = 0;
 101
 102 static int
 103 db_read_char(void)
 104 {
 105         int     c;
 106
 107         if (db_look_char != 0) {
 108             c = db_look_char;
 109             db_look_char = 0;
 110         }
 111         else if (db_lp >= db_endlp)
 112             c = -1;
 113         else
 114             c = *db_lp++;
 115         return (c);
 116 }
 117
 118 static void
 119 db_unread_char(c)
 120         int c;
 121 {
 122         db_look_char = c;
 123 }
 124
 125 static int      db_look_token = 0;
 126
 127 void
 128 db_unread_token(int t)
 129 {
 130         db_look_token = t;
 131 }
 132
 133 int
 134 db_read_token_flags(int flags)
 135 {
 136         int     t;
 137
 138         MPASS((flags & ~(DRT_VALID_FLAGS_MASK)) == 0);
 139
 140         if (db_look_token) {
 141             t = db_look_token;
 142             db_look_token = 0;
 143         }
 144         else
 145             t = db_lex(flags);
 146         return (t);
 147 }
 148
 149 db_expr_t       db_tok_number;
 150 char    db_tok_string[TOK_STRING_SIZE];
 151
 152 db_expr_t       db_radix = 16;
 153
 154 void
 155 db_flush_lex(void)
 156 {
 157         db_flush_line();
 158         db_look_char = 0;
 159         db_look_token = 0;
 160 }
 161
 162 static int
 163 db_lex(int flags)
 164 {
 165         int     c, n, radix_mode;
 166         bool    lex_wspace;
 167
 168         switch (flags & DRT_RADIX_MASK) {
 169         case DRT_DEFAULT_RADIX:
 170                 radix_mode = -1;
 171                 break;
 172         case DRT_OCTAL:
 173                 radix_mode = 8;
 174                 break;
 175         case DRT_DECIMAL:
 176                 radix_mode = 10;
 177                 break;
 178         case DRT_HEXADECIMAL:
 179                 radix_mode = 16;
 180                 break;
 181         }
 182
 183         lex_wspace = ((flags & DRT_WSPACE) != 0);
 184
 185         c = db_read_char();
 186         for (n = 0; c <= ' ' || c > '~'; n++) {
 187             if (c == '\n' || c == -1)
 188                 return (tEOL);
 189             c = db_read_char();
 190         }
 191         if (lex_wspace && n != 0) {
 192             db_unread_char(c);
 193             return (tWSPACE);
 194         }
 195
 196         if (c >= '0' && c <= '9') {
 197             /* number */
 198             int r, digit = 0;
 199
 200             if (radix_mode != -1)
 201                 r = radix_mode;
 202             else if (c > '0')
 203                 r = db_radix;
 204             else {
 205                 c = db_read_char();
 206                 if (c == 'O' || c == 'o')
 207                     r = 8;
 208                 else if (c == 'T' || c == 't')
 209                     r = 10;
 210                 else if (c == 'X' || c == 'x')
 211                     r = 16;
 212                 else {
 213                     r = db_radix;
 214                     db_unread_char(c);
 215                 }
 216                 c = db_read_char();
 217             }
 218             db_tok_number = 0;
 219             for (;;) {
 220                 if (c >= '0' && c <= ((r == 8) ? '7' : '9'))
 221                     digit = c - '0';
 222                 else if (r == 16 && ((c >= 'A' && c <= 'F') ||
 223                                      (c >= 'a' && c <= 'f'))) {
 224                     if (c >= 'a')
 225                         digit = c - 'a' + 10;
 226                     else if (c >= 'A')
 227                         digit = c - 'A' + 10;
 228                 }
 229                 else
 230                     break;
 231                 db_tok_number = db_tok_number * r + digit;
 232                 c = db_read_char();
 233             }
 234             if ((c >= '0' && c <= '9') ||
 235                 (c >= 'A' && c <= 'Z') ||
 236                 (c >= 'a' && c <= 'z') ||
 237                 (c == '_'))
 238             {
 239                 db_error("Bad character in number\n");
 240                 db_flush_lex();
 241                 return (tEOF);
 242             }
 243             db_unread_char(c);
 244             return (tNUMBER);
 245         }
 246         if ((c >= 'A' && c <= 'Z') ||
 247             (c >= 'a' && c <= 'z') ||
 248             c == '_' || c == '\\')
 249         {
 250             /* string */
 251             char *cp;
 252
 253             cp = db_tok_string;
 254             if (c == '\\') {
 255                 c = db_read_char();
 256                 if (c == '\n' || c == -1)
 257                     db_error("Bad escape\n");
 258             }
 259             *cp++ = c;
 260             while (1) {
 261                 c = db_read_char();
 262                 if ((c >= 'A' && c <= 'Z') ||
 263                     (c >= 'a' && c <= 'z') ||
 264                     (c >= '0' && c <= '9') ||
 265                     c == '_' || c == '\\' || c == ':' || c == '.')
 266                 {
 267                     if (c == '\\') {
 268                         c = db_read_char();
 269                         if (c == '\n' || c == -1)
 270                             db_error("Bad escape\n");
 271                     }
 272                     *cp++ = c;
 273                     if (cp == db_tok_string+sizeof(db_tok_string)) {
 274                         db_error("String too long\n");
 275                         db_flush_lex();
 276                         return (tEOF);
 277                     }
 278                     continue;
 279                 }
 280                 else {
 281                     *cp = '\0';
 282                     break;
 283                 }
 284             }
 285             db_unread_char(c);
 286             return (tIDENT);
 287         }
 288
 289         switch (c) {
 290             case '+':
 291                 return (tPLUS);
 292             case '-':
 293                 return (tMINUS);
 294             case '.':
 295                 c = db_read_char();
 296                 if (c == '.')
 297                     return (tDOTDOT);
 298                 db_unread_char(c);
 299                 return (tDOT);
 300             case '*':
 301                 return (tSTAR);
 302             case '/':
 303                 return (tSLASH);
 304             case '=':
 305                 c = db_read_char();
 306                 if (c == '=')
 307                     return (tLOG_EQ);
 308                 db_unread_char(c);
 309                 return (tEQ);
 310             case '%':
 311                 return (tPCT);
 312             case '#':
 313                 return (tHASH);
 314             case '(':
 315                 return (tLPAREN);
 316             case ')':
 317                 return (tRPAREN);
 318             case ',':
 319                 return (tCOMMA);
 320             case '"':
 321                 return (tDITTO);
 322             case '$':
 323                 return (tDOLLAR);
 324             case '!':
 325                 c = db_read_char();
 326                 if (c == '='){
 327                         return (tLOG_NOT_EQ);
 328                 }
 329                 db_unread_char(c);
 330                 return (tEXCL);
 331             case ';':
 332                 return (tSEMI);
 333             case '&':
 334                 c = db_read_char();
 335                 if (c == '&')
 336                     return (tLOG_AND);
 337                 db_unread_char(c);
 338                 return (tBIT_AND);
 339             case '|':
 340                 c = db_read_char();
 341                 if (c == '|')
 342                     return (tLOG_OR);
 343                 db_unread_char(c);
 344                 return (tBIT_OR);
 345             case '<':
 346                 c = db_read_char();
 347                 if (c == '<')
 348                     return (tSHIFT_L);
 349                 if (c == '=')
 350                     return (tLESS_EQ);
 351                 db_unread_char(c);
 352                 return (tLESS);
 353             case '>':
 354                 c = db_read_char();
 355                 if (c == '>')
 356                     return (tSHIFT_R);
 357                 if (c == '=')
 358                     return (tGREATER_EQ);
 359                 db_unread_char(c);
 360                 return (tGREATER);
 361             case '?':
 362                 return (tQUESTION);
 363             case '~':
 364                 return (tBIT_NOT);
 365             case -1:
 366                 return (tEOF);
 367         }
 368         db_printf("Bad character\n");
 369         db_flush_lex();
 370         return (tEOF);
 371 }