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         return ESP_ERR_INVALID_ARG;
  95     }
  96     if (strchr(cmd->command, ' ') != NULL) {
  97         return ESP_ERR_INVALID_ARG;
  98     }
  99     item->command = cmd->command;
 100     item->help = cmd->help;
 101     if (cmd->hint) {
 102         /* Prepend a space before the hint. It separates command name and
 103          * the hint. arg_print_syntax below adds this space as well.
 104          */
 105         asprintf(&item->hint, " %s", cmd->hint);
 106     } else if (cmd->argtable) {
 107         /* Generate hint based on cmd->argtable */
 108         char* buf = NULL;
 109         size_t buf_size = 0;
 110         FILE* f = open_memstream(&buf, &buf_size);
 111         if (f != NULL) {
 112             arg_print_syntax(f, cmd->argtable, NULL);
 113             fclose(f);
 114         }
 115         item->hint = buf;
 116     }
 117     item->argtable = cmd->argtable;
 118     item->func = cmd->func;
 119     cmd_item_t* last = SLIST_FIRST(&s_cmd_list);
 120     if (last == NULL) {
 121         SLIST_INSERT_HEAD(&s_cmd_list, item, next);
 122     } else {
 123         cmd_item_t* it;
 124         while ((it = SLIST_NEXT(last, next)) != NULL) {
 125             last = it;
 126         }
 127         SLIST_INSERT_AFTER(last, item, next);
 128     }
 129     return ESP_OK;
 130 }
 131
 132 void esp_console_get_completion(const char *buf, linenoiseCompletions *lc)
 133 {
 134     size_t len = strlen(buf);
 135     if (len == 0) {
 136         return;
 137     }
 138     cmd_item_t* it;
 139     SLIST_FOREACH(it, &s_cmd_list, next) {
 140         /* Check if command starts with buf */
 141         if (strncmp(buf, it->command, len) == 0) {
 142             linenoiseAddCompletion(lc, it->command);
 143         }
 144     }
 145 }
 146
 147 const char* esp_console_get_hint(const char *buf, int *color, int *bold)
 148 {
 149     int len = strlen(buf);
 150     cmd_item_t* it;
 151     SLIST_FOREACH(it, &s_cmd_list, next) {
 152         if (strlen(it->command) == len &&
 153                 strncmp(buf, it->command, len) == 0) {
 154             *color = s_config.hint_color;
 155             *bold = s_config.hint_bold;
 156             return it->hint;
 157         }
 158     }
 159     return NULL;
 160 }
 161
 162 static const cmd_item_t* find_command_by_name(const char* name)
 163 {
 164     const cmd_item_t* cmd = NULL;
 165     cmd_item_t* it;
 166     SLIST_FOREACH(it, &s_cmd_list, next) {
 167         if (strcmp(name, it->command) == 0) {
 168             cmd = it;
 169             break;
 170         }
 171     }
 172     return cmd;
 173 }
 174
 175 esp_err_t esp_console_run(const char* cmdline, int* cmd_ret)
 176 {
 177     if (s_tmp_line_buf == NULL) {
 178         return ESP_ERR_INVALID_STATE;
 179     }
 180     char** argv = (char**) calloc(s_config.max_cmdline_args, sizeof(char*));
 181     if (argv == NULL) {
 182         return ESP_ERR_NO_MEM;
 183     }
 184     strlcpy(s_tmp_line_buf, cmdline, s_config.max_cmdline_length);
 185
 186     size_t argc = esp_console_split_argv(s_tmp_line_buf, argv,
 187             s_config.max_cmdline_args);
 188     if (argc == 0) {
 189         return ESP_ERR_INVALID_ARG;
 190     }
 191     const cmd_item_t* cmd = find_command_by_name(argv[0]);
 192     if (cmd == NULL) {
 193         return ESP_ERR_NOT_FOUND;
 194     }
 195     *cmd_ret = (*cmd->func)(argc, argv);
 196     free(argv);
 197     return ESP_OK;
 198 }
 199
 200 static int help_command(int argc, char** argv)
 201 {
 202     cmd_item_t* it;
 203
 204     /* Print summary of each command */
 205     SLIST_FOREACH(it, &s_cmd_list, next) {
 206         if (it->help == NULL) {
 207             continue;
 208         }
 209         /* First line: command name and hint
 210          * Pad all the hints to the same column
 211          */
 212         const char* hint = (it->hint) ? it->hint : "";
 213         printf("%-s %s\n", it->command, hint);
 214         /* Second line: print help.
 215          * Argtable has a nice helper function for this which does line
 216          * wrapping.
 217          */
 218         printf("  "); // arg_print_formatted does not indent the first line
 219         arg_print_formatted(stdout, 2, 78, it->help);
 220         /* Finally, print the list of arguments */
 221         if (it->argtable) {
 222             arg_print_glossary(stdout, (void**) it->argtable, "  %12s  %s\n");
 223         }
 224         printf("\n");
 225     }
 226     return 0;
 227 }
 228
 229
 230 esp_err_t esp_console_register_help_command()
 231 {
 232     esp_console_cmd_t command = {
 233             .command = "help",
 234             .help = "Print the list of registered commands",
 235             .func = &help_command
 236     };
 237     return esp_console_cmd_register(&command);
 238 }