freebsd-dev/sys/ddb/db_lex.c
Ryan Libby d8404b7ec3 ddb: just move cursor when the lexer backs up
Get rid of db_look_char because it's not compatible with db_get_line().
This fixes the following issue:

db> script lockinfo=show alllocks
db> run lockinfo
db:0:lockinfo> how alllocks
No such command; use "help" to list available commands

Reported by:	markj
Reviewed by:	markj
Sponsored by:	Dell EMC Isilon
Differential Revision:	https://reviews.freebsd.org/D28725
2021-02-24 15:56:16 -08:00

387 lines
7.4 KiB
C

/*-
* SPDX-License-Identifier: MIT-CMU
*
* Mach Operating System
* Copyright (c) 1991,1990 Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
/*
* Author: David B. Golub, Carnegie Mellon University
* Date: 7/90
*/
/*
* Lexical analyzer.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/libkern.h>
#include <sys/lock.h>
#include <ddb/ddb.h>
#include <ddb/db_lex.h>
static char db_line[DB_MAXLINE];
static char * db_lp, *db_endlp;
static int db_lex(int);
static void db_flush_line(void);
static int db_read_char(void);
static void db_unread_char(int);
int
db_read_line(void)
{
int i;
i = db_readline(db_line, sizeof(db_line));
if (i == 0)
return (0); /* EOI */
db_lp = db_line;
db_endlp = db_lp + i;
return (i);
}
/*
* Simulate a line of input into DDB.
*/
void
db_inject_line(const char *command)
{
strlcpy(db_line, command, sizeof(db_line));
db_lp = db_line;
db_endlp = db_lp + strlen(command);
}
/*
* In rare cases, we may want to pull the remainder of the line input
* verbatim, rather than lexing it. For example, when assigning literal
* values associated with scripts. In that case, return a static pointer to
* the current location in the input buffer. The caller must be aware that
* the contents are not stable if other lex/input calls are made.
*/
char *
db_get_line(void)
{
return (db_lp);
}
static void
db_flush_line()
{
db_lp = db_line;
db_endlp = db_line;
}
static int
db_read_char(void)
{
int c;
if (db_lp >= db_endlp)
c = -1;
else
c = *db_lp++;
return (c);
}
static void
db_unread_char(int c)
{
if (c == -1) {
/* Unread EOL at EOL is okay. */
if (db_lp < db_endlp)
db_error("db_unread_char(-1) before end of line\n");
} else {
if (db_lp > db_line) {
db_lp--;
if (*db_lp != c)
db_error("db_unread_char() wrong char\n");
} else {
db_error("db_unread_char() at beginning of line\n");
}
}
}
static int db_look_token = 0;
void
db_unread_token(int t)
{
db_look_token = t;
}
int
db_read_token_flags(int flags)
{
int t;
MPASS((flags & ~(DRT_VALID_FLAGS_MASK)) == 0);
if (db_look_token) {
t = db_look_token;
db_look_token = 0;
}
else
t = db_lex(flags);
return (t);
}
db_expr_t db_tok_number;
char db_tok_string[TOK_STRING_SIZE];
db_expr_t db_radix = 16;
void
db_flush_lex(void)
{
db_flush_line();
db_look_token = 0;
}
static int
db_lex(int flags)
{
int c, n, radix_mode;
bool lex_wspace, lex_hex_numbers;
switch (flags & DRT_RADIX_MASK) {
case DRT_DEFAULT_RADIX:
radix_mode = -1;
break;
case DRT_OCTAL:
radix_mode = 8;
break;
case DRT_DECIMAL:
radix_mode = 10;
break;
case DRT_HEXADECIMAL:
radix_mode = 16;
break;
}
lex_wspace = ((flags & DRT_WSPACE) != 0);
lex_hex_numbers = ((flags & DRT_HEX) != 0);
c = db_read_char();
for (n = 0; c <= ' ' || c > '~'; n++) {
if (c == '\n' || c == -1)
return (tEOL);
c = db_read_char();
}
if (lex_wspace && n != 0) {
db_unread_char(c);
return (tWSPACE);
}
if ((c >= '0' && c <= '9') ||
(lex_hex_numbers &&
((c >= 'a' && c <= 'f') ||
(c >= 'A' && c <= 'F')))) {
/* number */
int r, digit = 0;
if (radix_mode != -1)
r = radix_mode;
else if (c != '0')
r = db_radix;
else {
c = db_read_char();
if (c == 'O' || c == 'o')
r = 8;
else if (c == 'T' || c == 't')
r = 10;
else if (c == 'X' || c == 'x')
r = 16;
else {
r = db_radix;
db_unread_char(c);
}
c = db_read_char();
}
db_tok_number = 0;
for (;;) {
if (c >= '0' && c <= ((r == 8) ? '7' : '9'))
digit = c - '0';
else if (r == 16 && ((c >= 'A' && c <= 'F') ||
(c >= 'a' && c <= 'f'))) {
if (c >= 'a')
digit = c - 'a' + 10;
else if (c >= 'A')
digit = c - 'A' + 10;
}
else
break;
db_tok_number = db_tok_number * r + digit;
c = db_read_char();
}
if ((c >= '0' && c <= '9') ||
(c >= 'A' && c <= 'Z') ||
(c >= 'a' && c <= 'z') ||
(c == '_'))
{
db_error("Bad character in number\n");
db_flush_lex();
return (tEOF);
}
db_unread_char(c);
return (tNUMBER);
}
if ((c >= 'A' && c <= 'Z') ||
(c >= 'a' && c <= 'z') ||
c == '_' || c == '\\')
{
/* string */
char *cp;
cp = db_tok_string;
if (c == '\\') {
c = db_read_char();
if (c == '\n' || c == -1)
db_error("Bad escape\n");
}
*cp++ = c;
while (1) {
c = db_read_char();
if ((c >= 'A' && c <= 'Z') ||
(c >= 'a' && c <= 'z') ||
(c >= '0' && c <= '9') ||
c == '_' || c == '\\' || c == ':' || c == '.')
{
if (c == '\\') {
c = db_read_char();
if (c == '\n' || c == -1)
db_error("Bad escape\n");
}
*cp++ = c;
if (cp == db_tok_string+sizeof(db_tok_string)) {
db_error("String too long\n");
db_flush_lex();
return (tEOF);
}
continue;
}
else {
*cp = '\0';
break;
}
}
db_unread_char(c);
return (tIDENT);
}
switch (c) {
case '+':
return (tPLUS);
case '-':
return (tMINUS);
case '.':
c = db_read_char();
if (c == '.')
return (tDOTDOT);
db_unread_char(c);
return (tDOT);
case '*':
return (tSTAR);
case '/':
return (tSLASH);
case '=':
c = db_read_char();
if (c == '=')
return (tLOG_EQ);
db_unread_char(c);
return (tEQ);
case '%':
return (tPCT);
case '#':
return (tHASH);
case '(':
return (tLPAREN);
case ')':
return (tRPAREN);
case ',':
return (tCOMMA);
case '"':
return (tDITTO);
case '$':
return (tDOLLAR);
case '!':
c = db_read_char();
if (c == '='){
return (tLOG_NOT_EQ);
}
db_unread_char(c);
return (tEXCL);
case ':':
c = db_read_char();
if (c == ':')
return (tCOLONCOLON);
db_unread_char(c);
return (tCOLON);
case ';':
return (tSEMI);
case '&':
c = db_read_char();
if (c == '&')
return (tLOG_AND);
db_unread_char(c);
return (tBIT_AND);
case '|':
c = db_read_char();
if (c == '|')
return (tLOG_OR);
db_unread_char(c);
return (tBIT_OR);
case '<':
c = db_read_char();
if (c == '<')
return (tSHIFT_L);
if (c == '=')
return (tLESS_EQ);
db_unread_char(c);
return (tLESS);
case '>':
c = db_read_char();
if (c == '>')
return (tSHIFT_R);
if (c == '=')
return (tGREATER_EQ);
db_unread_char(c);
return (tGREATER);
case '?':
return (tQUESTION);
case '~':
return (tBIT_NOT);
case -1:
return (tEOF);
}
db_printf("Bad character\n");
db_flush_lex();
return (tEOF);
}