377 lines
6.6 KiB
C
377 lines
6.6 KiB
C
/* $NetBSD: db_lex.c,v 1.27 2022/08/30 22:37:03 riastradh Exp $ */
|
|
|
|
/*
|
|
* 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 "AS IS"
|
|
* 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>
|
|
__KERNEL_RCSID(0, "$NetBSD: db_lex.c,v 1.27 2022/08/30 22:37:03 riastradh Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/cpu.h>
|
|
|
|
#include <ddb/ddb.h>
|
|
|
|
db_expr_t db_tok_number;
|
|
char db_tok_string[TOK_STRING_SIZE];
|
|
|
|
static char db_line[DB_LINE_MAXLEN];
|
|
static const char *db_lp;
|
|
static const char *db_endlp;
|
|
|
|
static int db_look_char = 0;
|
|
static int db_look_token = 0;
|
|
|
|
static void db_flush_line(void);
|
|
static int db_read_char(void);
|
|
static void db_unread_char(int);
|
|
static int db_lex(void);
|
|
|
|
int
|
|
db_read_line(void)
|
|
{
|
|
int i;
|
|
|
|
#ifdef _KERNEL
|
|
/*
|
|
* crash(8) prints the prompt using libedit. That's why we used to
|
|
* print it in db_readline(). But now people are using db_read_line()
|
|
* for general purpose input, so..
|
|
*/
|
|
#ifdef MULTIPROCESSOR
|
|
db_printf("db{%ld}> ", (long)cpu_number());
|
|
#else
|
|
db_printf("db> ");
|
|
#endif
|
|
#endif
|
|
i = db_readline(db_line, sizeof(db_line));
|
|
if (i == 0)
|
|
return (0); /* EOI */
|
|
db_set_line(db_line, db_line + i);
|
|
return (i);
|
|
}
|
|
|
|
void
|
|
db_set_line(const char *sp, const char *ep)
|
|
{
|
|
|
|
db_lp = sp;
|
|
db_endlp = ep;
|
|
}
|
|
|
|
void
|
|
db_get_line(const char **psp, const char **pep)
|
|
{
|
|
|
|
if (psp != NULL)
|
|
*psp = db_lp;
|
|
if (pep != NULL)
|
|
*pep = db_endlp;
|
|
}
|
|
|
|
static void
|
|
db_flush_line(void)
|
|
{
|
|
|
|
db_lp = db_line;
|
|
db_endlp = db_line;
|
|
}
|
|
|
|
static int
|
|
db_read_char(void)
|
|
{
|
|
int c;
|
|
|
|
if (db_look_char != 0) {
|
|
c = db_look_char;
|
|
db_look_char = 0;
|
|
}
|
|
else if (db_lp >= db_endlp)
|
|
c = -1;
|
|
else
|
|
c = *db_lp++;
|
|
return (c);
|
|
}
|
|
|
|
static void
|
|
db_unread_char(int c)
|
|
{
|
|
|
|
db_look_char = c;
|
|
}
|
|
|
|
void
|
|
db_unread_token(int t)
|
|
{
|
|
|
|
db_look_token = t;
|
|
}
|
|
|
|
int
|
|
db_read_token(void)
|
|
{
|
|
int t;
|
|
|
|
if (db_look_token) {
|
|
t = db_look_token;
|
|
db_look_token = 0;
|
|
}
|
|
else
|
|
t = db_lex();
|
|
return (t);
|
|
}
|
|
|
|
int db_radix = 16;
|
|
|
|
/*
|
|
* Convert the number to a string in the current radix.
|
|
* This replaces the non-standard %n printf() format.
|
|
*/
|
|
|
|
char *
|
|
db_num_to_str(db_expr_t val)
|
|
{
|
|
|
|
/*
|
|
* 2 chars for "0x", 1 for a sign ("-")
|
|
* up to 21 chars for a 64-bit number:
|
|
* % echo 2^64 | bc | wc -c
|
|
* 21
|
|
* and 1 char for a terminal NUL
|
|
* 2+1+21+1 => 25
|
|
*/
|
|
static char buf[25];
|
|
|
|
db_num_to_strbuf(val, buf, sizeof(buf));
|
|
|
|
return (buf);
|
|
}
|
|
|
|
void
|
|
db_num_to_strbuf(db_expr_t val, char *buf, size_t len)
|
|
{
|
|
|
|
if (db_radix == 16)
|
|
snprintf(buf, len, "%" DDB_EXPR_FMT "x", val);
|
|
else if (db_radix == 8)
|
|
snprintf(buf, len, "%" DDB_EXPR_FMT "o", val);
|
|
else
|
|
snprintf(buf, len, "%" DDB_EXPR_FMT "u", val);
|
|
}
|
|
|
|
void
|
|
db_flush_lex(void)
|
|
{
|
|
|
|
db_flush_line();
|
|
db_look_char = 0;
|
|
db_look_token = 0;
|
|
}
|
|
|
|
static int
|
|
db_lex(void)
|
|
{
|
|
int c;
|
|
|
|
c = db_read_char();
|
|
while (c <= ' ' || c > '~') {
|
|
if (c == '\n' || c == -1)
|
|
return (tEOL);
|
|
c = db_read_char();
|
|
}
|
|
|
|
if (c >= '0' && c <= '9') {
|
|
/* number */
|
|
db_expr_t r, digit = 0;
|
|
|
|
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) {
|
|
if (c >= 'A' && c <= 'F')
|
|
digit = c - 'A' + 10;
|
|
else if (c >= 'a' && c <= 'f')
|
|
digit = c - 'a' + 10;
|
|
else
|
|
break;
|
|
} 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");
|
|
/*NOTREACHED*/
|
|
}
|
|
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");
|
|
/*NOTREACHED*/
|
|
}
|
|
}
|
|
*cp++ = c;
|
|
while (1) {
|
|
c = db_read_char();
|
|
if ((c >= 'A' && c <= 'Z') ||
|
|
(c >= 'a' && c <= 'z') ||
|
|
(c >= '0' && c <= '9') ||
|
|
c == '_' || c == '\\' || c == ':') {
|
|
if (c == '\\') {
|
|
c = db_read_char();
|
|
if (c == '\n' || c == -1) {
|
|
db_error("Bad escape\n");
|
|
/*NOTREACHED*/
|
|
}
|
|
}
|
|
*cp++ = c;
|
|
if (cp == db_tok_string+sizeof(db_tok_string)) {
|
|
db_error("String too long\n");
|
|
/*NOTREACHED*/
|
|
}
|
|
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 '=':
|
|
return (tEQ);
|
|
case '%':
|
|
return (tPCT);
|
|
case '#':
|
|
return (tHASH);
|
|
case '(':
|
|
return (tLPAREN);
|
|
case ')':
|
|
return (tRPAREN);
|
|
case ',':
|
|
return (tCOMMA);
|
|
case '"':
|
|
return (tDITTO);
|
|
case '$':
|
|
return (tDOLLAR);
|
|
case '!':
|
|
return (tEXCL);
|
|
case '<':
|
|
c = db_read_char();
|
|
if (c == '<')
|
|
return (tSHIFT_L);
|
|
db_unread_char(c);
|
|
break;
|
|
case '>':
|
|
c = db_read_char();
|
|
if (c == '>')
|
|
return (tSHIFT_R);
|
|
db_unread_char(c);
|
|
break;
|
|
case -1:
|
|
return (tEOF);
|
|
}
|
|
db_printf("Bad character\n");
|
|
db_flush_lex();
|
|
return (tEOF);
|
|
}
|
|
|
|
/*
|
|
* Utility routine - discard tokens through end-of-line.
|
|
*/
|
|
void
|
|
db_skip_to_eol(void)
|
|
{
|
|
int t;
|
|
|
|
do {
|
|
t = db_read_token();
|
|
} while (t != tEOL);
|
|
}
|
|
|
|
void
|
|
db_error(const char *s)
|
|
{
|
|
|
|
if (s)
|
|
db_printf("%s", s);
|
|
db_flush_lex();
|
|
longjmp(db_recover);
|
|
}
|