blob: 5782530a990119e74bede34f7a6012ab99726979 [file] [log] [blame]
/*
* Copyright (c) 2008 Travis Geiselbrecht
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <debug.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <lib/console.h>
static cmd_block *command_list = NULL;
/* a linear array of statically defined command blocks,
defined in the linker script.
*/
extern cmd_block __commands_start;
extern cmd_block __commands_end;
static int cmd_help(int argc, const cmd_args *argv);
static int cmd_test(int argc, const cmd_args *argv);
STATIC_COMMAND_START
{ "help", "this list", &cmd_help },
{ "test", "test the command processor", &cmd_test },
STATIC_COMMAND_END(help);
int console_init(void)
{
printf("console_init: entry\n");
/* add all the statically defined commands to the list */
cmd_block *block;
for (block = &__commands_start; block != &__commands_end; block++) {
console_register_commands(block);
}
return 0;
}
static const cmd *match_command(const char *command)
{
cmd_block *block;
size_t i;
for (block = command_list; block != NULL; block = block->next) {
const cmd *curr_cmd = block->list;
for (i = 0; i < block->count; i++) {
if (strcmp(command, curr_cmd[i].cmd_str) == 0) {
return &curr_cmd[i];
}
}
}
return NULL;
}
static int read_line(char *buffer, int len)
{
int pos = 0;
int escape_level = 0;
for (;;) {
char c;
/* loop until we get a char */
if (getc(&c) < 0)
continue;
// printf("c = 0x%hhx\n", c);
if (escape_level == 0) {
switch (c) {
case '\r':
case '\n':
putc(c);
goto done;
case 0x7f: // backspace or delete
case 0x8:
if (pos > 0) {
pos--;
puts("\x1b[1D"); // move to the left one
putc(' ');
puts("\x1b[1D"); // move to the left one
}
break;
case 0x1b: // escape
escape_level++;
break;
default:
buffer[pos++] = c;
putc(c);
}
} else if (escape_level == 1) {
// inside an escape, look for '['
if (c == '[') {
escape_level++;
} else {
// we didn't get it, abort
escape_level = 0;
}
} else { // escape_level > 1
switch (c) {
case 67: // right arrow
buffer[pos++] = ' ';
putc(' ');
break;
case 68: // left arrow
if (pos > 0) {
pos--;
puts("\x1b[1D"); // move to the left one
putc(' ');
puts("\x1b[1D"); // move to the left one
}
break;
case 65: // up arrow
case 66: // down arrow
// XXX do history here
break;
default:
break;
}
escape_level = 0;
}
/* end of line. */
if (pos == (len - 1)) {
puts("\nerror: line too long\n");
pos = 0;
goto done;
}
}
done:
// printf("returning pos %d\n", pos);
buffer[pos] = 0;
return pos;
}
static int tokenize_command(char *buffer, cmd_args *args, int arg_count)
{
int pos;
int arg;
bool finished;
enum {
INITIAL = 0,
IN_SPACE,
IN_TOKEN
} state;
pos = 0;
arg = 0;
state = INITIAL;
finished = false;
for (;;) {
char c = buffer[pos];
if (c == '\0')
finished = true;
// printf("c 0x%hhx state %d arg %d pos %d\n", c, state, arg, pos);
switch (state) {
case INITIAL:
if (isspace(c)) {
state = IN_SPACE;
} else {
state = IN_TOKEN;
args[arg].str = &buffer[pos];
}
break;
case IN_TOKEN:
if (finished) {
arg++;
goto done;
}
if (isspace(c)) {
arg++;
buffer[pos] = 0;
/* are we out of tokens? */
if (arg == arg_count)
goto done;
state = IN_SPACE;
}
pos++;
break;
case IN_SPACE:
if (finished)
goto done;
if (!isspace(c)) {
state = IN_TOKEN;
args[arg].str = &buffer[pos];
}
pos++;
break;
}
}
done:
return arg;
}
static void convert_args(int argc, cmd_args *argv)
{
int i;
for (i = 0; i < argc; i++) {
argv[i].u = atoui(argv[i].str);
argv[i].i = atoi(argv[i].str);
}
}
static void console_loop(void)
{
cmd_args args[16];
char buffer[256];
printf("entering main console loop\n");
for (;;) {
puts("] ");
int len = read_line(buffer, sizeof(buffer));
if (len == 0)
continue;
// printf("line = '%s'\n", buffer);
/* tokenize the line */
int argc = tokenize_command(buffer, args, 16);
if (argc < 0) {
printf("syntax error\n");
continue;
} else if (argc == 0) {
continue;
}
// printf("after tokenize: argc %d\n", argc);
// for (int i = 0; i < argc; i++)
// printf("%d: '%s'\n", i, args[i].str);
/* convert the args */
convert_args(argc, args);
/* try to match the command */
const cmd *command = match_command(args[0].str);
if (!command) {
printf("command not found\n");
continue;
}
int result = command->cmd_callback(argc, args);
// XXX do something with the result
}
}
void console_start(void)
{
console_loop();
}
int console_run_command(const char *string)
{
const cmd *command;
ASSERT(string != NULL);
command = match_command(string);
if (!command)
return -1;
int result = command->cmd_callback(0, NULL);
return result;
}
void console_register_commands(cmd_block *block)
{
ASSERT(block);
ASSERT(block->next == NULL);
block->next = command_list;
command_list = block;
}
static int cmd_help(int argc, const cmd_args *argv)
{
printf("command list:\n");
cmd_block *block;
size_t i;
for (block = command_list; block != NULL; block = block->next) {
const cmd *curr_cmd = block->list;
for (i = 0; i < block->count; i++) {
printf("\t%-16s: %s\n", curr_cmd[i].cmd_str, curr_cmd[i].help_str ? curr_cmd[i].help_str : "");
}
}
return 0;
}
static int cmd_test(int argc, const cmd_args *argv)
{
int i;
printf("argc %d, argv %p\n", argc, argv);
for (i = 0; i < argc; i++)
printf("\t%d: str '%s', i %d, u %#x\n", i, argv[i].str, argv[i].i, argv[i].u);
return 0;
}