851 lines
24 KiB
C
851 lines
24 KiB
C
/*
|
|
* Copyright (c) 2006-2021, RT-Thread Development Team
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2006-04-30 Bernard the first version for FinSH
|
|
* 2006-05-08 Bernard change finsh thread stack to 2048
|
|
* 2006-06-03 Bernard add support for skyeye
|
|
* 2006-09-24 Bernard remove the code related with hardware
|
|
* 2010-01-18 Bernard fix down then up key bug.
|
|
* 2010-03-19 Bernard fix backspace issue and fix device read in shell.
|
|
* 2010-04-01 Bernard add prompt output when start and remove the empty history
|
|
* 2011-02-23 Bernard fix variable section end issue of finsh shell
|
|
* initialization when use GNU GCC compiler.
|
|
* 2016-11-26 armink add password authentication
|
|
* 2018-07-02 aozima add custom prompt support.
|
|
*/
|
|
#ifdef RT_USING_FINSH
|
|
|
|
#include "finsh.h"
|
|
#include "shell.h"
|
|
|
|
#ifdef FINSH_USING_MSH
|
|
#include "msh.h"
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
#include <stdio.h> /* for putchar */
|
|
#endif
|
|
|
|
/* finsh symtab */
|
|
#ifdef FINSH_USING_SYMTAB
|
|
struct finsh_syscall *_syscall_table_begin = NULL;
|
|
struct finsh_syscall *_syscall_table_end = NULL;
|
|
struct finsh_sysvar *_sysvar_table_begin = NULL;
|
|
struct finsh_sysvar *_sysvar_table_end = NULL;
|
|
#endif
|
|
|
|
struct finsh_shell *shell;
|
|
static char *finsh_prompt_custom = RT_NULL;
|
|
|
|
#if defined(_MSC_VER) || (defined(__GNUC__) && defined(__x86_64__))
|
|
struct finsh_syscall *finsh_syscall_next(struct finsh_syscall *call)
|
|
{
|
|
unsigned int *ptr;
|
|
ptr = (unsigned int *)(call + 1);
|
|
while ((*ptr == 0) && ((unsigned int *)ptr < (unsigned int *) _syscall_table_end)) {
|
|
ptr ++;
|
|
}
|
|
|
|
return (struct finsh_syscall *)ptr;
|
|
}
|
|
|
|
struct finsh_sysvar *finsh_sysvar_next(struct finsh_sysvar *call)
|
|
{
|
|
unsigned int *ptr;
|
|
ptr = (unsigned int *)(call + 1);
|
|
while ((*ptr == 0) && ((unsigned int *)ptr < (unsigned int *) _sysvar_table_end)) {
|
|
ptr ++;
|
|
}
|
|
|
|
return (struct finsh_sysvar *)ptr;
|
|
}
|
|
#endif /* defined(_MSC_VER) || (defined(__GNUC__) && defined(__x86_64__)) */
|
|
|
|
#ifdef RT_USING_HEAP
|
|
int finsh_set_prompt(const char *prompt)
|
|
{
|
|
if (finsh_prompt_custom) {
|
|
rt_free(finsh_prompt_custom);
|
|
finsh_prompt_custom = RT_NULL;
|
|
}
|
|
|
|
/* strdup */
|
|
if (prompt) {
|
|
finsh_prompt_custom = (char *)rt_malloc(strlen(prompt) + 1);
|
|
if (finsh_prompt_custom) {
|
|
strcpy(finsh_prompt_custom, prompt);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif /* RT_USING_HEAP */
|
|
|
|
#ifdef RT_USING_DFS
|
|
#include <dfs_posix.h>
|
|
#endif /* RT_USING_DFS */
|
|
|
|
const char *finsh_get_prompt(void)
|
|
{
|
|
#define _MSH_PROMPT "msh "
|
|
#define _PROMPT "finsh "
|
|
static char finsh_prompt[RT_CONSOLEBUF_SIZE + 1] = {0};
|
|
|
|
/* check prompt mode */
|
|
if (!shell->prompt_mode) {
|
|
finsh_prompt[0] = '\0';
|
|
return finsh_prompt;
|
|
}
|
|
|
|
if (finsh_prompt_custom) {
|
|
strncpy(finsh_prompt, finsh_prompt_custom, sizeof(finsh_prompt) - 1);
|
|
return finsh_prompt;
|
|
}
|
|
|
|
#ifdef FINSH_USING_MSH
|
|
if (msh_is_used()) {
|
|
strcpy(finsh_prompt, _MSH_PROMPT);
|
|
} else
|
|
#endif
|
|
strcpy(finsh_prompt, _PROMPT);
|
|
|
|
#if defined(RT_USING_DFS) && defined(DFS_USING_WORKDIR)
|
|
/* get current working directory */
|
|
getcwd(&finsh_prompt[rt_strlen(finsh_prompt)], RT_CONSOLEBUF_SIZE - rt_strlen(finsh_prompt));
|
|
#endif
|
|
|
|
strcat(finsh_prompt, ">");
|
|
|
|
return finsh_prompt;
|
|
}
|
|
|
|
/**
|
|
* @ingroup finsh
|
|
*
|
|
* This function get the prompt mode of finsh shell.
|
|
*
|
|
* @return prompt the prompt mode, 0 disable prompt mode, other values enable prompt mode.
|
|
*/
|
|
rt_uint32_t finsh_get_prompt_mode(void)
|
|
{
|
|
RT_ASSERT(shell != RT_NULL);
|
|
return shell->prompt_mode;
|
|
}
|
|
|
|
/**
|
|
* @ingroup finsh
|
|
*
|
|
* This function set the prompt mode of finsh shell.
|
|
*
|
|
* The parameter 0 disable prompt mode, other values enable prompt mode.
|
|
*
|
|
* @param prompt the prompt mode
|
|
*/
|
|
void finsh_set_prompt_mode(rt_uint32_t prompt_mode)
|
|
{
|
|
RT_ASSERT(shell != RT_NULL);
|
|
shell->prompt_mode = prompt_mode;
|
|
}
|
|
|
|
/****************************************************************************************************************************************/
|
|
#include "device.h"
|
|
#include "asm/uart.h"
|
|
#include "os/os_api.h"
|
|
#include "init.h"
|
|
__attribute__((weak)) const char *finsh_get_uart(void)
|
|
{
|
|
return "uart1";
|
|
}
|
|
static void *uart_hdl;
|
|
static u8 uart_buf[128] __attribute__((aligned(32))); //用于串口接收缓存数据的循环buf
|
|
static int finsh_uart_init(void)
|
|
{
|
|
uart_hdl = dev_open(finsh_get_uart(), NULL);
|
|
if (!uart_hdl) {
|
|
printf("finsh %s init fail !!!\n", finsh_get_uart());
|
|
return -1;
|
|
}
|
|
/* 1 . 设置串口接收缓存数据的循环buf地址 */
|
|
dev_ioctl(uart_hdl, UART_SET_CIRCULAR_BUFF_ADDR, (int)uart_buf);
|
|
|
|
/* 1 . 设置串口接收缓存数据的循环buf长度 */
|
|
dev_ioctl(uart_hdl, UART_SET_CIRCULAR_BUFF_LENTH, sizeof(uart_buf));
|
|
|
|
/* 3 . 设置接收数据为阻塞方式,需要非阻塞可以去掉,建议加上超时设置 */
|
|
dev_ioctl(uart_hdl, UART_SET_RECV_BLOCK, 1);
|
|
|
|
/* parm = 1000; */
|
|
/* dev_ioctl(mp_test_uart_dev_handle, UART_SET_RECV_TIMEOUT, (u32)parm); */
|
|
|
|
/* 4 . 使能特殊串口,启动收发数据 */
|
|
dev_ioctl(uart_hdl, UART_START, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int finsh_getchar(void)
|
|
{
|
|
char c;
|
|
//puts("^");
|
|
if (dev_read(uart_hdl, &c, 1) <= 0) {
|
|
puts("\n finsh_getchar err\n");
|
|
}
|
|
//printf("[%c]", c);
|
|
return c;
|
|
}
|
|
/****************************************************************************************************************************************/
|
|
|
|
#if !defined(RT_USING_POSIX) && defined(RT_USING_DEVICE)
|
|
static rt_err_t finsh_rx_ind(rt_device_t dev, rt_size_t size)
|
|
{
|
|
RT_ASSERT(shell != RT_NULL);
|
|
|
|
/* release semaphore to let finsh thread rx data */
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
/**
|
|
* @ingroup finsh
|
|
*
|
|
* This function sets the input device of finsh shell.
|
|
*
|
|
* @param device_name the name of new input device.
|
|
*/
|
|
void finsh_set_device(const char *device_name)
|
|
{
|
|
rt_device_t dev = RT_NULL;
|
|
|
|
RT_ASSERT(shell != RT_NULL);
|
|
dev = rt_device_find(device_name);
|
|
if (dev == RT_NULL) {
|
|
rt_kprintf("finsh: can not find device: %s\n", device_name);
|
|
return;
|
|
}
|
|
|
|
/* check whether it's a same device */
|
|
if (dev == shell->device) {
|
|
return;
|
|
}
|
|
/* open this device and set the new device in finsh shell */
|
|
if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | \
|
|
RT_DEVICE_FLAG_STREAM) == RT_EOK) {
|
|
if (shell->device != RT_NULL) {
|
|
/* close old finsh device */
|
|
|
|
|
|
rt_device_close(shell->device);
|
|
rt_device_set_rx_indicate(shell->device, RT_NULL);
|
|
}
|
|
|
|
/* clear line buffer before switch to new device */
|
|
memset(shell->line, 0, sizeof(shell->line));
|
|
shell->line_curpos = shell->line_position = 0;
|
|
|
|
shell->device = dev;
|
|
rt_device_set_rx_indicate(dev, finsh_rx_ind);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @ingroup finsh
|
|
*
|
|
* This function returns current finsh shell input device.
|
|
*
|
|
* @return the finsh shell input device name is returned.
|
|
*/
|
|
const char *finsh_get_device()
|
|
{
|
|
RT_ASSERT(shell != RT_NULL);
|
|
return shell->device->parent.name;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @ingroup finsh
|
|
*
|
|
* This function set the echo mode of finsh shell.
|
|
*
|
|
* FINSH_OPTION_ECHO=0x01 is echo mode, other values are none-echo mode.
|
|
*
|
|
* @param echo the echo mode
|
|
*/
|
|
void finsh_set_echo(rt_uint32_t echo)
|
|
{
|
|
RT_ASSERT(shell != RT_NULL);
|
|
shell->echo_mode = (rt_uint8_t)echo;
|
|
}
|
|
|
|
/**
|
|
* @ingroup finsh
|
|
*
|
|
* This function gets the echo mode of finsh shell.
|
|
*
|
|
* @return the echo mode
|
|
*/
|
|
rt_uint32_t finsh_get_echo()
|
|
{
|
|
RT_ASSERT(shell != RT_NULL);
|
|
|
|
return shell->echo_mode;
|
|
}
|
|
|
|
#ifdef FINSH_USING_AUTH
|
|
/**
|
|
* set a new password for finsh
|
|
*
|
|
* @param password new password
|
|
*
|
|
* @return result, RT_EOK on OK, -RT_ERROR on the new password length is less than
|
|
* FINSH_PASSWORD_MIN or greater than FINSH_PASSWORD_MAX
|
|
*/
|
|
rt_err_t finsh_set_password(const char *password)
|
|
{
|
|
rt_ubase_t level;
|
|
rt_size_t pw_len = rt_strlen(password);
|
|
|
|
if (pw_len < FINSH_PASSWORD_MIN || pw_len > FINSH_PASSWORD_MAX) {
|
|
return -RT_ERROR;
|
|
}
|
|
|
|
level = rt_hw_interrupt_disable();
|
|
rt_strncpy(shell->password, password, FINSH_PASSWORD_MAX);
|
|
rt_hw_interrupt_enable(level);
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
/**
|
|
* get the finsh password
|
|
*
|
|
* @return password
|
|
*/
|
|
const char *finsh_get_password(void)
|
|
{
|
|
return shell->password;
|
|
}
|
|
|
|
static void finsh_wait_auth(void)
|
|
{
|
|
int ch;
|
|
rt_bool_t input_finish = RT_FALSE;
|
|
char password[FINSH_PASSWORD_MAX] = { 0 };
|
|
rt_size_t cur_pos = 0;
|
|
/* password not set */
|
|
if (rt_strlen(finsh_get_password()) == 0) {
|
|
return;
|
|
}
|
|
|
|
while (1) {
|
|
rt_kprintf("Password for login: ");
|
|
while (!input_finish) {
|
|
while (1) {
|
|
/* read one character from device */
|
|
ch = finsh_getchar();
|
|
if (ch < 0) {
|
|
continue;
|
|
}
|
|
|
|
if (ch >= ' ' && ch <= '~' && cur_pos < FINSH_PASSWORD_MAX) {
|
|
/* change the printable characters to '*' */
|
|
rt_kprintf("*");
|
|
password[cur_pos++] = ch;
|
|
} else if (ch == '\b' && cur_pos > 0) {
|
|
/* backspace */
|
|
cur_pos--;
|
|
password[cur_pos] = '\0';
|
|
rt_kprintf("\b \b");
|
|
} else if (ch == '\r' || ch == '\n') {
|
|
rt_kprintf("\n");
|
|
input_finish = RT_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!rt_strncmp(shell->password, password, FINSH_PASSWORD_MAX)) {
|
|
return;
|
|
} else {
|
|
/* authentication failed, delay 2S for retry */
|
|
rt_thread_delay(2 * RT_TICK_PER_SECOND);
|
|
rt_kprintf("Sorry, try again.\n");
|
|
cur_pos = 0;
|
|
input_finish = RT_FALSE;
|
|
rt_memset(password, '\0', FINSH_PASSWORD_MAX);
|
|
}
|
|
}
|
|
}
|
|
#endif /* FINSH_USING_AUTH */
|
|
|
|
static void shell_auto_complete(char *prefix)
|
|
{
|
|
|
|
rt_kprintf("\n");
|
|
#ifdef FINSH_USING_MSH
|
|
if (msh_is_used() == RT_TRUE) {
|
|
msh_auto_complete(prefix);
|
|
} else
|
|
#endif
|
|
{
|
|
#ifndef FINSH_USING_MSH_ONLY
|
|
extern void list_prefix(char *prefix);
|
|
list_prefix(prefix);
|
|
#endif
|
|
}
|
|
|
|
rt_kprintf("%s%s", FINSH_PROMPT, prefix);
|
|
}
|
|
|
|
#ifndef FINSH_USING_MSH_ONLY
|
|
void finsh_run_line(struct finsh_parser *parser, const char *line)
|
|
{
|
|
const char *err_str;
|
|
|
|
if (shell->echo_mode) {
|
|
rt_kprintf("\n");
|
|
}
|
|
finsh_parser_run(parser, (unsigned char *)line);
|
|
|
|
/* compile node root */
|
|
if (finsh_errno() == 0) {
|
|
finsh_compiler_run(parser->root);
|
|
} else {
|
|
err_str = finsh_error_string(finsh_errno());
|
|
rt_kprintf("%s\n", err_str);
|
|
}
|
|
|
|
/* run virtual machine */
|
|
if (finsh_errno() == 0) {
|
|
char ch;
|
|
finsh_vm_run();
|
|
|
|
ch = (unsigned char)finsh_stack_bottom();
|
|
if (ch > 0x20 && ch < 0x7e) {
|
|
rt_kprintf("\t'%c', %d, 0x%08x\n",
|
|
(unsigned char)finsh_stack_bottom(),
|
|
(unsigned int)finsh_stack_bottom(),
|
|
(unsigned int)finsh_stack_bottom());
|
|
} else {
|
|
rt_kprintf("\t%d, 0x%08x\n",
|
|
(unsigned int)finsh_stack_bottom(),
|
|
(unsigned int)finsh_stack_bottom());
|
|
}
|
|
}
|
|
|
|
finsh_flush(parser);
|
|
}
|
|
#endif
|
|
|
|
#ifdef FINSH_USING_HISTORY
|
|
static rt_bool_t shell_handle_history(struct finsh_shell *shell)
|
|
{
|
|
#if defined(_WIN32)
|
|
int i;
|
|
rt_kprintf("\r");
|
|
|
|
for (i = 0; i <= 60; i++) {
|
|
putchar(' ');
|
|
}
|
|
rt_kprintf("\r");
|
|
|
|
#else
|
|
rt_kprintf("\033[2K\r");
|
|
#endif
|
|
rt_kprintf("%s%s", FINSH_PROMPT, shell->line);
|
|
return RT_FALSE;
|
|
}
|
|
|
|
static void shell_push_history(struct finsh_shell *shell)
|
|
{
|
|
if (shell->line_position != 0) {
|
|
/* push history */
|
|
if (shell->history_count >= FINSH_HISTORY_LINES) {
|
|
/* if current cmd is same as last cmd, don't push */
|
|
if (memcmp(&shell->cmd_history[FINSH_HISTORY_LINES - 1], shell->line, FINSH_CMD_SIZE)) {
|
|
/* move history */
|
|
int index;
|
|
for (index = 0; index < FINSH_HISTORY_LINES - 1; index ++) {
|
|
memcpy(&shell->cmd_history[index][0],
|
|
&shell->cmd_history[index + 1][0], FINSH_CMD_SIZE);
|
|
}
|
|
memset(&shell->cmd_history[index][0], 0, FINSH_CMD_SIZE);
|
|
memcpy(&shell->cmd_history[index][0], shell->line, shell->line_position);
|
|
|
|
/* it's the maximum history */
|
|
shell->history_count = FINSH_HISTORY_LINES;
|
|
}
|
|
} else {
|
|
/* if current cmd is same as last cmd, don't push */
|
|
if (shell->history_count == 0 || memcmp(&shell->cmd_history[shell->history_count - 1], shell->line, FINSH_CMD_SIZE)) {
|
|
shell->current_history = shell->history_count;
|
|
memset(&shell->cmd_history[shell->history_count][0], 0, FINSH_CMD_SIZE);
|
|
memcpy(&shell->cmd_history[shell->history_count][0], shell->line, shell->line_position);
|
|
|
|
/* increase count and set current history position */
|
|
shell->history_count ++;
|
|
}
|
|
}
|
|
}
|
|
shell->current_history = shell->history_count;
|
|
}
|
|
#endif
|
|
|
|
void finsh_thread_entry(void *parameter)
|
|
{
|
|
int ch;
|
|
/* normal is echo mode */
|
|
#ifndef FINSH_ECHO_DISABLE_DEFAULT
|
|
shell->echo_mode = 1;
|
|
#else
|
|
shell->echo_mode = 0;
|
|
#endif
|
|
#ifndef FINSH_USING_MSH_ONLY
|
|
finsh_init(&shell->parser);
|
|
#endif
|
|
#if !defined(RT_USING_POSIX) && defined(RT_USING_DEVICE)
|
|
/* set console device as shell device */
|
|
if (shell->device == RT_NULL) {
|
|
rt_device_t console = rt_console_get_device();
|
|
if (console) {
|
|
finsh_set_device(console->parent.name);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
#ifdef FINSH_USING_AUTH
|
|
/* set the default password when the password isn't setting */
|
|
if (rt_strlen(finsh_get_password()) == 0) {
|
|
if (finsh_set_password(FINSH_DEFAULT_PASSWORD) != RT_EOK) {
|
|
rt_kprintf("Finsh password set failed.\n");
|
|
}
|
|
}
|
|
/* waiting authenticate success */
|
|
finsh_wait_auth();
|
|
#endif
|
|
rt_kprintf(FINSH_PROMPT);
|
|
while (1) {
|
|
ch = finsh_getchar();
|
|
if (ch < 0) {
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* handle control key
|
|
* up key : 0x1b 0x5b 0x41
|
|
* down key: 0x1b 0x5b 0x42
|
|
* right key:0x1b 0x5b 0x43
|
|
* left key: 0x1b 0x5b 0x44
|
|
*/
|
|
if (ch == 0x1b) {
|
|
shell->stat = WAIT_SPEC_KEY;
|
|
continue;
|
|
} else if (shell->stat == WAIT_SPEC_KEY) {
|
|
if (ch == 0x5b) {
|
|
shell->stat = WAIT_FUNC_KEY;
|
|
continue;
|
|
}
|
|
|
|
shell->stat = WAIT_NORMAL;
|
|
} else if (shell->stat == WAIT_FUNC_KEY) {
|
|
shell->stat = WAIT_NORMAL;
|
|
if (ch == 0x41) { /* up key */
|
|
#ifdef FINSH_USING_HISTORY
|
|
/* prev history */
|
|
if (shell->current_history > 0) {
|
|
shell->current_history --;
|
|
} else {
|
|
shell->current_history = 0;
|
|
continue;
|
|
}
|
|
/* copy the history command */
|
|
memcpy(shell->line, &shell->cmd_history[shell->current_history][0],
|
|
FINSH_CMD_SIZE);
|
|
shell->line_curpos = shell->line_position = strlen(shell->line);
|
|
shell_handle_history(shell);
|
|
#endif
|
|
continue;
|
|
} else if (ch == 0x42) { /* down key */
|
|
#ifdef FINSH_USING_HISTORY
|
|
/* next history */
|
|
if (shell->current_history < shell->history_count - 1) {
|
|
shell->current_history ++;
|
|
} else {
|
|
/* set to the end of history */
|
|
if (shell->history_count != 0) {
|
|
shell->current_history = shell->history_count - 1;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
memcpy(shell->line, &shell->cmd_history[shell->current_history][0],
|
|
FINSH_CMD_SIZE);
|
|
shell->line_curpos = shell->line_position = strlen(shell->line);
|
|
shell_handle_history(shell);
|
|
#endif
|
|
continue;
|
|
} else if (ch == 0x44) { /* left key */
|
|
if (shell->line_curpos) {
|
|
rt_kprintf("\b");
|
|
shell->line_curpos --;
|
|
}
|
|
continue;
|
|
} else if (ch == 0x43) { /* right key */
|
|
if (shell->line_curpos < shell->line_position) {
|
|
rt_kprintf("%c", shell->line[shell->line_curpos]);
|
|
shell->line_curpos ++;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* received null or error */
|
|
if (ch == '\0' || ch == 0xFF) {
|
|
continue;
|
|
}
|
|
/* handle tab key */
|
|
else if (ch == '\t') {
|
|
int i;
|
|
/* move the cursor to the beginning of line */
|
|
for (i = 0; i < shell->line_curpos; i++) {
|
|
rt_kprintf("\b");
|
|
}
|
|
/* auto complete */
|
|
shell_auto_complete(&shell->line[0]);
|
|
/* re-calculate position */
|
|
shell->line_curpos = shell->line_position = strlen(shell->line);
|
|
|
|
continue;
|
|
}
|
|
/* handle backspace key */
|
|
else if (ch == 0x7f || ch == 0x08) {
|
|
/* note that shell->line_curpos >= 0 */
|
|
if (shell->line_curpos == 0) {
|
|
continue;
|
|
}
|
|
shell->line_position--;
|
|
shell->line_curpos--;
|
|
if (shell->line_position > shell->line_curpos) {
|
|
int i;
|
|
rt_memmove(&shell->line[shell->line_curpos],
|
|
&shell->line[shell->line_curpos + 1],
|
|
shell->line_position - shell->line_curpos);
|
|
shell->line[shell->line_position] = 0;
|
|
rt_kprintf("\b%s \b", &shell->line[shell->line_curpos]);
|
|
|
|
/* move the cursor to the origin position */
|
|
for (i = shell->line_curpos; i <= shell->line_position; i++) {
|
|
rt_kprintf("\b");
|
|
}
|
|
} else {
|
|
rt_kprintf("\b \b");
|
|
shell->line[shell->line_position] = 0;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/* handle end of line, break */
|
|
if (ch == '\r' || ch == '\n') {
|
|
#ifdef FINSH_USING_HISTORY
|
|
shell_push_history(shell);
|
|
#endif
|
|
#ifdef FINSH_USING_MSH
|
|
if (msh_is_used() == RT_TRUE) {
|
|
if (shell->echo_mode) {
|
|
rt_kprintf("\n");
|
|
}
|
|
msh_exec(shell->line, shell->line_position);
|
|
} else
|
|
#endif
|
|
{
|
|
#ifndef FINSH_USING_MSH_ONLY
|
|
/* add ';' and run the command line */
|
|
shell->line[shell->line_position] = ';';
|
|
if (shell->line_position != 0) {
|
|
finsh_run_line(&shell->parser, shell->line);
|
|
} else if (shell->echo_mode) {
|
|
rt_kprintf("\n");
|
|
}
|
|
#endif
|
|
}
|
|
rt_kprintf(FINSH_PROMPT);
|
|
memset(shell->line, 0, sizeof(shell->line));
|
|
shell->line_curpos = shell->line_position = 0;
|
|
continue;
|
|
}
|
|
|
|
/* it's a large line, discard it */
|
|
if (shell->line_position >= FINSH_CMD_SIZE) {
|
|
shell->line_position = 0;
|
|
}
|
|
|
|
/* normal character */
|
|
if (shell->line_curpos < shell->line_position) {
|
|
int i;
|
|
rt_memmove(&shell->line[shell->line_curpos + 1],
|
|
&shell->line[shell->line_curpos],
|
|
shell->line_position - shell->line_curpos);
|
|
shell->line[shell->line_curpos] = ch;
|
|
if (shell->echo_mode) {
|
|
rt_kprintf("%s", &shell->line[shell->line_curpos]);
|
|
}
|
|
|
|
/* move the cursor to new position */
|
|
for (i = shell->line_curpos; i < shell->line_position; i++) {
|
|
rt_kprintf("\b");
|
|
}
|
|
} else {
|
|
shell->line[shell->line_position] = ch;
|
|
if (shell->echo_mode) {
|
|
rt_kprintf("%c", ch);
|
|
}
|
|
}
|
|
|
|
ch = 0;
|
|
shell->line_position ++;
|
|
shell->line_curpos++;
|
|
if (shell->line_position >= FINSH_CMD_SIZE) {
|
|
/* clear command line */
|
|
shell->line_position = 0;
|
|
shell->line_curpos = 0;
|
|
}
|
|
} /* end of device read */
|
|
}
|
|
|
|
void finsh_system_function_init(const void *begin, const void *end)
|
|
{
|
|
_syscall_table_begin = (struct finsh_syscall *) begin;
|
|
_syscall_table_end = (struct finsh_syscall *) end;
|
|
}
|
|
|
|
void finsh_system_var_init(const void *begin, const void *end)
|
|
{
|
|
|
|
_sysvar_table_begin = (struct finsh_sysvar *) begin;
|
|
_sysvar_table_end = (struct finsh_sysvar *) end;
|
|
}
|
|
|
|
#if defined(__ICCARM__) || defined(__ICCRX__) /* for IAR compiler */
|
|
#ifdef FINSH_USING_SYMTAB
|
|
#pragma section="FSymTab"
|
|
#pragma section="VSymTab"
|
|
|
|
#endif
|
|
#elif defined(__ADSPBLACKFIN__) /* for VisaulDSP++ Compiler*/
|
|
#ifdef FINSH_USING_SYMTAB
|
|
extern "asm" int __fsymtab_start;
|
|
extern "asm" int __fsymtab_end;
|
|
extern "asm" int __vsymtab_start;
|
|
extern "asm" int __vsymtab_end;
|
|
#endif
|
|
#elif defined(_MSC_VER)
|
|
#pragma section("FSymTab$a", read)
|
|
const char __fsym_begin_name[] = "__start";
|
|
const char __fsym_begin_desc[] = "begin of finsh";
|
|
__declspec(allocate("FSymTab$a")) const struct finsh_syscall __fsym_begin = {
|
|
__fsym_begin_name,
|
|
__fsym_begin_desc,
|
|
NULL
|
|
};
|
|
|
|
#pragma section("FSymTab$z", read)
|
|
const char __fsym_end_name[] = "__end";
|
|
const char __fsym_end_desc[] = "end of finsh";
|
|
__declspec(allocate("FSymTab$z")) const struct finsh_syscall __fsym_end = {
|
|
__fsym_end_name,
|
|
__fsym_end_desc,
|
|
NULL
|
|
};
|
|
#endif
|
|
|
|
/*
|
|
* @ingroup finsh
|
|
*
|
|
* This function will initialize finsh shell
|
|
*/
|
|
int finsh_system_init(void)
|
|
{
|
|
if (finsh_uart_init()) {
|
|
return -RT_ERROR;
|
|
}
|
|
rt_err_t result = RT_EOK;
|
|
|
|
#ifdef FINSH_USING_SYMTAB
|
|
#ifdef __ARMCC_VERSION /* ARM C Compiler */
|
|
extern const int FSymTab$$Base;
|
|
extern const int FSymTab$$Limit;
|
|
extern const int VSymTab$$Base;
|
|
extern const int VSymTab$$Limit;
|
|
finsh_system_function_init(&FSymTab$$Base, &FSymTab$$Limit);
|
|
#ifndef FINSH_USING_MSH_ONLY
|
|
finsh_system_var_init(&VSymTab$$Base, &VSymTab$$Limit);
|
|
#endif
|
|
#elif defined (__ICCARM__) || defined(__ICCRX__) /* for IAR Compiler */
|
|
finsh_system_function_init(__section_begin("FSymTab"),
|
|
__section_end("FSymTab"));
|
|
finsh_system_var_init(__section_begin("VSymTab"),
|
|
__section_end("VSymTab"));
|
|
#elif defined (__GNUC__) || defined(__TI_COMPILER_VERSION__) || defined(__TASKING__)
|
|
/* GNU GCC Compiler and TI CCS */
|
|
extern const int __fsymtab_start;
|
|
extern const int __fsymtab_end;
|
|
extern const int __vsymtab_start;
|
|
extern const int __vsymtab_end;
|
|
finsh_system_function_init(&__fsymtab_start, &__fsymtab_end);
|
|
finsh_system_var_init(&__vsymtab_start, &__vsymtab_end);
|
|
#elif defined(__ADSPBLACKFIN__) /* for VisualDSP++ Compiler */
|
|
finsh_system_function_init(&__fsymtab_start, &__fsymtab_end);
|
|
finsh_system_var_init(&__vsymtab_start, &__vsymtab_end);
|
|
#elif defined(__ADSPBLACKFIN__) /* for VisualDSP++ Compiler */
|
|
#elif defined(_MSC_VER)
|
|
unsigned int *ptr_begin, *ptr_end;
|
|
if (shell) {
|
|
rt_kprintf("finsh shell already init.\n");
|
|
return RT_EOK;
|
|
}
|
|
|
|
ptr_begin = (unsigned int *)&__fsym_begin;
|
|
ptr_begin += (sizeof(struct finsh_syscall) / sizeof(unsigned int));
|
|
while (*ptr_begin == 0) {
|
|
ptr_begin ++;
|
|
}
|
|
ptr_end = (unsigned int *) &__fsym_end;
|
|
ptr_end --;
|
|
while (*ptr_end == 0) {
|
|
ptr_end --;
|
|
}
|
|
finsh_system_function_init(ptr_begin, ptr_end);
|
|
#endif
|
|
#endif
|
|
|
|
static struct finsh_shell _shell;
|
|
shell = &_shell;
|
|
finsh_set_prompt_mode(1);
|
|
os_task_create(finsh_thread_entry, NULL, FINSH_THREAD_PRIORITY, FINSH_THREAD_STACK_SIZE, 0, FINSH_THREAD_NAME);
|
|
|
|
return RT_EOK;
|
|
|
|
}
|
|
|
|
|
|
int rt_kprintf(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
#if 1
|
|
vprintf(fmt, ap);
|
|
#else
|
|
user_vprintf(fmt, ap);
|
|
#endif
|
|
va_end(ap);
|
|
return 0;
|
|
}
|
|
|
|
|
|
#endif /* RT_USING_FINSH */
|
|
|
|
|