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