granicus.if.org Git - esp-idf/blob - components/console/commands.c

   1 // Copyright 2016-2017 Espressif Systems (Shanghai) PTE LTD
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include <stdlib.h>
  18 #include <sys/param.h>
  19 #include "esp_log.h"
  20 #include "esp_console.h"
  21 #include "linenoise/linenoise.h"
  22 #include "argtable3/argtable3.h"
  23 #include "rom/queue.h"
  24
  25 #define ANSI_COLOR_DEFAULT      39      /** Default foreground color */
  26
  27 typedef struct cmd_item_ {
  28     /**
  29      * Command name (statically allocated by application)
  30      */
  31     const char *command;
  32     /**
  33      * Help text (statically allocated by application), may be NULL.
  34      */
  35     const char *help;
  36     /**
  37      * Hint text, usually lists possible arguments, dynamically allocated.
  38      * May be NULL.
  39      */
  40     char *hint;
  41     esp_console_cmd_func_t func;    //!< pointer to the command handler
  42     void *argtable;                 //!< optional pointer to arg table
  43     SLIST_ENTRY(cmd_item_) next;    //!< next command in the list
  44 } cmd_item_t;
  45
  46 /** linked list of command structures */
  47 static SLIST_HEAD(cmd_list_, cmd_item_) s_cmd_list;
  48
  49 /** run-time configuration options */
  50 static esp_console_config_t s_config;
  51
  52 /** temporary buffer used for command line parsing */
  53 static char *s_tmp_line_buf;
  54
  55 static const cmd_item_t *find_command_by_name(const char *name);
  56
  57 esp_err_t esp_console_init(const esp_console_config_t *config)
  58 {
  59     if (s_tmp_line_buf) {
  60         return ESP_ERR_INVALID_STATE;
  61     }
  62     memcpy(&s_config, config, sizeof(s_config));
  63     if (s_config.hint_color == 0) {
  64         s_config.hint_color = ANSI_COLOR_DEFAULT;
  65     }
  66     s_tmp_line_buf = calloc(config->max_cmdline_length, 1);
  67     if (s_tmp_line_buf == NULL) {
  68         return ESP_ERR_NO_MEM;
  69     }
  70     return ESP_OK;
  71 }
  72
  73 esp_err_t esp_console_deinit()
  74 {
  75     if (!s_tmp_line_buf) {
  76         return ESP_ERR_INVALID_STATE;
  77     }
  78     free(s_tmp_line_buf);
  79     cmd_item_t *it, *tmp;
  80     SLIST_FOREACH_SAFE(it, &s_cmd_list, next, tmp) {
  81         free(it->hint);
  82         free(it);
  83     }
  84     return ESP_OK;
  85 }
  86
  87 esp_err_t esp_console_cmd_register(const esp_console_cmd_t *cmd)
  88 {
  89     cmd_item_t *item = (cmd_item_t *) calloc(1, sizeof(*item));
  90     if (item == NULL) {
  91         return ESP_ERR_NO_MEM;
  92     }
  93     if (cmd->command == NULL) {
  94         free(item);
  95         return ESP_ERR_INVALID_ARG;
  96     }
  97     if (strchr(cmd->command, ' ') != NULL) {
  98         free(item);
  99         return ESP_ERR_INVALID_ARG;
 100     }
 101     item->command = cmd->command;
 102     item->help = cmd->help;
 103     if (cmd->hint) {
 104         /* Prepend a space before the hint. It separates command name and
 105          * the hint. arg_print_syntax below adds this space as well.
 106          */
 107         asprintf(&item->hint, " %s", cmd->hint);
 108     } else if (cmd->argtable) {
 109         /* Generate hint based on cmd->argtable */
 110         char *buf = NULL;
 111         size_t buf_size = 0;
 112         FILE *f = open_memstream(&buf, &buf_size);
 113         if (f != NULL) {
 114             arg_print_syntax(f, cmd->argtable, NULL);
 115             fclose(f);
 116         }
 117         item->hint = buf;
 118     }
 119     item->argtable = cmd->argtable;
 120     item->func = cmd->func;
 121     cmd_item_t *last = SLIST_FIRST(&s_cmd_list);
 122     if (last == NULL) {
 123         SLIST_INSERT_HEAD(&s_cmd_list, item, next);
 124     } else {
 125         cmd_item_t *it;
 126         while ((it = SLIST_NEXT(last, next)) != NULL) {
 127             last = it;
 128         }
 129         SLIST_INSERT_AFTER(last, item, next);
 130     }
 131     return ESP_OK;
 132 }
 133
 134 void esp_console_get_completion(const char *buf, linenoiseCompletions *lc)
 135 {
 136     size_t len = strlen(buf);
 137     if (len == 0) {
 138         return;
 139     }
 140     cmd_item_t *it;
 141     SLIST_FOREACH(it, &s_cmd_list, next) {
 142         /* Check if command starts with buf */
 143         if (strncmp(buf, it->command, len) == 0) {
 144             linenoiseAddCompletion(lc, it->command);
 145         }
 146     }
 147 }
 148
 149 const char *esp_console_get_hint(const char *buf, int *color, int *bold)
 150 {
 151     int len = strlen(buf);
 152     cmd_item_t *it;
 153     SLIST_FOREACH(it, &s_cmd_list, next) {
 154         if (strlen(it->command) == len &&
 155                 strncmp(buf, it->command, len) == 0) {
 156             *color = s_config.hint_color;
 157             *bold = s_config.hint_bold;
 158             return it->hint;
 159         }
 160     }
 161     return NULL;
 162 }
 163
 164 static const cmd_item_t *find_command_by_name(const char *name)
 165 {
 166     const cmd_item_t *cmd = NULL;
 167     cmd_item_t *it;
 168     SLIST_FOREACH(it, &s_cmd_list, next) {
 169         if (strcmp(name, it->command) == 0) {
 170             cmd = it;
 171             break;
 172         }
 173     }
 174     return cmd;
 175 }
 176
 177 esp_err_t esp_console_run(const char *cmdline, int *cmd_ret)
 178 {
 179     if (s_tmp_line_buf == NULL) {
 180         return ESP_ERR_INVALID_STATE;
 181     }
 182     char **argv = (char **) calloc(s_config.max_cmdline_args, sizeof(char *));
 183     if (argv == NULL) {
 184         return ESP_ERR_NO_MEM;
 185     }
 186     strlcpy(s_tmp_line_buf, cmdline, s_config.max_cmdline_length);
 187
 188     size_t argc = esp_console_split_argv(s_tmp_line_buf, argv,
 189                                          s_config.max_cmdline_args);
 190     if (argc == 0) {
 191         free(argv);
 192         return ESP_ERR_INVALID_ARG;
 193     }
 194     const cmd_item_t *cmd = find_command_by_name(argv[0]);
 195     if (cmd == NULL) {
 196         free(argv);
 197         return ESP_ERR_NOT_FOUND;
 198     }
 199     *cmd_ret = (*cmd->func)(argc, argv);
 200     free(argv);
 201     return ESP_OK;
 202 }
 203
 204 static int help_command(int argc, char **argv)
 205 {
 206     cmd_item_t *it;
 207
 208     /* Print summary of each command */
 209     SLIST_FOREACH(it, &s_cmd_list, next) {
 210         if (it->help == NULL) {
 211             continue;
 212         }
 213         /* First line: command name and hint
 214          * Pad all the hints to the same column
 215          */
 216         const char *hint = (it->hint) ? it->hint : "";
 217         printf("%-s %s\n", it->command, hint);
 218         /* Second line: print help.
 219          * Argtable has a nice helper function for this which does line
 220          * wrapping.
 221          */
 222         printf("  "); // arg_print_formatted does not indent the first line
 223         arg_print_formatted(stdout, 2, 78, it->help);
 224         /* Finally, print the list of arguments */
 225         if (it->argtable) {
 226             arg_print_glossary(stdout, (void **) it->argtable, "  %12s  %s\n");
 227         }
 228         printf("\n");
 229     }
 230     return 0;
 231 }
 232
 233
 234 esp_err_t esp_console_register_help_command()
 235 {
 236     esp_console_cmd_t command = {
 237         .command = "help",
 238         .help = "Print the list of registered commands",
 239         .func = &help_command
 240     };
 241     return esp_console_cmd_register(&command);
 242 }