[ { "path": ".github/workflows/arduino-ci.yaml", "content": "name: Arduino Library CI\n\non: [pull_request, push, repository_dispatch]\n\njobs:\n build:\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/setup-python@v5\n with:\n python-version: '3.x'\n - uses: actions/checkout@v4\n\n - uses: actions/checkout@v4\n with:\n repository: adafruit/ci-arduino\n path: ci\n\n - name: pre-install\n run: bash ci/actions_install.sh\n\n - name: test platforms\n run: python3 ci/build_platform.py --no_warn esp32\n\n #- name: clang\n # run: python3 ci/run-clang-format.py -e \"ci/*\" -e \"bin/*\" -r . \n\n - name: doxygen\n env:\n GH_REPO_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n PRETTYNAME : \"ESP32Console Library\"\n run: bash ci/doxy_gen_and_deploy.sh " }, { "path": ".github/workflows/arduino-lint.yaml", "content": "on: [push, pull_request]\njobs:\n lint:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - uses: arduino/arduino-lint-action@v1\n with:\n library-manager: update\n compliance: strict" }, { "path": "LICENSE", "content": "MIT License\n\nCopyright (c) 2022 Jan Böhmer\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE." }, { "path": "README.md", "content": "# ESP32Console\n\n[![PlatformIO Registry](https://badges.registry.platformio.org/packages/jbtronics/library/ESP32Console.svg)](https://registry.platformio.org/libraries/jbtronics/ESP32Console)\n\nArduino library to add a serial console to your ESP32 console. It includes some useful commands and allows to easily add your own custom commands.\n\nThis easily allows you to control and configure your control via serial console in a comfortable and easy way.\n\nThis library encapsulates the Console component included in the ESP-IDF and allows to use it in an easy \"Arduino-way\".\n\n![Screenshot of console output](extras/screenshot.png)\n\n## Features\n* Simple to use\n* Navigatable history, autocompletion with tab for commands (when using an ANSI terminal)\n* Persistent history if wished (history gets saved across reboots)\n* Many useful commands included like showing infos about system, memory, network and more (see [commands.md](commands.md) for more info)\n* Console works in its own asynchronous task, so you can use your arduino loop() function as you like\n* Support for environment variables and variable interpolation in commands\n* Easy to implement own commands\n* Easy to use argument parsing using cxxopts (see `argparser` example)\n* Customizable prompt\n* Ships a simple file editor to modify and create files locally on system if wanted\n\n\n## Usage\n\n### Installation\nThis library is available via Arduino Library Manager and [PlatformIO registry](https://registry.platformio.org/libraries/jbtronics/ESP32Console). So just install it via your preferred IDE's library manager and you are ready to start.\n\n### Basic\n\nTo use this library you have to do an `#include ` to import all needed files into your project. This library uses namespaces, so you have to do an `using namespace ESP32Console` to not having to prefix all classes (see example below).\n\nYou instantiate an `Console` object and initialize it with `Console.begin(BAUD)`. You can specifiy the baud rate and rx/tx pins similar to `Serial.begin`. Please note that you can use EITHER `Serial` OR `Console`. If you try to start ESP32Console after Serial was inited you will get an error.\n\nUsing `Console.registerCommand()` you can register your own custom commands. You have to pass a command object (see example below), which contains the name of the command, a little help text and the function which should be executed, when this command is executed. There are different types of commands:\n* `ConsoleCommand`: The \"default\" console command, which takes a pointer to a function which is executed on call (similar to arduinos `attachInterrupt` function). The function receives an `int argc` which contains the number of arguments and `char** argv` which contains the arguments itself. The function MUST return an integer. Return 0 if everything was successfull, return something else (e.g. 1) if an error happened. This command type has the lowest memory usage.\n* `ConsoleCommandD`: Similar to `ConsoleCommand` but allows to pass an `std::function` object as handler. This allows you to use lambda-functions and `std::bind`\n* `OptionsConsoleCommand`: Allows you to define and parse command options and arguments in an easy way. Uses [cxxopts](https://github.com/jarro2783/cxxopts) for arguments parsing. Every command of this type has an `--help` and `--version` option. See `examples/argparser` for usage.\n\n### Included commands\nESP32Console includes many useful commands, which can be registered using their respective `registerXXX()` functions. See [commands.md](commands.md) for a detailed list of the commands.\n\n### Environment variables\nThe ESP32Console supports environment variables and string interpolation in the console. You can use `env` command to list all existing environment variables and `declare [VAR] [VALUE]` to change one. In the console prompt `$ENV` and `${ENV}` will get replaced by the value of the defined env value. With that you can for example define a variable with `declare HOST www.github.com` and access it in other commands: `ping $HOST`.\nYou can change and predefine env variables from your code. See `examples/gpio` for more info.\n\n### Computer side\nYou can use almost any terminal software on PC for connecting with ESP32Console. You can use a simple terminal like the one included in Arduino but it is highly recommended to use a VT100 compatible terminal (e.g. PuTTY on windows).\nThis kind of terminal is needed for more complex functions like auto-complete with TAB, history scrolling, colors and more.\n\nIf you use a VT100 compatible terminal you can use the keybinds, when in prompt:\n* `Ctrl + L`: Clear screen\n* `Ctrl + A`: Jump cursor to begin of line\n* `Ctrl + E`: Jump cursor to end of line\n* `Ctrl + U`: Delete whole line\n* `Ctrl + K`: Delete from current position to end of line\n* `Ctrl + W`: Delete previous word\n* `Ctrl + T`: Swap current character with previous one\n\n## Examples\nA simple usage can be seen here (see `examples/simple.ino`):\nMore advanced usages can be found in `examples/` folder.\n\n```\n#include \n\n#include \"ESP32Console.h\"\n\nusing namespace ESP32Console;\n\nConsole console;\n\nconstexpr int LED = 2;\n\nint led(int argc, char **argv)\n{\n //Ensure that we have an argument to parse\n if (argc != 2)\n {\n printf(\"You have to give 'on' or 'off' as a argument (e.g. 'led on')\\n\");\n \n //Return EXIT_FAILURE if something did not worked.\n return EXIT_FAILURE;\n }\n \n //Take the first argument...\n auto arg = String(argv[1]);\n\n //and use it to decide what to do with the LED\n if (arg == \"on\") {\n digitalWrite(LED, HIGH);\n printf(\"LED is now on\\n\");\n } else if(arg == \"off\") {\n digitalWrite(LED, LOW);\n printf(\"LED is now off\\n\");\n } else {\n printf(\"Unknown argument!\\n\");\n return EXIT_FAILURE;\n }\n \n //Return EXIT_SUCCESS if everything worked as intended.\n return EXIT_SUCCESS;\n}\n\nvoid setup()\n{\n pinMode(LED, OUTPUT);\n\n //You can change the console prompt before calling begin(). By default it is \"ESP32>\"\n console.setPrompt(\"MyConsole> \");\n\n //You can change the baud rate and pin numbers similar to Serial.begin() here.\n console.begin(115200);\n\n //Register builtin commands like 'reboot', 'sysinfo', or 'meminfo'\n console.registerSystemCommands();\n\n //Register our own command\n //First argument is the name with which the command can be executed, second argument is the function to execute and third one is the description shown in help command.\n console.registerCommand(ConsoleCommand(\"led\", &led, \"Turn the LED on or off\"));\n\n //With ConsoleCommandD you can use lambda functions (and anything else that can be cast to std::function). This needs a bit more memory and CPU time than the normal ConsoleCommand.\n console.registerCommand(ConsoleCommandD(\"test\", [](int argc, char **argv) -> int {\n printf(\"Lambda function test\\n\");\n return EXIT_SUCCESS;\n }, \"Just a test command!\"));\n\n //When console is in use, we can not use Serial.print but you can use printf to output text\n printf(\"\\n\\nWelcome to ESP32Console example. Try out typing 'led off' and 'led on' (without quotes) or see 'help' for all commands.\");\n}\n\nvoid loop()\n{\n //Console works async in its own task, so you can do whatever you want in your loop() function.\n}\n```\n\n## Credits\n* This library utilizes the console component of ESP-IDF written by Espressif at core.\n* Argument parsing is done by [cxxopts](https://github.com/jarro2783/cxxopts).\n* As editor a modified version of [kilo](https://github.com/antirez/kilo) is used.\n\n## LICENSE\nESP32Console is licensed under MIT LICENSE. See [LICENSE file](LICENSE) for more info.\n\nkilo shipped with ESP32Console is licensed under BSD-2 clause license. See the respective file for more info. \n\n## TODO\n* Add more useful commands\n* Easy integration of colors and console styles\n* Support of command batch files\n* Add support for ESP8266 (this should be possible in theory as the old RTOS-SDK already ships the console parts)\n* Check if more complex terminal stuff, like pipes, output redirection and similar is possible (difficult due only having one global stdout)\n" }, { "path": "commands.md", "content": "# Included command reference\n\n## Core commands (automatically loaded, when begin() is called)\n\n* `help`: Show a list of all possible commands with descriptions\n* `clear`: Clear terminal screen using ANSI commands (only working when using an ANSI compatible terminal)\n* `echo`: Echo the parameter strings\n* `history`: Show the recent command history\n* `multiline_mode`: Switch multiline mode on or off. When it is on, lines get break into a second line, if it gets too long.\n* `env`: List all environment variables\n* `declare`: Change the value of an environment variable (syntax: `declare VARIABLE Value` or `declare VARIABLE \"Long Value\"`)\n\n## System commands (loaded by calling registerSystemCommands())\n\n* `sysinfo`: Prints info about the chip model, revision, ESP-IDF version, EFuse MAC, flash and PSRAM\n* `restart`: Restarts the system\n* `meminfo`: Show informations about used and free Heap\n* `date`: Shows and set the current system time. Change time with `date -s \"2022-07-13 22:47:00\"`. Timezone can be set by changing the `TZ` env variable (e.g. `declare TZ CET-1`).\n\n## Network commands (loaded by calling registerNetworkCommands())\n\n* `ipconfig`: Shows information about WiFi connection\n* `ping [HOST]`: Pings a hostname. You can change the number of pings done with `-n`parameter. Use `-n 0` for infinite pinging. You can stop the ping by `Strg + C` or `Strg + D`.\n\n## VFS commands (loaded by calling registerVFSCommands())\n\nThis functions allows you to navigate through and edit files in ESP-IDFs Virtual Filesystem. Things likes SPIFF, SDCards, some hardware and more are getting mounted into VFS with different prefixes.\nThe following commands allow an unified access on it.\n\n* `pwd`: Show the current working directory (the directory we are currently in)\n* `cd [PATH]`: Change the current directory\n* `ls [PATH]`: List the contents of the current or given directory\n* `cat [FILES...]`: Show the content of the given files\n* `rm [FILE]`: Delete the given file\n* `rmdir [DIR]`: Delete the given director\n* `mv [ORIGIN] [TARGET]`: Moves/Rename the file to new name/posiion\n* `cp [ORIGIN] [TARGET]`: Copies the contents of origin to target file\n* `edit [FILE]`: Opens a file editor with a visual editor. Use `Strg + S` to save, `Strg + Q` to quit and `Strg + F` to search in file.\n\n## GPIO commands (loaded by calling registerGPIOCommands())\nThe commands allow you to read and change the states of the ESPs GPIO pins. They are similar to the arduino included functions:\n\n* `pinMode [PIN] [MODE]`: Change the pinMode of an GPIO\n* `digitalRead [PIN]`: Reads the state of an digital GPIO\n* `digitalWrite [PIN] [LEVEL]`: Changes the state of an digital GPIO\n* `analogRead [PIN]`: Reads the voltage applied to an analog GPIO in millivolts" }, { "path": "examples/argparser/argparser.ino", "content": "/**\n * This example demonstrates the usage of OptionsConsoleCommand, which allows you to easily build commands with complex options and argument parsing.\n */\n\n#include \n\n#include \"ESP32Console.h\"\n\nusing namespace ESP32Console;\n\nConsole console;\n\nvoid setup()\n{\n console.begin(115200);\n\n // Define a new command. Every command has an --option argument which shows the possible arguments and (if defined) a --version option which shows the version of this command.\n OptionsConsoleCommand test(\n \"test\", // The command name\n [](int argc, char **argv, ParseResult result, Options options) -> int { // The function which is called when command is called. You get the parsed arguments and the options object\n \n printf(\"Lambda function test\\n\");\n\n // Check if argument was passed, then print it:\n if (result.count(\"i\"))\n {\n int i = result[\"i\"].as();\n printf(\"Selected mode: %d\\n\", i);\n }\n\n return EXIT_SUCCESS;\n },\n \"Just a test command!\",\n \"v1.0.0\"); //You can define a version number which is shown when the command is called with --version\n\n //Customize the options of the console object. See https://github.com/jarro2783/cxxopts for explaination\n test.options.add_options()(\"i,integer\", \"Int param\", cxxopts::value());\n\n //Register it like any other command\n console.registerCommand(test);\n}\n\nvoid loop()\n{\n // Console works async in its own task, so you can do whatever you want in your loop() function.\n}" }, { "path": "examples/basic/basic.ino", "content": "#include \n\n#include \"ESP32Console.h\"\n\nusing namespace ESP32Console;\n\nConsole console;\n\nconstexpr int LED = 2;\n\nint led(int argc, char **argv)\n{\n //Ensure that we have an argument to parse\n if (argc != 2)\n {\n printf(\"You have to give 'on' or 'off' as a argument (e.g. 'led on')\\n\");\n \n //Return EXIT_FAILURE if something did not worked.\n return EXIT_FAILURE;\n }\n \n //Take the first argument...\n auto arg = String(argv[1]);\n\n //and use it to decide what to do with the LED\n if (arg == \"on\") {\n digitalWrite(LED, HIGH);\n printf(\"LED is now on\\n\");\n } else if(arg == \"off\") {\n digitalWrite(LED, LOW);\n printf(\"LED is now off\\n\");\n } else {\n printf(\"Unknown argument!\\n\");\n return EXIT_FAILURE;\n }\n \n //Return EXIT_SUCCESS if everything worked as intended.\n return EXIT_SUCCESS;\n}\n\nvoid setup()\n{\n pinMode(LED, OUTPUT);\n\n //You can change the console prompt before calling begin(). By default it is \"ESP32>\"\n console.setPrompt(\"MyConsole> \");\n\n //You can change the baud rate and pin numbers similar to Serial.begin() here.\n console.begin(115200);\n\n //Register builtin commands like 'reboot', 'version', or 'meminfo'\n console.registerSystemCommands();\n\n //Register our own command\n //First argument is the name with which the command can be executed, second argument is the function to execute and third one is the description shown in help command.\n console.registerCommand(ConsoleCommand(\"led\", &led, \"Turn the LED on or off\"));\n\n //With ConsoleCommandD you can use lambda functions (and anything else that can be cast to std::function). This needs a bit more memory and CPU time than the normal ConsoleCommand.\n console.registerCommand(ConsoleCommandD(\"test\", [](int argc, char **argv) -> int {\n printf(\"Lambda function test\\n\");\n return EXIT_SUCCESS;\n }, \"Just a test command!\"));\n\n //When console is in use, we can not use Serial.print but you can use printf to output text\n printf(\"\\n\\nWelcome to ESP32Console example. Try out typing 'led off' and 'led on' (without quotes) or see 'help' for all commands.\");\n}\n\nvoid loop()\n{\n //Console works async in its own task, so you can do whatever you want in your loop() function.\n}" }, { "path": "examples/gpio/gpio.ino", "content": "/**\n * This example demonstrates the usage of the internal GPIO functions and the env variables interpolation\n */\n\n#include \n#include \"ESP32Console.h\"\n\n#include \"ESP32Console/Helpers/PWDHelpers.h\"\n\nusing namespace ESP32Console;\n\nConsole console;\n\nvoid setup()\n{ \n\n console.begin(115200);\n console.registerSystemCommands();\n \n /**\n * Set environment variables, so users can access pin numbers easily in console.\n * Users can do commands like `digitalWrite $LED HIGH` which will then be expanded to `digitalWrite 10 HIGH`.\n * Users can change these env variables or create new ones dynamically in the console by `declare LED 10`.\n */\n setenv(\"LED\", \"10\", 1);\n setenv(\"BUTTON\", \"4\", 1);\n\n /**\n * Users can list all defined env variables and their values by `env` command\n */\n\n //Register GPIO commands\n console.registerGPIOCommands();\n}\n\nvoid loop()\n{\n \n}" }, { "path": "examples/network/network.ino", "content": "/**\n * This example demonstrates the usage of the builtin network functions\n */\n\n#include \n#include \"ESP32Console.h\"\n#include \n\n#include \"ESP32Console/Helpers/PWDHelpers.h\"\n\nusing namespace ESP32Console;\n\nConsole console;\n\nconst char *ssid = \"yourSSID\";\nconst char *password = \"yourWLAN\";\n\nvoid setup()\n{ \n //Connect to WiFi\n WiFi.begin(ssid, password);\n\n console.begin(115200);\n console.registerSystemCommands();\n \n //Register network commands\n console.registerNetworkCommands();\n}\n\nvoid loop()\n{\n \n}" }, { "path": "examples/other_uart_channel/other_uart_channel.ino", "content": "/**\n * This example demonstrates the usage of ESP32Console on a seperate UART channel, using its own Pins, which allows you to use\n * the console besides normal Serial.* commands\n */\n\n#include \n#include \"ESP32Console.h\"\n\nusing namespace ESP32Console;\n\nConsole console;\n\nvoid setup()\n{ \n //Initialize Serial port on UART0 (the onboard USB Serial Converter)\n Serial.begin(115200);\n \n //Enable ESP32Console on Pin 12 & 14 on UART1\n console.begin(115200, 12, 14, 1);\n\n\n console.registerSystemCommands();\n console.registerNetworkCommands();\n}\n\nvoid loop()\n{\n //We can use Serial on UART0 as usual, while ESP32Console is available on the Pins above.\n Serial.println(\"Test\");\n delay(1000);\n}" }, { "path": "examples/vfs/vfs.ino", "content": "/**\n * This example demonstrates the usage of the builtin VFS commands and persistent history\n */\n\n#include \n#include \"ESP32Console.h\"\n#include \n#include \"SPIFFS.h\"\n#include \"ESP32Console/Helpers/PWDHelpers.h\"\n\nusing namespace ESP32Console;\n\nConsole console;\n\nvoid setup()\n{\n //Initalize SPIFFS and mount it on /spiffs\n SPIFFS.begin(true, \"/spiffs\");\n\n //Modify prompt to show current file path (%pwd% get replaced by the filepath)\n console.setPrompt(\"ESP32 %pwd%> \");\n \n //Set HOME env for easier navigating (type cd to jump to home)\n setenv(\"HOME\", \"/spiffs\", 1);\n //Set PWD to env\n console_chdir(\"/spiffs\");\n \n console.begin(115200);\n\n //Enable the saving of our command history to SPIFFS. You will be able to see it, when you type ls in your console.\n console.enablePersistentHistory(\"/spiffs/.history.txt\");\n\n console.registerSystemCommands();\n\n //Register the VFS specific commands\n console.registerVFSCommands();\n}\n\nvoid loop()\n{\n}" }, { "path": "library.json", "content": "{\n \"name\": \"ESP32Console\",\n \"version\": \"1.3.0\",\n \"description\": \"Extensible UART console for ESP32 with useful included commands. This library encapsules the console component of ESP-IDF and make them easy to use in an Arduino environment.\",\n \"keywords\": \"esp32, console, ping, ifconfig, sysinfo, editor, file\",\n \"repository\":\n {\n \"type\": \"git\",\n \"url\": \"https://github.com/jbtronics/ESP32Console\"\n },\n \"authors\":\n [\n {\n \"name\": \"Jan Böhmer\",\n \"email\": \"mail@jan-boehmer.de\",\n \"url\": \"https://github.com/jbtronics\",\n \"maintainer\": true\n }\n ],\n \"license\": \"MIT\",\n \"homepage\": \"https://github.com/jbtronics/ESP32Console\",\n \"dependencies\": {\n },\n \"exclude\": [\n \".github\",\n \"extras\"\n ],\n \"frameworks\": \"arduino\",\n \"platforms\": \"espressif32\"\n }\n" }, { "path": "library.properties", "content": "name=ESP32Console\nversion=1.3.0\nauthor=Jan Böhmer \nmaintainer=Jan Böhmer \nsentence=Extensible UART console for ESP32 with useful included commands.\nparagraph=This library encapsules the console component of ESP-IDF and make them easy to use in an Arduino environment\ncategory=Communication\nurl=https://github.com/jbtronics/ESP32Console\narchitectures=esp32\n" }, { "path": "src/ESP32Console/Commands/CoreCommands.cpp", "content": "#include \"./CoreCommands.h\"\n#include \"linenoise/linenoise.h\"\n#include \"Arduino.h\"\n#include \"soc/soc_caps.h\"\n//#include \"argparse/argparse.hpp\"\n\nstatic int clear(int argc, char **argv)\n{\n // If we are on a dumb erminal clearing does not work\n if (linenoiseProbe())\n {\n printf(\"\\nYour terminal does not support escape sequences. Clearing screen does not work!\\n\");\n return EXIT_FAILURE;\n }\n\n linenoiseClearScreen();\n return EXIT_SUCCESS;\n}\n\nstatic int echo(int argc, char **argv)\n{\n for (int n = 1; n 1)\n {\n if (strcasecmp(argv[1], \"-c\"))\n { // When -c option was detected clear history.\n linenoiseHistorySetMaxLen(0);\n printf(\"History cleared!\\n\");\n linenoiseHistorySetMaxLen(10);\n return EXIT_SUCCESS;\n }\n else\n {\n printf(\"Invalid argument. Use -c to clear history.\\n\");\n\n return EXIT_FAILURE;\n }\n }\n else*/\n { // Without arguments we just output the history\n // We use the ESP-IDF VFS to directly output the file to an UART. UART channel 0 has the path /dev/uart/0 and so on.\n char path[12] = {0};\n snprintf(path, 12, \"/dev/uart/%d\", history_channel);\n\n // If we found the correct one, let linoise save (output) them.\n linenoiseHistorySave(path);\n return EXIT_SUCCESS;\n }\n\n return EXIT_FAILURE;\n}\n\nextern char **environ;\n\nstatic int env(int argc, char **argv)\n{\n char **s = environ;\n\n for (; *s; s++)\n {\n printf(\"%s\\n\", *s);\n }\n return EXIT_SUCCESS;\n}\n\nstatic int declare(int argc, char **argv)\n{\n if (argc != 3) {\n fprintf(stderr, \"Syntax: declare VAR short OR declare VARIABLE \\\"Long Value\\\"\\n\");\n return EXIT_FAILURE; \n }\n\n setenv(argv[1], argv[2], 1);\n\n return EXIT_SUCCESS;\n}\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getClearCommand()\n {\n return ConsoleCommand(\"clear\", &clear, \"Clears the screen using ANSI codes\");\n }\n\n const ConsoleCommand getEchoCommand()\n {\n return ConsoleCommand(\"echo\", &echo, \"Echos the text supplied as argument\");\n }\n\n const ConsoleCommand getSetMultilineCommand()\n {\n return ConsoleCommand(\"multiline_mode\", &set_multiline_mode, \"Sets the multiline mode of the console\");\n }\n\n const ConsoleCommand getHistoryCommand(int uart_channel)\n {\n history_channel = uart_channel;\n return ConsoleCommand(\"history\", &history, \"Shows and clear command history (using -c parameter)\");\n }\n\n const ConsoleCommand getEnvCommand()\n {\n return ConsoleCommand(\"env\", &env, \"List all environment variables.\");\n }\n\n const ConsoleCommand getDeclareCommand()\n {\n return ConsoleCommand(\"declare\", &declare, \"Change enviroment variables\");\n }\n}" }, { "path": "src/ESP32Console/Commands/CoreCommands.h", "content": "#pragma once\n\n#include \"ESP32Console/ConsoleCommand.h\"\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getClearCommand();\n\n const ConsoleCommand getEchoCommand();\n\n const ConsoleCommand getSetMultilineCommand();\n\n const ConsoleCommand getHistoryCommand(int uart_channel=0);\n\n const ConsoleCommand getEnvCommand();\n\n const ConsoleCommand getDeclareCommand();\n}" }, { "path": "src/ESP32Console/Commands/GPIOCommands.cpp", "content": "#include \"./GPIOCommands.h\"\n#include \"Arduino.h\"\n#include \n#include \n\nstatic int _pinmode(int argc, char **argv)\n{\n if (argc != 3)\n {\n printf(\"You have to pass a pin number and mode. Syntax: pinMode [GPIO] [MODE]\\n\");\n return 1;\n }\n\n char *pin_str = argv[1];\n String mode_str = String(argv[2]);\n\n unsigned long pin = 0;\n\n try\n {\n pin = std::stoul(pin_str);\n }\n catch (std::invalid_argument ex)\n {\n fprintf(stderr, \"Invalid argument for pin: %s\\n\", ex.what());\n return 1;\n }\n\n if (pin > 255 || !digitalPinIsValid(pin)) {\n fprintf(stderr, \"%d is not a GPIO pin\\n\", pin);\n return 1;\n }\n\n int mode = INPUT;\n\n if (mode_str.equalsIgnoreCase(\"INPUT\"))\n {\n mode = INPUT;\n }\n else if (mode_str.equalsIgnoreCase(\"OUTPUT\"))\n {\n mode = OUTPUT;\n }\n else if (mode_str.equalsIgnoreCase(\"INPUT_PULLUP\"))\n {\n mode = INPUT_PULLUP;\n }\n else if (mode_str.equalsIgnoreCase(\"INPUT_PULLDOWN\"))\n {\n mode = INPUT_PULLDOWN;\n }\n else if (mode_str.equalsIgnoreCase(\"OUTPUT_OPEN_DRAIN\"))\n {\n mode = OUTPUT_OPEN_DRAIN;\n }\n else\n {\n fprintf(stderr, \"Invalid mode: Allowed modes are INPUT, OUTPUT, INPUT_PULLUP, INPUT_PULLDOWN, OUTPUT_OPEN_DRAIN\\n\");\n }\n\n pinMode(pin, mode);\n printf(\"Mode set successful.\\n\");\n\n return 0;\n}\n\nstatic int _digitalWrite(int argc, char** argv)\n{\n if (argc != 3)\n {\n printf(\"You have to pass an pin number and level. Syntax: digitalWrite [GPIO] [Level]\\n\");\n return 1;\n }\n\n char *pin_str = argv[1];\n String mode_str = String(argv[2]);\n\n unsigned long pin = 0;\n\n try\n {\n pin = std::stoul(pin_str);\n }\n catch (std::invalid_argument ex)\n {\n fprintf(stderr, \"Invalid argument for pin: %s\\n\", ex.what());\n return 1;\n }\n\n if (pin > 255 || !digitalPinCanOutput(pin)) {\n fprintf(stderr, \"%d is not a GPIO pin\\n\", pin);\n return 1;\n }\n\n int mode = LOW;\n\n if (mode_str.equalsIgnoreCase(\"HIGH\") || mode_str.equalsIgnoreCase(\"1\"))\n {\n mode = HIGH;\n }\n else if (mode_str.equalsIgnoreCase(\"LOW\") || mode_str.equalsIgnoreCase(\"0\"))\n {\n mode = LOW;\n } else\n {\n fprintf(stderr, \"Invalid mode: Allowed levels are HIGH, LOW, 0 and 1\\n\");\n }\n\n pinMode(pin, mode);\n printf(\"Output set successful.\\n\");\n\n return 0;\n}\n\nstatic int _digitalRead(int argc, char** argv)\n{\n if (argc != 2)\n {\n printf(\"You have to pass an pin number to read\\n\");\n return 1;\n }\n\n char *pin_str = argv[1];\n\n unsigned long pin = 0;\n\n try\n {\n pin = std::stoul(pin_str);\n }\n catch (std::invalid_argument ex)\n {\n fprintf(stderr, \"Invalid argument for pin: %s\\n\", ex.what());\n return 1;\n }\n\n if (pin > 255 || !digitalPinCanOutput(pin)) {\n fprintf(stderr, \"%d is not a GPIO pin\\n\", pin);\n return 1;\n }\n\n auto level = digitalRead(pin);\n\n if(level == HIGH) {\n printf(\"HIGH\\n\");\n } else if(level == LOW) {\n printf(\"LOW\\n\");\n } else {\n fprintf(stderr, \"Unknown state (%u) of pin %u!\\n\", level, pin);\n return 1;\n }\n\n return 0;\n}\n\nstatic int _analogRead(int argc, char** argv)\n{\n if (argc != 2)\n {\n printf(\"You have to pass an pin number to read\\n\");\n return 1;\n }\n\n char *pin_str = argv[1];\n\n unsigned long pin = 0;\n\n try\n {\n pin = std::stoul(pin_str);\n }\n catch (std::invalid_argument ex)\n {\n fprintf(stderr, \"Invalid argument for pin: %s\\n\", ex.what());\n return 1;\n }\n\n if (pin > 255 || digitalPinToAnalogChannel(pin) == -1) {\n fprintf(stderr, \"%d is not a ADC pin\\n\", pin);\n return 1;\n }\n\n auto value = analogReadMilliVolts(pin);\n \n printf(\"%u mV\\n\", value);\n\n return 0;\n}\n\n\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getPinModeCommand()\n {\n return ConsoleCommand(\"pinMode\", &_pinmode, \"Changes the pinmode of an GPIO pin (similar to Arduino function)\");\n }\n\n const ConsoleCommand getDigitalWriteCommand()\n {\n return ConsoleCommand(\"digitalWrite\", &_digitalWrite, \"Writes the state of an ouput pin (similar to Arduino function)\");\n }\n\n const ConsoleCommand getDigitalReadCommand()\n {\n return ConsoleCommand(\"digitalRead\", &_digitalRead, \"Reads the state of an input pin (similar to Arduino function)\");\n }\n\n const ConsoleCommand getAnalogReadCommand()\n {\n return ConsoleCommand(\"analogRead\", &_analogRead, \"Show the voltage at an analog pin in millivollts.\");\n }\n}" }, { "path": "src/ESP32Console/Commands/GPIOCommands.h", "content": "#pragma once\n\n#include \"ESP32Console/ConsoleCommand.h\"\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getPinModeCommand();\n\n const ConsoleCommand getDigitalWriteCommand();\n\n const ConsoleCommand getDigitalReadCommand();\n\n const ConsoleCommand getAnalogReadCommand();\n}" }, { "path": "src/ESP32Console/Commands/NetworkCommands.cpp", "content": "#include \"./NetworkCommands.h\"\n#include \n\n#include \n#include \n#include \n#include \"lwip/inet.h\"\n#include \"lwip/netdb.h\"\n#include \"lwip/sockets.h\"\n\n#include \n\n#include \"WiFi.h\"\n\nstatic const char *wlstatus2string(wl_status_t status)\n{\n switch (status)\n {\n case WL_NO_SHIELD:\n return \"Not initialized\";\n case WL_CONNECT_FAILED:\n return \"Connection failed\";\n case WL_CONNECTED:\n return \"Connected\";\n case WL_CONNECTION_LOST:\n return \"Connection lost\";\n case WL_DISCONNECTED:\n return \"Disconnected\";\n case WL_IDLE_STATUS:\n return \"Idle status\";\n case WL_NO_SSID_AVAIL:\n return \"No SSID available\";\n case WL_SCAN_COMPLETED:\n return \"Scan completed\";\n default:\n return \"Unknown\";\n }\n}\n\nconst char* wlmode2string(wifi_mode_t mode)\n{\n switch(mode) {\n case WIFI_MODE_NULL:\n return \"Not initialized\";\n case WIFI_MODE_AP:\n return \"Accesspoint\";\n case WIFI_MODE_STA:\n return \"Station\";\n case WIFI_MODE_APSTA:\n return \"Station + Accesspoint\";\n default:\n return \"Unknown\";\n }\n}\n\nstatic void on_ping_success(esp_ping_handle_t hdl, void *args)\n{\n uint8_t ttl;\n uint16_t seqno;\n uint32_t elapsed_time, recv_len;\n ip_addr_t target_addr;\n esp_ping_get_profile(hdl, ESP_PING_PROF_SEQNO, &seqno, sizeof(seqno));\n esp_ping_get_profile(hdl, ESP_PING_PROF_TTL, &ttl, sizeof(ttl));\n esp_ping_get_profile(hdl, ESP_PING_PROF_IPADDR, &target_addr, sizeof(target_addr));\n esp_ping_get_profile(hdl, ESP_PING_PROF_SIZE, &recv_len, sizeof(recv_len));\n esp_ping_get_profile(hdl, ESP_PING_PROF_TIMEGAP, &elapsed_time, sizeof(elapsed_time));\n printf(\"%u bytes from %s icmp_seq=%d ttl=%d time=%u ms\\n\",\n recv_len, inet_ntoa(target_addr.u_addr.ip4), seqno, ttl, elapsed_time);\n}\n\nstatic void on_ping_timeout(esp_ping_handle_t hdl, void *args)\n{\n uint16_t seqno;\n ip_addr_t target_addr;\n esp_ping_get_profile(hdl, ESP_PING_PROF_SEQNO, &seqno, sizeof(seqno));\n esp_ping_get_profile(hdl, ESP_PING_PROF_IPADDR, &target_addr, sizeof(target_addr));\n printf(\"From %s icmp_seq=%u timeout\\n\", inet_ntoa(target_addr.u_addr.ip4), seqno);\n}\n\nstatic void on_ping_end(esp_ping_handle_t hdl, void *args)\n{\n}\n\nstatic int ping(int argc, char **argv)\n{\n //By default do 5 pings\n int number_of_pings = 5;\n\n int opt;\n while ((opt = getopt(argc, argv, \"n:\")) != -1) {\n switch(opt) {\n case 'n':\n number_of_pings = atoi(optarg);\n break;\n case '?':\n printf(\"Unknown option: %c\\n\", optopt);\n break;\n case ':':\n printf(\"Missing arg for %c\\n\", optopt);\n break;\n\n default:\n fprintf(stderr, \"Usage: ping -n 5 [HOSTNAME]\\n\");\n fprintf(stderr, \"-n: The number of pings. 0 means infinite. Can be aborted with Ctrl+D or Ctrl+C.\");\n return 1;\n }\n }\n\n int argind = optind;\n\n //Get hostname\n if (argind >= argc) {\n fprintf(stderr, \"You need to pass an hostname!\\n\");\n return EXIT_FAILURE;\n }\n\n char* hostname = argv[argind];\n\n /* convert hostname to IP address */\n ip_addr_t target_addr;\n struct addrinfo hint;\n struct addrinfo *res = NULL;\n memset(&hint, 0, sizeof(hint));\n memset(&target_addr, 0, sizeof(target_addr));\n auto result = getaddrinfo(hostname, NULL, &hint, &res);\n\n if (result) {\n fprintf(stderr, \"Could not resolve hostname! (getaddrinfo returned %d)\\n\", result);\n return 1;\n }\n\n struct in_addr addr4 = ((struct sockaddr_in *) (res->ai_addr))->sin_addr;\n inet_addr_to_ip4addr(ip_2_ip4(&target_addr), &addr4);\n freeaddrinfo(res);\n\n //Configure ping session\n esp_ping_config_t ping_config = ESP_PING_DEFAULT_CONFIG();\n ping_config.task_stack_size = 4096;\n ping_config.target_addr = target_addr; // target IP address\n ping_config.count = number_of_pings; // 0 means infinite ping\n\n /* set callback functions */\n esp_ping_callbacks_t cbs;\n cbs.on_ping_success = on_ping_success;\n cbs.on_ping_timeout = on_ping_timeout;\n cbs.on_ping_end = on_ping_end;\n //Pass a variable as pointer so the sub tasks can decrease it\n //cbs.cb_args = &number_of_pings_remaining;\n\n esp_ping_handle_t ping;\n esp_ping_new_session(&ping_config, &cbs, &ping);\n\n esp_ping_start(ping);\n\n char c = 0;\n \n uint16_t seqno;\n esp_ping_get_profile(ping, ESP_PING_PROF_SEQNO, &seqno, sizeof(seqno));\n \n //Make stdin input non blocking so we can query for input AND check ping seqno\n int flags = fcntl(fileno(stdin), F_GETFL, 0);\n fcntl(fileno(stdin), F_SETFL, flags | O_NONBLOCK);\n\n //Wait for Ctrl+D or Ctr+C or that our task finishes\n //The async tasks decrease number_of_pings, so wait for it to get to 0\n while((number_of_pings == 0 || seqno < number_of_pings) && c != 4 && c != 3) {\n esp_ping_get_profile(ping, ESP_PING_PROF_SEQNO, &seqno, sizeof(seqno));\n c = getc(stdin);\n delay(50);\n }\n\n //Reset flags, so we dont end up destroying our terminal env later, when linenoise takes over again\n fcntl(fileno(stdin), F_SETFL, flags);\n\n esp_ping_stop(ping);\n //Print total statistics\n uint32_t transmitted;\n uint32_t received;\n uint32_t total_time_ms;\n esp_ping_get_profile(ping, ESP_PING_PROF_REQUEST, &transmitted, sizeof(transmitted));\n esp_ping_get_profile(ping, ESP_PING_PROF_REPLY, &received, sizeof(received));\n esp_ping_get_profile(ping, ESP_PING_PROF_DURATION, &total_time_ms, sizeof(total_time_ms));\n printf(\"%u packets transmitted, %u received, time %u ms\\n\", transmitted, received, total_time_ms);\n\n\n\n esp_ping_delete_session(ping);\n\n return EXIT_SUCCESS;\n}\n\nstatic void ipconfig_wlan()\n{\n printf(\"==== WLAN ====\\n\");\n auto status = WiFi.status();\n printf(\"Mode: %s\\n\", wlmode2string(WiFi.getMode()));\n printf(\"Status: %s\\n\", wlstatus2string(status));\n\n if (status == WL_NO_SHIELD) {\n return;\n }\n \n printf(\"\\n\");\n printf(\"SSID: %s\\n\", WiFi.SSID().c_str());\n printf(\"BSSID: %s\\n\", WiFi.BSSIDstr().c_str());\n printf(\"Channel: %d\\n\", WiFi.channel());\n\n printf(\"\\n\");\n printf(\"IP: %s\\n\", WiFi.localIP().toString().c_str());\n printf(\"Subnet Mask: %s (/%d)\\n\", WiFi.subnetMask().toString().c_str(), WiFi.subnetCIDR());\n printf(\"Gateway: %s\\n\", WiFi.gatewayIP().toString().c_str());\n#if !defined(ESP_ARDUINO_VERSION_MAJOR) || ESP_ARDUINO_VERSION_MAJOR < 3\n printf(\"IPv6: %s\\n\", WiFi.localIPv6().toString().c_str());\n#endif\n \n printf(\"\\n\");\n printf(\"Hostname: %s\\n\", WiFi.getHostname());\n printf(\"DNS1: %s\\n\", WiFi.dnsIP(0).toString().c_str());\n printf(\"DNS2: %s\\n\", WiFi.dnsIP(0).toString().c_str());\n}\n\nstatic int ipconfig(int argc, char **argv)\n{\n ipconfig_wlan();\n return EXIT_SUCCESS;\n}\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getPingCommand()\n {\n return ConsoleCommand(\"ping\", &ping, \"Ping host\");\n }\n\n const ConsoleCommand getIpconfigCommand()\n {\n return ConsoleCommand(\"ipconfig\", &ipconfig, \"Show IP and connection informations\");\n }\n}" }, { "path": "src/ESP32Console/Commands/NetworkCommands.h", "content": "#pragma once\n\n#include \"ESP32Console/ConsoleCommand.h\"\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getPingCommand();\n\n\n const ConsoleCommand getIpconfigCommand();\n}" }, { "path": "src/ESP32Console/Commands/SystemCommands.cpp", "content": "#include \"./SystemCommands.h\"\n#include \"ESP32Console.h\"\n#include \n#include \n#include \n#include \n#if __has_include()\n#include \n#endif\n#if __has_include()\n#include \n#endif\n#include \n\n// For XTSTR macros (Xtensa-specific)\n#if __has_include()\n#include \n#else\n// Provide a fallback stringification macro for non-Xtensa architectures (e.g. RISC-V)\n#ifndef XTSTR\n#define _XTSTR(x) #x\n#define XTSTR(x) _XTSTR(x)\n#endif\n#endif\n\nstatic String mac2String(uint64_t mac)\n{\n byte *ar = (byte *)&mac;\n String s;\n for (byte i = 0; i < 6; ++i)\n {\n char buf[3];\n sprintf(buf, \"%02X\", ar[i]); // J-M-L: slight modification, added the 0 in the format for padding\n s += buf;\n if (i < 5)\n s += ':';\n }\n return s;\n}\n\nstatic const char *getFlashModeStr()\n{\n switch (ESP.getFlashChipMode())\n {\n case FM_DIO:\n return \"DIO\";\n case FM_DOUT:\n return \"DOUT\";\n case FM_FAST_READ:\n return \"FAST READ\";\n case FM_QIO:\n return \"QIO\";\n case FM_QOUT:\n return \"QOUT\";\n case FM_SLOW_READ:\n return \"SLOW READ\";\n case FM_UNKNOWN:\n default:\n return \"UNKNOWN\";\n }\n}\n\nstatic const char *getResetReasonStr()\n{\n switch (esp_reset_reason())\n {\n case ESP_RST_BROWNOUT:\n return \"Brownout reset (software or hardware)\";\n case ESP_RST_DEEPSLEEP:\n return \"Reset after exiting deep sleep mode\";\n case ESP_RST_EXT:\n return \"Reset by external pin (not applicable for ESP32)\";\n case ESP_RST_INT_WDT:\n return \"Reset (software or hardware) due to interrupt watchdog\";\n case ESP_RST_PANIC:\n return \"Software reset due to exception/panic\";\n case ESP_RST_POWERON:\n return \"Reset due to power-on event\";\n case ESP_RST_SDIO:\n return \"Reset over SDIO\";\n case ESP_RST_SW:\n return \"Software reset via esp_restart\";\n case ESP_RST_TASK_WDT:\n return \"Reset due to task watchdog\";\n case ESP_RST_WDT:\n return \"ESP_RST_WDT\";\n\n case ESP_RST_UNKNOWN:\n default:\n return \"Unknown\";\n }\n}\n\nstatic int sysInfo(int argc, char **argv)\n{\n esp_chip_info_t info;\n esp_chip_info(&info);\n\n printf(\"ESP32Console version: %s\\n\", ESP32CONSOLE_VERSION);\n#if defined(ARDUINO_ESP32_GIT_DESC)\n printf(\"Arduino Core version: %s (%x)\\n\", XTSTR(ARDUINO_ESP32_GIT_DESC), ARDUINO_ESP32_GIT_VER);\n#endif\n printf(\"ESP-IDF Version: %s\\n\", ESP.getSdkVersion());\n\n printf(\"\\n\");\n printf(\"Chip info:\\n\");\n printf(\"\\tModel: %s\\n\", ESP.getChipModel());\n printf(\"\\tRevison number: %d\\n\", ESP.getChipRevision());\n printf(\"\\tCores: %d\\n\", ESP.getChipCores());\n printf(\"\\tClock: %d MHz\\n\", ESP.getCpuFreqMHz());\n printf(\"\\tFeatures:%s%s%s%s%s\\r\\n\",\n info.features & CHIP_FEATURE_WIFI_BGN ? \" 802.11bgn \" : \"\",\n info.features & CHIP_FEATURE_BLE ? \" BLE \" : \"\",\n info.features & CHIP_FEATURE_BT ? \" BT \" : \"\",\n info.features & CHIP_FEATURE_EMB_FLASH ? \" Embedded-Flash \" : \" External-Flash \",\n info.features & CHIP_FEATURE_EMB_PSRAM ? \" Embedded-PSRAM\" : \"\");\n\n printf(\"EFuse MAC: %s\\n\", mac2String(ESP.getEfuseMac()).c_str());\n\n printf(\"Flash size: %d MB (mode: %s, speed: %d MHz)\\n\", ESP.getFlashChipSize() / (1024 * 1024), getFlashModeStr(), ESP.getFlashChipSpeed() / (1024 * 1024));\n printf(\"PSRAM size: %d MB\\n\", ESP.getPsramSize() / (1024 * 1024));\n\n printf(\"Sketch size: %d KB\\n\", ESP.getSketchSize() / (1024));\n printf(\"Sketch MD5: %s\\n\", ESP.getSketchMD5().c_str());\n\n#ifndef CONFIG_APP_REPRODUCIBLE_BUILD\n printf(\"Compilation datetime: \" __DATE__ \" \" __TIME__ \"\\n\");\n#endif\n\n printf(\"\\nReset reason: %s\\n\", getResetReasonStr());\n\n printf(\"\\n\");\n printf(\"CPU temperature: %.01f °C\\n\", temperatureRead());\n\n return EXIT_SUCCESS;\n}\n\nstatic int restart(int argc, char **argv)\n{\n printf(\"Restarting...\");\n ESP.restart();\n return EXIT_SUCCESS;\n}\n\nstatic int meminfo(int argc, char **argv)\n{\n uint32_t free = ESP.getFreeHeap() / 1024;\n uint32_t total = ESP.getHeapSize() / 1024;\n uint32_t used = total - free;\n uint32_t min = ESP.getMinFreeHeap() / 1024;\n\n printf(\"Heap: %u KB free, %u KB used, (%u KB total)\\n\", free, used, total);\n printf(\"Minimum free heap size during uptime was: %u KB\\n\", min);\n return EXIT_SUCCESS;\n}\n\nstatic int date(int argc, char **argv)\n{\n bool set_time = false;\n char *target = nullptr;\n\n int c;\n opterr = 0;\n\n // Set timezone from env variable\n tzset();\n\n while ((c = getopt(argc, argv, \"s\")) != -1)\n switch (c)\n {\n case 's':\n set_time = true;\n break;\n case '?':\n printf(\"Unknown option: %c\\n\", optopt);\n return 1;\n case ':':\n printf(\"Missing arg for %c\\n\", optopt);\n return 1;\n }\n\n if (optind < argc)\n {\n target = argv[optind];\n }\n\n if (set_time)\n {\n if (!target)\n {\n fprintf(stderr, \"Set option requires an datetime as argument in format '%Y-%m-%d %H:%M:%S' (e.g. 'date -s \\\"2022-07-13 22:47:00\\\"'\\n\");\n return 1;\n }\n\n tm t;\n\n if (!strptime(target, \"%Y-%m-%d %H:%M:%S\", &t))\n {\n fprintf(stderr, \"Set option requires an datetime as argument in format '%Y-%m-%d %H:%M:%S' (e.g. 'date -s \\\"2022-07-13 22:47:00\\\"'\\n\");\n return 1;\n }\n\n timeval tv = {\n .tv_sec = mktime(&t),\n .tv_usec = 0};\n\n if (settimeofday(&tv, nullptr))\n {\n fprintf(stderr, \"Could not set system time: %s\", strerror(errno));\n return 1;\n }\n\n time_t tmp = time(nullptr);\n\n constexpr int buffer_size = 100;\n char buffer[buffer_size];\n strftime(buffer, buffer_size, \"%a %b %e %H:%M:%S %Z %Y\", localtime(&tmp));\n printf(\"Time set: %s\\n\", buffer);\n\n return 0;\n }\n\n // If no target was supplied put a default one (similar to coreutils date)\n if (!target)\n {\n target = (char*) \"+%a %b %e %H:%M:%S %Z %Y\";\n }\n\n // Ensure the format string is correct\n if (target[0] != '+')\n {\n fprintf(stderr, \"Format string must start with an +!\\n\");\n return 1;\n }\n\n // Ignore + by moving pointer one step forward\n target++;\n\n constexpr int buffer_size = 100;\n char buffer[buffer_size];\n time_t t = time(nullptr);\n strftime(buffer, buffer_size, target, localtime(&t));\n printf(\"%s\\n\", buffer);\n return 0;\n\n return EXIT_SUCCESS;\n}\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getRestartCommand()\n {\n return ConsoleCommand(\"restart\", &restart, \"Restart / Reboot the system\");\n }\n\n const ConsoleCommand getSysInfoCommand()\n {\n return ConsoleCommand(\"sysinfo\", &sysInfo, \"Shows informations about the system like chip model and ESP-IDF version\");\n }\n\n const ConsoleCommand getMemInfoCommand()\n {\n return ConsoleCommand(\"meminfo\", &meminfo, \"Shows information about heap usage\");\n }\n\n const ConsoleCommand getDateCommand()\n {\n return ConsoleCommand(\"date\", &date, \"Shows and modify the system time\");\n }\n}" }, { "path": "src/ESP32Console/Commands/SystemCommands.h", "content": "#pragma once\n\n#include \"ESP32Console/ConsoleCommand.h\"\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getSysInfoCommand();\n\n const ConsoleCommand getRestartCommand();\n\n const ConsoleCommand getMemInfoCommand();\n\n const ConsoleCommand getDateCommand();\n};" }, { "path": "src/ESP32Console/Commands/VFSCommands.cpp", "content": "#include \"./VFSCommands.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"ESP32Console/Helpers/PWDHelpers.h\"\n\n#include \"kilo/kilo.h\"\n\nchar *canonicalize_file_name(const char *path);\n\nint cat(int argc, char **argv)\n{\n if (argc == 1)\n {\n fprintf(stderr, \"You have to pass at least one file path!\\n\");\n return EXIT_SUCCESS;\n }\n\n for (int n = 1; n < argc; n++)\n {\n char filename[PATH_MAX];\n // We have manually do resolving of . and .., as VFS does not do it\n ESP32Console::console_realpath(argv[n], filename);\n\n FILE *file = fopen(filename, \"r\");\n if (file == nullptr)\n {\n fprintf(stderr, \"%s %s : %s\\n\", argv[0], filename,\n strerror(errno));\n return errno;\n }\n\n int chr;\n while ((chr = getc(file)) != EOF)\n fprintf(stdout, \"%c\", chr);\n fclose(file);\n }\n\n return EXIT_SUCCESS;\n}\n\nint pwd(int argc, char **argv)\n{\n printf(\"%s\\n\", ESP32Console::console_getpwd());\n return EXIT_SUCCESS;\n}\n\nint cd(int argc, char **argv)\n{\n const char *path;\n\n if (argc != 2)\n {\n path = getenv(\"HOME\");\n if (!path)\n {\n fprintf(stderr, \"No HOME env variable set!\\n\");\n return EXIT_FAILURE;\n }\n }\n else\n {\n path = argv[1];\n }\n\n // Check if target path is a file\n char resolved[PATH_MAX];\n ESP32Console::console_realpath(path, resolved);\n FILE *file = fopen(resolved, \"r\");\n\n // If we can open it, then we can not chdir into it.\n if (file)\n {\n fclose(file);\n fprintf(stderr, \"Can not cd into a file!\\n\");\n return 1;\n }\n\n if (ESP32Console::console_chdir(path))\n {\n fprintf(stderr, \"Error: %s\\n\", strerror(errno));\n return 1;\n }\n\n const char *pwd = ESP32Console::console_getpwd();\n\n // Check if the new PWD exists, and show a warning if not\n DIR *dir = opendir(pwd);\n if (dir)\n {\n closedir(dir);\n }\n else if (ENOENT == errno)\n {\n fprintf(stderr, \"Choosen directory maybe does not exists!\\n\");\n }\n\n return EXIT_SUCCESS;\n}\n\nint ls(int argc, char **argv)\n{\n char *inpath;\n if (argc == 1)\n {\n inpath = (char *)\".\";\n }\n else if (argc == 2)\n {\n inpath = argv[1];\n }\n else\n {\n printf(\"You can pass only one filename!\\n\");\n return 1;\n }\n\n char path[PATH_MAX];\n ESP32Console::console_realpath(inpath, path);\n\n DIR *dir = opendir(path);\n if (!dir)\n {\n fprintf(stderr, \"Could not open filepath: %s\\n\", strerror(errno));\n return 1;\n }\n\n struct dirent *d;\n while ((d = readdir(dir)) != NULL)\n {\n printf(\"%s\\n\", d->d_name);\n }\n\n closedir(dir);\n return EXIT_SUCCESS;\n}\n\nint mv(int argc, char **argv)\n{\n if (argc != 3)\n {\n fprintf(stderr, \"Syntax is mv [ORIGIN] [TARGET]\\n\");\n return 1;\n }\n\n char old_name[PATH_MAX], new_name[PATH_MAX];\n\n // Resolve arguments to full path\n ESP32Console::console_realpath(argv[1], old_name);\n ESP32Console::console_realpath(argv[2], new_name);\n\n // Do rename\n if (rename(old_name, new_name))\n {\n printf(\"Error moving: %s\\n\", strerror(errno));\n return EXIT_FAILURE;\n }\n\n return EXIT_SUCCESS;\n}\n\nint cp(int argc, char **argv)\n{\n //TODO: Shows weird error message\n if (argc != 3)\n {\n fprintf(stderr, \"Syntax is cp [ORIGIN] [TARGET]\\n\");\n return 1;\n }\n\n char old_name[PATH_MAX], new_name[PATH_MAX];\n\n // Resolve arguments to full path\n ESP32Console::console_realpath(argv[1], old_name);\n ESP32Console::console_realpath(argv[2], new_name);\n\n // Do copy\n FILE *origin = fopen(old_name, \"r\");\n if (!origin)\n {\n fprintf(stderr, \"Error opening origin file: %s\\n\", strerror(errno));\n return 1;\n }\n\n FILE *target = fopen(new_name, \"w\");\n if (!target)\n {\n fclose(origin);\n fprintf(stderr, \"Error opening target file: %s\\n\", strerror(errno));\n return 1;\n }\n\n int buffer;\n\n // Clear existing errors\n auto error = errno;\n\n while ((buffer = getc(origin)) != EOF)\n {\n if(fputc(buffer, target) == EOF) {\n fprintf(stderr, \"Error writing: %s\\n\", strerror(errno));\n fclose(origin); fclose(target);\n return 1;\n }\n }\n\n error = errno;\n if (error && !feof(origin))\n {\n fprintf(stderr, \"Error copying: %s\\n\", strerror(error));\n fclose(origin);\n fclose(target);\n return 1;\n }\n\n fclose(origin);\n fclose(target);\n\n return EXIT_SUCCESS;\n}\n\nint rm(int argc, char **argv)\n{\n if (argc != 2)\n {\n fprintf(stderr, \"You have to pass exactly one file. Syntax rm [FIILE]\\n\");\n return EXIT_SUCCESS;\n }\n\n char filename[PATH_MAX];\n ESP32Console::console_realpath(argv[1], filename);\n\n if(unlink(filename)) {\n fprintf(stderr, \"Error deleting %s: %s\\n\", filename, strerror(errno));\n }\n\n return EXIT_SUCCESS;\n}\n\nint rmdir(int argc, char **argv)\n{\n if (argc != 2)\n {\n fprintf(stderr, \"You have to pass exactly one file. Syntax rmdir [FIILE]\\n\");\n return EXIT_SUCCESS;\n }\n\n char filename[PATH_MAX];\n ESP32Console::console_realpath(argv[1], filename);\n\n if(rmdir(filename)) {\n fprintf(stderr, \"Error deleting %s: %s\\n\", filename, strerror(errno));\n }\n\n return EXIT_SUCCESS;\n}\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getCatCommand()\n {\n return ConsoleCommand(\"cat\", &cat, \"Show the content of one or more files.\");\n }\n\n const ConsoleCommand getPWDCommand()\n {\n return ConsoleCommand(\"pwd\", &pwd, \"Show the current working dir\");\n }\n\n const ConsoleCommand getCDCommand()\n {\n return ConsoleCommand(\"cd\", &cd, \"Change the working directory\");\n }\n\n const ConsoleCommand getLsCommand()\n {\n return ConsoleCommand(\"ls\", &ls, \"List the contents of the given path\");\n }\n\n const ConsoleCommand getMvCommand()\n {\n return ConsoleCommand(\"mv\", &mv, \"Move the given file to another place or name\");\n }\n\n const ConsoleCommand getCPCommand()\n {\n return ConsoleCommand(\"cp\", &cp, \"Copy the given file to another place or name\");\n }\n\n const ConsoleCommand getRMCommand()\n {\n return ConsoleCommand(\"rm\", &rm, \"Permanenty deletes the given file.\");\n }\n\n const ConsoleCommand getRMDirCommand()\n {\n return ConsoleCommand(\"rmdir\", &rmdir, \"Permanenty deletes the given folder. Folder must be empty!\");\n }\n\n const ConsoleCommand getEditCommand()\n {\n return ConsoleCommand(\"edit\", &ESP32Console::Kilo::kilo, \"Edit files\");\n }\n}" }, { "path": "src/ESP32Console/Commands/VFSCommands.h", "content": "#pragma once\n\n#include \"ESP32Console/ConsoleCommand.h\"\n\nnamespace ESP32Console::Commands\n{\n const ConsoleCommand getCatCommand();\n\n const ConsoleCommand getPWDCommand();\n\n const ConsoleCommand getCDCommand();\n\n const ConsoleCommand getLsCommand();\n\n const ConsoleCommand getMvCommand();\n\n const ConsoleCommand getCPCommand();\n\n const ConsoleCommand getRMCommand();\n\n const ConsoleCommand getRMDirCommand();\n\n const ConsoleCommand getEditCommand();\n}" }, { "path": "src/ESP32Console/Console.cpp", "content": "#include \"./Console.h\"\n#include \"soc/soc_caps.h\"\n#include \"esp_err.h\"\n#include \"esp_idf_version.h\"\n#include \"ESP32Console/Commands/CoreCommands.h\"\n#include \"ESP32Console/Commands/SystemCommands.h\"\n#include \"ESP32Console/Commands/NetworkCommands.h\"\n#include \"ESP32Console/Commands/VFSCommands.h\"\n#include \"ESP32Console/Commands/GPIOCommands.h\"\n#include \"driver/uart.h\"\n#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)\n#include \"driver/uart_vfs.h\"\n#else\n#include \"esp_vfs_dev.h\"\n#endif\n#include \"linenoise/linenoise.h\"\n#include \"ESP32Console/Helpers/PWDHelpers.h\"\n#include \"ESP32Console/Helpers/InputParser.h\"\n\nstatic const char *TAG = \"ESP32Console\";\n\nusing namespace ESP32Console::Commands;\n\nnamespace ESP32Console\n{\n void Console::registerCoreCommands()\n {\n registerCommand(getClearCommand());\n registerCommand(getHistoryCommand());\n registerCommand(getEchoCommand());\n registerCommand(getSetMultilineCommand());\n registerCommand(getEnvCommand());\n registerCommand(getDeclareCommand());\n }\n\n void Console::registerSystemCommands()\n {\n registerCommand(getSysInfoCommand());\n registerCommand(getRestartCommand());\n registerCommand(getMemInfoCommand());\n registerCommand(getDateCommand());\n }\n\n void ESP32Console::Console::registerNetworkCommands()\n {\n registerCommand(getPingCommand());\n registerCommand(getIpconfigCommand());\n }\n\n void Console::registerVFSCommands()\n {\n registerCommand(getCatCommand());\n registerCommand(getCDCommand());\n registerCommand(getPWDCommand());\n registerCommand(getLsCommand());\n registerCommand(getMvCommand());\n registerCommand(getCPCommand());\n registerCommand(getRMCommand());\n registerCommand(getRMDirCommand());\n registerCommand(getEditCommand());\n }\n\n void Console::registerGPIOCommands()\n {\n registerCommand(getPinModeCommand());\n registerCommand(getDigitalReadCommand());\n registerCommand(getDigitalWriteCommand());\n registerCommand(getAnalogReadCommand());\n }\n\n void Console::beginCommon()\n {\n /* Tell linenoise where to get command completions and hints */\n linenoiseSetCompletionCallback(&esp_console_get_completion);\n linenoiseSetHintsCallback((linenoiseHintsCallback *)&esp_console_get_hint);\n\n /* Set command history size */\n linenoiseHistorySetMaxLen(max_history_len_);\n\n /* Set command maximum length */\n linenoiseSetMaxLineLen(max_cmdline_len_);\n\n // Load history if defined\n if (history_save_path_)\n {\n linenoiseHistoryLoad(history_save_path_);\n }\n\n // Register core commands like echo\n esp_console_register_help_command();\n registerCoreCommands();\n }\n\n void Console::begin(int baud, int rxPin, int txPin, uart_port_t channel)\n {\n log_d(\"Initialize console\");\n\n if (channel >= SOC_UART_NUM)\n {\n log_e(\"Serial number is invalid, please use numers from 0 to %u\", SOC_UART_NUM - 1);\n return;\n }\n\n this->uart_channel_ = channel;\n\n //Reinit the UART driver if the channel was already in use\n if (uart_is_driver_installed(channel)) {\n uart_driver_delete(channel);\n }\n\n /* Drain stdout before reconfiguring it */\n fflush(stdout);\n fsync(fileno(stdout));\n\n /* Disable buffering on stdin */\n setvbuf(stdin, NULL, _IONBF, 0);\n\n /* Minicom, screen, idf_monitor send CR when ENTER key is pressed */\n#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)\n uart_vfs_dev_port_set_rx_line_endings(channel, ESP_LINE_ENDINGS_CR);\n /* Move the caret to the beginning of the next line on '\\n' */\n uart_vfs_dev_port_set_tx_line_endings(channel, ESP_LINE_ENDINGS_CRLF);\n#else\n esp_vfs_dev_uart_port_set_rx_line_endings(channel, ESP_LINE_ENDINGS_CR);\n /* Move the caret to the beginning of the next line on '\\n' */\n esp_vfs_dev_uart_port_set_tx_line_endings(channel, ESP_LINE_ENDINGS_CRLF);\n#endif\n\n /* Configure UART. Note that REF_TICK is used so that the baud rate remains\n * correct while APB frequency is changing in light sleep mode.\n */\n const uart_config_t uart_config = {\n .baud_rate = baud,\n .data_bits = UART_DATA_8_BITS,\n .parity = UART_PARITY_DISABLE,\n .stop_bits = UART_STOP_BITS_1,\n#if SOC_UART_SUPPORT_REF_TICK\n .source_clk = UART_SCLK_REF_TICK,\n#elif SOC_UART_SUPPORT_XTAL_CLK\n .source_clk = UART_SCLK_XTAL,\n#endif\n };\n \n\n ESP_ERROR_CHECK(uart_param_config(channel, &uart_config));\n\n // Set the correct pins for the UART of needed\n if (rxPin > 0 || txPin > 0) {\n if (rxPin < 0 || txPin < 0) {\n log_e(\"Both rxPin and txPin has to be passed!\");\n }\n uart_set_pin(channel, txPin, rxPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);\n }\n\n /* Install UART driver for interrupt-driven reads and writes */\n ESP_ERROR_CHECK(uart_driver_install(channel, 256, 0, 0, NULL, 0));\n\n /* Tell VFS to use UART driver */\n#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)\n uart_vfs_dev_use_driver(channel);\n#else\n esp_vfs_dev_uart_use_driver(channel);\n#endif\n\n esp_console_config_t console_config = {\n .max_cmdline_length = max_cmdline_len_,\n .max_cmdline_args = max_cmdline_args_,\n .hint_color = 333333};\n\n ESP_ERROR_CHECK(esp_console_init(&console_config));\n\n beginCommon();\n\n // Start REPL task\n if (xTaskCreate(&Console::repl_task, \"console_repl\", 4096, this, 2, &task_) != pdTRUE)\n {\n log_e(\"Could not start REPL task!\");\n }\n }\n\n static void resetAfterCommands()\n {\n //Reset all global states a command could change\n\n //Reset getopt parameters\n optind = 0;\n }\n\n void Console::repl_task(void *args)\n {\n Console const &console = *(static_cast(args));\n\n /* Change standard input and output of the task if the requested UART is\n * NOT the default one. This block will replace stdin, stdout and stderr.\n * We have to do this in the repl task (not in the begin, as these settings are only valid for the current task)\n */\n if (console.uart_channel_ != CONFIG_ESP_CONSOLE_UART_NUM)\n {\n char path[13] = {0};\n snprintf(path, 13, \"/dev/uart/%d\", console.uart_channel_);\n\n stdin = fopen(path, \"r\");\n stdout = fopen(path, \"w\");\n stderr = stdout;\n }\n\n setvbuf(stdin, NULL, _IONBF, 0);\n\n /* This message shall be printed here and not earlier as the stdout\n * has just been set above. */\n printf(\"\\r\\n\"\n \"Type 'help' to get the list of commands.\\r\\n\"\n \"Use UP/DOWN arrows to navigate through command history.\\r\\n\"\n \"Press TAB when typing command name to auto-complete.\\r\\n\");\n\n // Probe terminal status\n int probe_status = linenoiseProbe();\n if (probe_status)\n {\n linenoiseSetDumbMode(1);\n }\n\n if (linenoiseIsDumbMode())\n {\n printf(\"\\r\\n\"\n \"Your terminal application does not support escape sequences.\\n\\n\"\n \"Line editing and history features are disabled.\\n\\n\"\n \"On Windows, try using Putty instead.\\r\\n\");\n }\n\n linenoiseSetMaxLineLen(console.max_cmdline_len_);\n while (1)\n {\n String prompt = console.prompt_;\n\n // Insert current PWD into prompt if needed\n prompt.replace(\"%pwd%\", console_getpwd());\n\n char *line = linenoise(prompt.c_str());\n if (line == NULL)\n {\n ESP_LOGD(TAG, \"empty line\");\n /* Ignore empty lines */\n continue;\n }\n\n log_v(\"Line received from linenoise: %s\\n\", line);\n\n /* Add the command to the history */\n linenoiseHistoryAdd(line);\n \n /* Save command history to filesystem */\n if (console.history_save_path_)\n {\n linenoiseHistorySave(console.history_save_path_);\n }\n\n //Interpolate the input line\n String interpolated_line = interpolateLine(line);\n log_v(\"Interpolated line: %s\\n\", interpolated_line.c_str());\n\n /* Try to run the command */\n int ret;\n esp_err_t err = esp_console_run(interpolated_line.c_str(), &ret);\n \n //Reset global state\n resetAfterCommands();\n\n if (err == ESP_ERR_NOT_FOUND)\n {\n printf(\"Unrecognized command\\n\");\n }\n else if (err == ESP_ERR_INVALID_ARG)\n {\n // command was empty\n }\n else if (err == ESP_OK && ret != ESP_OK)\n {\n printf(\"Command returned non-zero error code: 0x%x (%s)\\n\", ret, esp_err_to_name(ret));\n }\n else if (err != ESP_OK)\n {\n printf(\"Internal error: %s\\n\", esp_err_to_name(err));\n }\n /* linenoise allocates line buffer on the heap, so need to free it */\n linenoiseFree(line);\n }\n ESP_LOGD(TAG, \"REPL task ended\");\n vTaskDelete(NULL);\n }\n\n void Console::end()\n {\n }\n};" }, { "path": "src/ESP32Console/Console.h", "content": "#pragma once\n\n#if !defined(ESP32)\n#error This library depends on ESP-IDF and only works on ESP32!\n#endif\n\n#include \"esp_console.h\"\n#include \"Arduino.h\"\n#include \"./ConsoleCommandBase.h\"\n#include \"freertos/task.h\"\n#include \"linenoise/linenoise.h\"\n#include \"driver/uart.h\"\n\nnamespace ESP32Console\n{\n class Console\n {\n private:\n const char *prompt_ = \"ESP32> \";\n const uint32_t task_priority_;\n const BaseType_t task_stack_size_;\n\n uint16_t max_history_len_ = 40;\n const char* history_save_path_ = nullptr;\n\n const size_t max_cmdline_len_;\n const size_t max_cmdline_args_;\n\n uart_port_t uart_channel_;\n\n TaskHandle_t task_;\n\n static void repl_task(void *args);\n\n void beginCommon();\n\n public:\n /**\n * @brief Create a new ESP32Console with the default parameters\n */\n Console(const uint32_t task_stack_size = 4096, const BaseType_t task_priority = 2, int max_cmdline_len = 256, int max_cmdline_args = 32) : task_priority_(task_priority), task_stack_size_(task_stack_size), max_cmdline_len_(max_cmdline_len), max_cmdline_args_(max_cmdline_args){};\n\n ~Console()\n {\n vTaskDelete(task_);\n end();\n }\n\n /**\n * @brief Register the given command, using the raw ESP-IDF structure.\n *\n * @param cmd The command that should be registered\n * @return Return true, if the registration was successfull, false if not.\n */\n bool registerCommand(const esp_console_cmd_t *cmd)\n {\n log_v(\"Registering new command %s\", cmd->command);\n\n auto code = esp_console_cmd_register(cmd);\n if (code != ESP_OK)\n {\n log_e(\"Error registering command (Reason %s)\", esp_err_to_name(code));\n return false;\n }\n\n return true;\n }\n\n /**\n * @brief Register the given command\n *\n * @param cmd The command that should be registered\n * @return true If the command was registered successful.\n * @return false If the command was not registered because of an error.\n */\n bool registerCommand(const ConsoleCommandBase &cmd)\n {\n auto c = cmd.toCommandStruct();\n return registerCommand(&c);\n }\n\n /**\n * @brief Registers the given command\n *\n * @param command The name under which the command can be called (e.g. \"ls\"). Must not contain spaces.\n * @param func A pointer to the function which should be run, when this command is called\n * @param help A text shown in output of \"help\" command describing this command. When empty it is not shown in help.\n * @param hint A text describing the usage of the command in help output\n * @return true If the command was registered successful.\n * @return false If the command was not registered because of an error.\n */\n bool registerCommand(const char *command, esp_console_cmd_func_t func, const char *help, const char *hint = \"\")\n {\n const esp_console_cmd_t cmd = {\n .command = command,\n .help = help,\n .hint = hint,\n .func = func,\n .argtable = nullptr\n };\n\n return registerCommand(&cmd);\n };\n\n void registerCoreCommands();\n\n void registerSystemCommands();\n\n void registerNetworkCommands();\n\n void registerVFSCommands();\n\n void registerGPIOCommands();\n\n /**\n * @brief Set the command prompt. Default is \"ESP32>\".\n *\n * @param prompt\n */\n void setPrompt(const char *prompt) { prompt_ = prompt; };\n\n /**\n * @brief Set the History Max Length object\n * \n * @param max_length \n */\n void setHistoryMaxLength(uint16_t max_length)\n {\n max_history_len_ = max_length;\n linenoiseHistorySetMaxLen(max_length);\n }\n\n /**\n * @brief Enable saving of command history, which makes history persistent over resets. SPIFF need to be enabled, or you need to pass the filename to use.\n *\n * @param history_save_path The file which will be used to save command history. Set to nullptr to disable persistent saving\n */\n void enablePersistentHistory(const char *history_save_path = \"/spiffs/.history.txt\") { history_save_path_ = history_save_path; };\n\n /**\n * @brief Starts the console. Similar to the Serial.begin() function\n * \n * @param baud The baud rate with which the console should work. Recommended: 115200\n * @param rxPin The pin to use for RX\n * @param txPin The pin to use for TX\n * @param channel The UART port to use\n */\n void begin(int baud, int rxPin = -1, int txPin = -1, uart_port_t channel = UART_NUM_0);\n\n /**\n * @brief Starts the console. Overload for backward compatibility with uint8_t channel argument.\n *\n * @param baud The baud rate with which the console should work. Recommended: 115200\n * @param rxPin The pin to use for RX\n * @param txPin The pin to use for TX\n * @param channel The number of the UART to use (cast to uart_port_t)\n */\n void begin(int baud, int rxPin, int txPin, uint8_t channel)\n {\n begin(baud, rxPin, txPin, static_cast(channel));\n }\n\n void end();\n };\n};" }, { "path": "src/ESP32Console/ConsoleCommand.h", "content": "#pragma once\n\n#include \"./ConsoleCommandBase.h\"\n\nnamespace ESP32Console\n{\n\n /**\n * @brief A class for registering custom console commands via a passed function pointer.\n * \n */\n class ConsoleCommand : public ConsoleCommandBase\n {\n protected:\n const char *hint_;\n\n public:\n /**\n * @brief Creates a new ConsoleCommand object with the given parameters.\n * \n * @param command The name under which the command will be called (e.g. \"ls\"). Must not contain spaces.\n * @param func The pointer to the function which is run if this function is called. Takes two paramaters argc and argv, similar to a classical C program.\n * @param help The text shown in \"help\" output for this command. If set to empty string, then the command is not shown in help.\n * @param hint A hint explaining the parameters in help output\n */\n ConsoleCommand(const char *command, esp_console_cmd_func_t func, const char* help, const char* hint = \"\") { command_ = command; func_ = func; help_= help; hint_ = hint;};\n\n const esp_console_cmd_t toCommandStruct() const override\n {\n const esp_console_cmd_t cmd = {\n .command = command_,\n .help = help_,\n .hint = hint_,\n .func = func_,\n .argtable = nullptr\n };\n\n return cmd;\n }\n };\n};" }, { "path": "src/ESP32Console/ConsoleCommandBase.h", "content": "#pragma once\n\n#include \"esp_console.h\"\n\nnamespace ESP32Console {\n class ConsoleCommandBase\n {\n protected:\n const char *command_;\n const char *help_;\n esp_console_cmd_func_t func_;\n\n public:\n /**\n * @brief Get the command name\n * \n * @return const char* \n */\n const char* getCommand() { return command_; };\n\n const char* getHelp() { return help_; };\n\n virtual const esp_console_cmd_t toCommandStruct() const = 0; \n };\n};" }, { "path": "src/ESP32Console/ConsoleCommandD.cpp", "content": "#include \"./ConsoleCommandD.h\"\n#include \"Arduino.h\"\n\nconst static char *TAG = \"ConsoleCommandD\";\n\nnamespace ESP32Console\n{\n std::unordered_map ConsoleCommandD::registry_ = std::unordered_map();\n\n int ConsoleCommandD::delegateResolver(int argc, char **argv)\n {\n // Retrieve ConsoleCommandD from registry\n auto it = registry_.find(argv[0]);\n if (it == registry_.end())\n {\n log_e(\"Could not resolve the delegated function call!\");\n return 1;\n }\n\n delegateFunc command = it->second;\n\n int code = 0;\n\n try\n {\n return command(argc, argv);\n }\n catch (const std::exception &err)\n {\n printf(\"%s\", err.what());\n printf(\"\\n\");\n return 1;\n }\n }\n}" }, { "path": "src/ESP32Console/ConsoleCommandD.h", "content": "#pragma once\n\n#include \"./ConsoleCommand.h\"\n#include \"esp_console.h\"\n#include \n#include \n#include \n\n#include \n\nnamespace ESP32Console\n{\n using delegateFunc = std::function;\n\n /**\n * @brief A class for registering custom console commands via delegate function element. The difference to ConsoleCommand is that you can pass a std::function object instead of a function pointer directly.\n * This allows for use of lambda functions. The disadvantage is that we need more heap, as we have to save the delegate function objects in a map.\n * \n */\n class ConsoleCommandD : public ConsoleCommand\n {\n protected:\n delegateFunc delegateFn_;\n\n static int delegateResolver(int argc, char **argv);\n\n public:\n static std::unordered_map registry_;\n \n ConsoleCommandD(const char *command, delegateFunc func, const char* help, const char* hint = \"\"): ConsoleCommand(command, &delegateResolver, help, hint), delegateFn_(func) {};\n\n const esp_console_cmd_t toCommandStruct() const override\n {\n const esp_console_cmd_t cmd = {\n .command = command_,\n .help = help_,\n .hint = hint_,\n .func = func_,\n .argtable = nullptr\n };\n\n // When the command gets registered add it to our map, so we can access it later to resolve the delegated function call\n registry_.insert({std::string(command_), std::move(delegateFn_)});\n\n return cmd;\n }\n\n delegateFunc &getDelegateFunction() { return delegateFn_; }\n };\n\n}" }, { "path": "src/ESP32Console/Helpers/InputParser.cpp", "content": "#include \"./InputParser.h\"\n\n#include \n\nnamespace ESP32Console\n{\n String interpolateLine(const char *in_)\n {\n String in(in_);\n String out = in;\n\n // Add a space at end of line, this does not change anything for our consoleLine and makes parsing easier\n in = in + \" \";\n\n // Interpolate each $ with the env variable if existing. If $ is the first character in a line it is not interpolated\n int var_index = 1;\n while ((var_index = in.indexOf(\"$\", var_index + 1)) > 0)\n {\n /**\n * Extract the possible env variable\n */\n int variable_start = var_index + 1;\n // If the char after $ is a { we look for an closing }. Otherwise we just look for an space\n char delimiter = ' ';\n if (in.charAt(variable_start) == '{')\n {\n // Our variable starts then at the character after ${\n variable_start++;\n }\n\n int variable_end = in.indexOf(delimiter, variable_start + 1);\n // If delimiter not found look for next possible env variable\n if (variable_end == -1)\n {\n continue;\n }\n\n String env_var = in.substring(variable_start, variable_end);\n env_var.trim();\n // Depending on whether this is an variable string, we have to include the next character\n String replace_target = in.substring(var_index, delimiter == '}' ? variable_end + 1 : variable_end);\n\n // Check if we have an env with this name, then replace it\n const char *value = getenv(env_var.c_str());\n if (value)\n {\n out.replace(replace_target.c_str(), value);\n }\n }\n\n return out.c_str();\n }\n}" }, { "path": "src/ESP32Console/Helpers/InputParser.h", "content": "#pragma once\n#include \n\nnamespace ESP32Console\n{\n /**\n * @brief Interpolate the given line using environment variables. $VAR and ${ENV} are replaced by the representive values of the environment variables.\n * \n * @param in \n * @return String\n */\n String interpolateLine(const char *in);\n}" }, { "path": "src/ESP32Console/Helpers/PWDHelpers.cpp", "content": "#include \"ESP32Console/Helpers/PWDHelpers.h\"\n\n#include \n#include \n#include \n\nnamespace ESP32Console\n{\n constexpr char *PWD_DEFAULT = (char*) \"/\";\n\n const char *console_getpwd()\n {\n char *pwd = getenv(\"PWD\");\n if (pwd)\n { // If we have defined a PWD value, return it\n return pwd;\n }\n\n // Otherwise set a default one\n setenv(\"PWD\", PWD_DEFAULT, 1);\n return PWD_DEFAULT;\n }\n\n const char *console_realpath(const char *path, char *resolvedPath)\n {\n String in = String(path);\n String pwd = String(console_getpwd());\n String result;\n // If path is not absolute we prepend our pwd\n if (!in.startsWith(\"/\"))\n {\n result = pwd + \"/\" + in;\n }\n else\n {\n result = in;\n }\n \n realpath(result.c_str(), resolvedPath);\n return resolvedPath;\n }\n\n int console_chdir(const char *path)\n {\n char buffer[PATH_MAX + 2];\n console_realpath(path, buffer);\n\n size_t buffer_len = strlen(buffer);\n //If path does not end with slash, add it.\n if(buffer[buffer_len - 1] != '/')\n {\n buffer[buffer_len] = '/';\n buffer[buffer_len + 1] = '\\0';\n }\n\n setenv(\"PWD\", buffer, 1);\n\n return 0;\n }\n\n}" }, { "path": "src/ESP32Console/Helpers/PWDHelpers.h", "content": "#pragma once\n\nnamespace ESP32Console\n{\n\n /**\n * @brief Returns the current console process working dir\n *\n * @return const char*\n */\n const char *console_getpwd();\n\n /**\n * @brief Resolves the given path using the console process working dir\n *\n * @return const char*\n */\n const char *console_realpath(const char *path, char *resolvedPath);\n\n int console_chdir(const char *path);\n\n}" }, { "path": "src/ESP32Console/OptionsConsoleCommand.cpp", "content": "#include \"./OptionsConsoleCommand.h\"\n#include \"Arduino.h\"\n\nconst static char *TAG = \"ArgParseCommand\";\n\nnamespace ESP32Console\n{\n std::unordered_map OptionsConsoleCommand::registry_ = std::unordered_map();\n\n int OptionsConsoleCommand::delegateResolver(int argc, char **argv)\n {\n // Retrieve ArgParserCommand from registry\n auto it = registry_.find(argv[0]);\n if (it == registry_.end())\n {\n log_e(\"Could not resolve the delegated function call!\");\n return 1;\n }\n\n auto command = it->second;\n\n int code = 0;\n\n try\n {\n auto options = command.options;\n auto result = options.parse(argc, argv);\n\n //Print help on --help argument\n if (result.count(\"help\")) {\n printf(options.help().c_str());\n printf(\"\\n\");\n return EXIT_SUCCESS;\n }\n\n if (command.getVersion() && result.count(\"version\")) {\n printf(\"Version: %s\\n\", command.getVersion());\n return EXIT_SUCCESS;\n }\n\n return command.delegateFn_(argc, argv, result, options);\n }\n catch (const std::exception &err)\n {\n printf(err.what());\n printf(\"\\n\");\n return EXIT_FAILURE;\n }\n }\n}\n" }, { "path": "src/ESP32Console/OptionsConsoleCommand.h", "content": "#pragma once\n\n#include \"./ConsoleCommandBase.h\"\n\n#include \"esp_console.h\"\n\n//This define is important, otherwise we get very high memory usage from regex\n#define CXXOPTS_NO_REGEX 1\n#define CXXOPTS_NO_RTTI 1\n#include \"cxxopts/cxxopts.hpp\"\n#include \n#include \n#include \n\nnamespace ESP32Console\n{\n using cxxopts::Options;\n using cxxopts::ParseResult;\n using argParseFunc = std::function;\n\n class OptionsConsoleCommand : public ConsoleCommandBase\n {\n protected:\n argParseFunc delegateFn_;\n const char *hint_;\n const char *version_;\n\n static int delegateResolver(int argc, char **argv);\n\n public:\n Options options;\n static std::unordered_map registry_;\n\n OptionsConsoleCommand(const char *command, argParseFunc func, const char *help, const char* version = nullptr, const char *hint = nullptr): options(command, help)\n {\n command_ = command;\n help_ = help;\n version_ = version;\n\n if (hint)\n {\n hint_ = hint;\n }\n else\n {\n hint_ = \"Use --help option of command for more info\";\n }\n\n //Add an option \n options.add_options()\n (\"help\", \"Show help\", cxxopts::value()->default_value(\"false\"))\n ;\n\n if (version_)\n {\n options.add_options()\n (\"version\", \"Show version number of this command\", cxxopts::value()->default_value(\"false\"))\n ;\n }\n\n\n\n delegateFn_ = func;\n func_ = &delegateResolver;\n }\n\n const esp_console_cmd_t toCommandStruct() const override\n {\n const esp_console_cmd_t cmd = {\n .command = command_,\n .help = help_,\n .hint = hint_,\n .func = func_,\n .argtable = nullptr\n };\n\n // When the command gets registered add it to our map, so we can access it later to resolve the delegated function call\n registry_.insert({std::string(command_), std::move(*this)});\n\n return cmd;\n }\n\n argParseFunc &getDelegateFunction() { return delegateFn_; }\n\n const char* getVersion() const {return version_;};\n };\n}" }, { "path": "src/ESP32Console.h", "content": "#pragma once\n\n#if !defined(ESP32)\n#error This library depends on ESP-IDF and only works on ESP32!\n#endif\n\n#define ESP32CONSOLE_VERSION \"1.3.0\"\n\n#include \"ESP32Console/Console.h\"\n#include \"ESP32Console/ConsoleCommand.h\"\n#include \"ESP32Console/ConsoleCommandD.h\"\n#include \"ESP32Console/OptionsConsoleCommand.h\"\n" }, { "path": "src/cxxopts/cxxopts.hpp", "content": "/*\n\nCopyright (c) 2014, 2015, 2016, 2017 Jarryd Beck\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n*/\n\n#ifndef CXXOPTS_HPP_INCLUDED\n#define CXXOPTS_HPP_INCLUDED\n\n#include \n#include \n#include \n//#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#if defined(__GNUC__) && !defined(__clang__)\n# if (__GNUC__ * 10 + __GNUC_MINOR__) < 49\n# define CXXOPTS_NO_REGEX true\n# endif\n#endif\n\n#ifndef CXXOPTS_NO_REGEX\n# include \n#endif // CXXOPTS_NO_REGEX\n\n// Nonstandard before C++17, which is coincidentally what we also need for \n#ifdef __has_include\n# if __has_include()\n# include \n# ifdef __cpp_lib_optional\n# define CXXOPTS_HAS_OPTIONAL\n# endif\n# endif\n#endif\n\n#if __cplusplus >= 201603L\n#define CXXOPTS_NODISCARD [[nodiscard]]\n#else\n#define CXXOPTS_NODISCARD\n#endif\n\n#ifndef CXXOPTS_VECTOR_DELIMITER\n#define CXXOPTS_VECTOR_DELIMITER ','\n#endif\n\n#define CXXOPTS__VERSION_MAJOR 3\n#define CXXOPTS__VERSION_MINOR 0\n#define CXXOPTS__VERSION_PATCH 0\n\n#if (__GNUC__ < 10 || (__GNUC__ == 10 && __GNUC_MINOR__ < 1)) && __GNUC__ >= 6\n #define CXXOPTS_NULL_DEREF_IGNORE\n#endif\n\nnamespace cxxopts\n{\n static constexpr struct {\n uint8_t major, minor, patch;\n } version = {\n CXXOPTS__VERSION_MAJOR,\n CXXOPTS__VERSION_MINOR,\n CXXOPTS__VERSION_PATCH\n };\n} // namespace cxxopts\n\n//when we ask cxxopts to use Unicode, help strings are processed using ICU,\n//which results in the correct lengths being computed for strings when they\n//are formatted for the help output\n//it is necessary to make sure that can be found by the\n//compiler, and that icu-uc is linked in to the binary.\n\n#ifdef CXXOPTS_USE_UNICODE\n#include \n\nnamespace cxxopts\n{\n using String = icu::UnicodeString;\n\n inline\n String\n toLocalString(std::string s)\n {\n return icu::UnicodeString::fromUTF8(std::move(s));\n }\n\n#if defined(__GNUC__)\n// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we want to silence it:\n// warning: base class 'class std::enable_shared_from_this' has accessible non-virtual destructor\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wnon-virtual-dtor\"\n#pragma GCC diagnostic ignored \"-Weffc++\"\n// This will be ignored under other compilers like LLVM clang.\n#endif\n class UnicodeStringIterator : public\n std::iterator\n {\n public:\n\n UnicodeStringIterator(const icu::UnicodeString* string, int32_t pos)\n : s(string)\n , i(pos)\n {\n }\n\n value_type\n operator*() const\n {\n return s->char32At(i);\n }\n\n bool\n operator==(const UnicodeStringIterator& rhs) const\n {\n return s == rhs.s && i == rhs.i;\n }\n\n bool\n operator!=(const UnicodeStringIterator& rhs) const\n {\n return !(*this == rhs);\n }\n\n UnicodeStringIterator&\n operator++()\n {\n ++i;\n return *this;\n }\n\n UnicodeStringIterator\n operator+(int32_t v)\n {\n return UnicodeStringIterator(s, i + v);\n }\n\n private:\n const icu::UnicodeString* s;\n int32_t i;\n };\n#if defined(__GNUC__)\n#pragma GCC diagnostic pop\n#endif\n\n inline\n String&\n stringAppend(String&s, String a)\n {\n return s.append(std::move(a));\n }\n\n inline\n String&\n stringAppend(String& s, size_t n, UChar32 c)\n {\n for (size_t i = 0; i != n; ++i)\n {\n s.append(c);\n }\n\n return s;\n }\n\n template \n String&\n stringAppend(String& s, Iterator begin, Iterator end)\n {\n while (begin != end)\n {\n s.append(*begin);\n ++begin;\n }\n\n return s;\n }\n\n inline\n size_t\n stringLength(const String& s)\n {\n return s.length();\n }\n\n inline\n std::string\n toUTF8String(const String& s)\n {\n std::string result;\n s.toUTF8String(result);\n\n return result;\n }\n\n inline\n bool\n empty(const String& s)\n {\n return s.isEmpty();\n }\n}\n\nnamespace std\n{\n inline\n cxxopts::UnicodeStringIterator\n begin(const icu::UnicodeString& s)\n {\n return cxxopts::UnicodeStringIterator(&s, 0);\n }\n\n inline\n cxxopts::UnicodeStringIterator\n end(const icu::UnicodeString& s)\n {\n return cxxopts::UnicodeStringIterator(&s, s.length());\n }\n}\n\n//ifdef CXXOPTS_USE_UNICODE\n#else\n\nnamespace cxxopts\n{\n using String = std::string;\n\n template \n T\n toLocalString(T&& t)\n {\n return std::forward(t);\n }\n\n inline\n size_t\n stringLength(const String& s)\n {\n return s.length();\n }\n\n inline\n String&\n stringAppend(String&s, const String& a)\n {\n return s.append(a);\n }\n\n inline\n String&\n stringAppend(String& s, size_t n, char c)\n {\n return s.append(n, c);\n }\n\n template \n String&\n stringAppend(String& s, Iterator begin, Iterator end)\n {\n return s.append(begin, end);\n }\n\n template \n std::string\n toUTF8String(T&& t)\n {\n return std::forward(t);\n }\n\n inline\n bool\n empty(const std::string& s)\n {\n return s.empty();\n }\n} // namespace cxxopts\n\n//ifdef CXXOPTS_USE_UNICODE\n#endif\n\nnamespace cxxopts\n{\n namespace\n {\n#ifdef _WIN32\n const std::string LQUOTE(\"\\'\");\n const std::string RQUOTE(\"\\'\");\n#else\n const std::string LQUOTE(\"‘\");\n const std::string RQUOTE(\"’\");\n#endif\n } // namespace\n\n#if defined(__GNUC__)\n// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we want to silence it:\n// warning: base class 'class std::enable_shared_from_this' has accessible non-virtual destructor\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wnon-virtual-dtor\"\n#pragma GCC diagnostic ignored \"-Weffc++\"\n// This will be ignored under other compilers like LLVM clang.\n#endif\n class Value : public std::enable_shared_from_this\n {\n public:\n\n virtual ~Value() = default;\n\n virtual\n std::shared_ptr\n clone() const = 0;\n\n virtual void\n parse(const std::string& text) const = 0;\n\n virtual void\n parse() const = 0;\n\n virtual bool\n has_default() const = 0;\n\n virtual bool\n is_container() const = 0;\n\n virtual bool\n has_implicit() const = 0;\n\n virtual std::string\n get_default_value() const = 0;\n\n virtual std::string\n get_implicit_value() const = 0;\n\n virtual std::shared_ptr\n default_value(const std::string& value) = 0;\n\n virtual std::shared_ptr\n implicit_value(const std::string& value) = 0;\n\n virtual std::shared_ptr\n no_implicit_value() = 0;\n\n virtual bool\n is_boolean() const = 0;\n };\n#if defined(__GNUC__)\n#pragma GCC diagnostic pop\n#endif\n class OptionException : public std::exception\n {\n public:\n explicit OptionException(std::string message)\n : m_message(std::move(message))\n {\n }\n\n CXXOPTS_NODISCARD\n const char*\n what() const noexcept override\n {\n return m_message.c_str();\n }\n\n private:\n std::string m_message;\n };\n\n class OptionSpecException : public OptionException\n {\n public:\n\n explicit OptionSpecException(const std::string& message)\n : OptionException(message)\n {\n }\n };\n\n class OptionParseException : public OptionException\n {\n public:\n explicit OptionParseException(const std::string& message)\n : OptionException(message)\n {\n }\n };\n\n class option_exists_error : public OptionSpecException\n {\n public:\n explicit option_exists_error(const std::string& option)\n : OptionSpecException(\"Option \" + LQUOTE + option + RQUOTE + \" already exists\")\n {\n }\n };\n\n class invalid_option_format_error : public OptionSpecException\n {\n public:\n explicit invalid_option_format_error(const std::string& format)\n : OptionSpecException(\"Invalid option format \" + LQUOTE + format + RQUOTE)\n {\n }\n };\n\n class option_syntax_exception : public OptionParseException {\n public:\n explicit option_syntax_exception(const std::string& text)\n : OptionParseException(\"Argument \" + LQUOTE + text + RQUOTE +\n \" starts with a - but has incorrect syntax\")\n {\n }\n };\n\n class option_not_exists_exception : public OptionParseException\n {\n public:\n explicit option_not_exists_exception(const std::string& option)\n : OptionParseException(\"Option \" + LQUOTE + option + RQUOTE + \" does not exist\")\n {\n }\n };\n\n class missing_argument_exception : public OptionParseException\n {\n public:\n explicit missing_argument_exception(const std::string& option)\n : OptionParseException(\n \"Option \" + LQUOTE + option + RQUOTE + \" is missing an argument\"\n )\n {\n }\n };\n\n class option_requires_argument_exception : public OptionParseException\n {\n public:\n explicit option_requires_argument_exception(const std::string& option)\n : OptionParseException(\n \"Option \" + LQUOTE + option + RQUOTE + \" requires an argument\"\n )\n {\n }\n };\n\n class option_not_has_argument_exception : public OptionParseException\n {\n public:\n option_not_has_argument_exception\n (\n const std::string& option,\n const std::string& arg\n )\n : OptionParseException(\n \"Option \" + LQUOTE + option + RQUOTE +\n \" does not take an argument, but argument \" +\n LQUOTE + arg + RQUOTE + \" given\"\n )\n {\n }\n };\n\n class option_not_present_exception : public OptionParseException\n {\n public:\n explicit option_not_present_exception(const std::string& option)\n : OptionParseException(\"Option \" + LQUOTE + option + RQUOTE + \" not present\")\n {\n }\n };\n\n class option_has_no_value_exception : public OptionException\n {\n public:\n explicit option_has_no_value_exception(const std::string& option)\n : OptionException(\n !option.empty() ?\n (\"Option \" + LQUOTE + option + RQUOTE + \" has no value\") :\n \"Option has no value\")\n {\n }\n };\n\n class argument_incorrect_type : public OptionParseException\n {\n public:\n explicit argument_incorrect_type\n (\n const std::string& arg\n )\n : OptionParseException(\n \"Argument \" + LQUOTE + arg + RQUOTE + \" failed to parse\"\n )\n {\n }\n };\n\n class option_required_exception : public OptionParseException\n {\n public:\n explicit option_required_exception(const std::string& option)\n : OptionParseException(\n \"Option \" + LQUOTE + option + RQUOTE + \" is required but not present\"\n )\n {\n }\n };\n\n template \n void throw_or_mimic(const std::string& text)\n {\n static_assert(std::is_base_of::value,\n \"throw_or_mimic only works on std::exception and \"\n \"deriving classes\");\n\n#ifndef CXXOPTS_NO_EXCEPTIONS\n // If CXXOPTS_NO_EXCEPTIONS is not defined, just throw\n throw T{text};\n#else\n // Otherwise manually instantiate the exception, print what() to stderr,\n // and exit\n T exception{text};\n std::cerr << exception.what() << std::endl;\n std::exit(EXIT_FAILURE);\n#endif\n }\n\n namespace values\n {\n namespace parser_tool\n {\n struct IntegerDesc\n {\n std::string negative = \"\";\n std::string base = \"\";\n std::string value = \"\";\n };\n struct ArguDesc {\n std::string arg_name = \"\";\n bool grouping = false;\n bool set_value = false;\n std::string value = \"\";\n };\n#ifdef CXXOPTS_NO_REGEX\n inline IntegerDesc SplitInteger(const std::string &text)\n {\n if (text.empty())\n {\n throw_or_mimic(text);\n }\n IntegerDesc desc;\n const char *pdata = text.c_str();\n if (*pdata == '-')\n {\n pdata += 1;\n desc.negative = \"-\";\n }\n if (strncmp(pdata, \"0x\", 2) == 0)\n {\n pdata += 2;\n desc.base = \"0x\";\n }\n if (*pdata != '\\0')\n {\n desc.value = std::string(pdata);\n }\n else\n {\n throw_or_mimic(text);\n }\n return desc;\n }\n\n inline bool IsTrueText(const std::string &text)\n {\n const char *pdata = text.c_str();\n if (*pdata == 't' || *pdata == 'T')\n {\n pdata += 1;\n if (strncmp(pdata, \"rue\\0\", 4) == 0)\n {\n return true;\n }\n }\n else if (strncmp(pdata, \"1\\0\", 2) == 0)\n {\n return true;\n }\n return false;\n }\n\n inline bool IsFalseText(const std::string &text)\n {\n const char *pdata = text.c_str();\n if (*pdata == 'f' || *pdata == 'F')\n {\n pdata += 1;\n if (strncmp(pdata, \"alse\\0\", 5) == 0)\n {\n return true;\n }\n }\n else if (strncmp(pdata, \"0\\0\", 2) == 0)\n {\n return true;\n }\n return false;\n }\n\n inline std::pair SplitSwitchDef(const std::string &text)\n {\n std::string short_sw, long_sw;\n const char *pdata = text.c_str();\n if (isalnum(*pdata) && *(pdata + 1) == ',') {\n short_sw = std::string(1, *pdata);\n pdata += 2;\n }\n while (*pdata == ' ') { pdata += 1; }\n if (isalnum(*pdata)) {\n const char *store = pdata;\n pdata += 1;\n while (isalnum(*pdata) || *pdata == '-' || *pdata == '_') {\n pdata += 1;\n }\n if (*pdata == '\\0') {\n long_sw = std::string(store, pdata - store);\n } else {\n throw_or_mimic(text);\n }\n }\n return std::pair(short_sw, long_sw);\n }\n\n inline ArguDesc ParseArgument(const char *arg, bool &matched)\n {\n ArguDesc argu_desc;\n const char *pdata = arg;\n matched = false;\n if (strncmp(pdata, \"--\", 2) == 0)\n {\n pdata += 2;\n if (isalnum(*pdata))\n {\n argu_desc.arg_name.push_back(*pdata);\n pdata += 1;\n while (isalnum(*pdata) || *pdata == '-' || *pdata == '_')\n {\n argu_desc.arg_name.push_back(*pdata);\n pdata += 1;\n }\n if (argu_desc.arg_name.length() > 1)\n {\n if (*pdata == '=')\n {\n argu_desc.set_value = true;\n pdata += 1;\n if (*pdata != '\\0')\n {\n argu_desc.value = std::string(pdata);\n }\n matched = true;\n }\n else if (*pdata == '\\0')\n {\n matched = true;\n }\n }\n }\n }\n else if (strncmp(pdata, \"-\", 1) == 0)\n {\n pdata += 1;\n argu_desc.grouping = true;\n while (isalnum(*pdata))\n {\n argu_desc.arg_name.push_back(*pdata);\n pdata += 1;\n }\n matched = !argu_desc.arg_name.empty() && *pdata == '\\0';\n }\n return argu_desc;\n }\n\n#else // CXXOPTS_NO_REGEX\n\n namespace\n {\n\n std::basic_regex integer_pattern\n (\"(-)?(0x)?([0-9a-zA-Z]+)|((0x)?0)\");\n std::basic_regex truthy_pattern\n (\"(t|T)(rue)?|1\");\n std::basic_regex falsy_pattern\n (\"(f|F)(alse)?|0\");\n\n std::basic_regex option_matcher\n (\"--([[:alnum:]][-_[:alnum:]]+)(=(.*))?|-([[:alnum:]]+)\");\n std::basic_regex option_specifier\n (\"(([[:alnum:]]),)?[ ]*([[:alnum:]][-_[:alnum:]]*)?\");\n\n } // namespace\n\n inline IntegerDesc SplitInteger(const std::string &text)\n {\n std::smatch match;\n std::regex_match(text, match, integer_pattern);\n\n if (match.length() == 0)\n {\n throw_or_mimic(text);\n }\n\n IntegerDesc desc;\n desc.negative = match[1];\n desc.base = match[2];\n desc.value = match[3];\n\n if (match.length(4) > 0)\n {\n desc.base = match[5];\n desc.value = \"0\";\n return desc;\n }\n\n return desc;\n }\n\n inline bool IsTrueText(const std::string &text)\n {\n std::smatch result;\n std::regex_match(text, result, truthy_pattern);\n return !result.empty();\n }\n\n inline bool IsFalseText(const std::string &text)\n {\n std::smatch result;\n std::regex_match(text, result, falsy_pattern);\n return !result.empty();\n }\n\n inline std::pair SplitSwitchDef(const std::string &text)\n {\n std::match_results result;\n std::regex_match(text.c_str(), result, option_specifier);\n if (result.empty())\n {\n throw_or_mimic(text);\n }\n\n const std::string& short_sw = result[2];\n const std::string& long_sw = result[3];\n\n return std::pair(short_sw, long_sw);\n }\n\n inline ArguDesc ParseArgument(const char *arg, bool &matched)\n {\n std::match_results result;\n std::regex_match(arg, result, option_matcher);\n matched = !result.empty();\n\n ArguDesc argu_desc;\n if (matched) {\n argu_desc.arg_name = result[1].str();\n argu_desc.set_value = result[2].length() > 0;\n argu_desc.value = result[3].str();\n if (result[4].length() > 0)\n {\n argu_desc.grouping = true;\n argu_desc.arg_name = result[4].str();\n }\n }\n\n return argu_desc;\n }\n\n#endif // CXXOPTS_NO_REGEX\n#undef CXXOPTS_NO_REGEX\n }\n\n namespace detail\n {\n template \n struct SignedCheck;\n\n template \n struct SignedCheck\n {\n template \n void\n operator()(bool negative, U u, const std::string& text)\n {\n if (negative)\n {\n if (u > static_cast((std::numeric_limits::min)()))\n {\n throw_or_mimic(text);\n }\n }\n else\n {\n if (u > static_cast((std::numeric_limits::max)()))\n {\n throw_or_mimic(text);\n }\n }\n }\n };\n\n template \n struct SignedCheck\n {\n template \n void\n operator()(bool, U, const std::string&) const {}\n };\n\n template \n void\n check_signed_range(bool negative, U value, const std::string& text)\n {\n SignedCheck::is_signed>()(negative, value, text);\n }\n } // namespace detail\n\n template \n void\n checked_negate(R& r, T&& t, const std::string&, std::true_type)\n {\n // if we got to here, then `t` is a positive number that fits into\n // `R`. So to avoid MSVC C4146, we first cast it to `R`.\n // See https://github.com/jarro2783/cxxopts/issues/62 for more details.\n r = static_cast(-static_cast(t-1)-1);\n }\n\n template \n void\n checked_negate(R&, T&&, const std::string& text, std::false_type)\n {\n throw_or_mimic(text);\n }\n\n template \n void\n integer_parser(const std::string& text, T& value)\n {\n parser_tool::IntegerDesc int_desc = parser_tool::SplitInteger(text);\n\n using US = typename std::make_unsigned::type;\n constexpr bool is_signed = std::numeric_limits::is_signed;\n\n const bool negative = int_desc.negative.length() > 0;\n const uint8_t base = int_desc.base.length() > 0 ? 16 : 10;\n const std::string & value_match = int_desc.value;\n\n US result = 0;\n\n for (char ch : value_match)\n {\n US digit = 0;\n\n if (ch >= '0' && ch <= '9')\n {\n digit = static_cast(ch - '0');\n }\n else if (base == 16 && ch >= 'a' && ch <= 'f')\n {\n digit = static_cast(ch - 'a' + 10);\n }\n else if (base == 16 && ch >= 'A' && ch <= 'F')\n {\n digit = static_cast(ch - 'A' + 10);\n }\n else\n {\n throw_or_mimic(text);\n }\n\n const US next = static_cast(result * base + digit);\n if (result > next)\n {\n throw_or_mimic(text);\n }\n\n result = next;\n }\n\n detail::check_signed_range(negative, result, text);\n\n if (negative)\n {\n checked_negate(value, result, text, std::integral_constant());\n }\n else\n {\n value = static_cast(result);\n }\n }\n\n template \n void stringstream_parser(const std::string& text, T& value)\n {\n std::stringstream in(text);\n in >> value;\n if (!in) {\n throw_or_mimic(text);\n }\n }\n\n template ::value>::type* = nullptr\n >\n void parse_value(const std::string& text, T& value)\n {\n integer_parser(text, value);\n }\n\n inline\n void\n parse_value(const std::string& text, bool& value)\n {\n if (parser_tool::IsTrueText(text))\n {\n value = true;\n return;\n }\n\n if (parser_tool::IsFalseText(text))\n {\n value = false;\n return;\n }\n\n throw_or_mimic(text);\n }\n\n inline\n void\n parse_value(const std::string& text, std::string& value)\n {\n value = text;\n }\n\n // The fallback parser. It uses the stringstream parser to parse all types\n // that have not been overloaded explicitly. It has to be placed in the\n // source code before all other more specialized templates.\n template ::value>::type* = nullptr\n >\n void\n parse_value(const std::string& text, T& value) {\n stringstream_parser(text, value);\n }\n\n template \n void\n parse_value(const std::string& text, std::vector& value)\n {\n if (text.empty()) {\n T v;\n parse_value(text, v);\n value.emplace_back(std::move(v));\n return;\n }\n std::stringstream in(text);\n std::string token;\n while(!in.eof() && std::getline(in, token, CXXOPTS_VECTOR_DELIMITER)) {\n T v;\n parse_value(token, v);\n value.emplace_back(std::move(v));\n }\n }\n\n#ifdef CXXOPTS_HAS_OPTIONAL\n template \n void\n parse_value(const std::string& text, std::optional& value)\n {\n T result;\n parse_value(text, result);\n value = std::move(result);\n }\n#endif\n\n inline\n void parse_value(const std::string& text, char& c)\n {\n if (text.length() != 1)\n {\n throw_or_mimic(text);\n }\n\n c = text[0];\n }\n\n template \n struct type_is_container\n {\n static constexpr bool value = false;\n };\n\n template \n struct type_is_container>\n {\n static constexpr bool value = true;\n };\n\n template \n class abstract_value : public Value\n {\n using Self = abstract_value;\n\n public:\n abstract_value()\n : m_result(std::make_shared())\n , m_store(m_result.get())\n {\n }\n\n explicit abstract_value(T* t)\n : m_store(t)\n {\n }\n\n ~abstract_value() override = default;\n\n abstract_value& operator=(const abstract_value&) = default;\n\n abstract_value(const abstract_value& rhs)\n {\n if (rhs.m_result)\n {\n m_result = std::make_shared();\n m_store = m_result.get();\n }\n else\n {\n m_store = rhs.m_store;\n }\n\n m_default = rhs.m_default;\n m_implicit = rhs.m_implicit;\n m_default_value = rhs.m_default_value;\n m_implicit_value = rhs.m_implicit_value;\n }\n\n void\n parse(const std::string& text) const override\n {\n parse_value(text, *m_store);\n }\n\n bool\n is_container() const override\n {\n return type_is_container::value;\n }\n\n void\n parse() const override\n {\n parse_value(m_default_value, *m_store);\n }\n\n bool\n has_default() const override\n {\n return m_default;\n }\n\n bool\n has_implicit() const override\n {\n return m_implicit;\n }\n\n std::shared_ptr\n default_value(const std::string& value) override\n {\n m_default = true;\n m_default_value = value;\n return shared_from_this();\n }\n\n std::shared_ptr\n implicit_value(const std::string& value) override\n {\n m_implicit = true;\n m_implicit_value = value;\n return shared_from_this();\n }\n\n std::shared_ptr\n no_implicit_value() override\n {\n m_implicit = false;\n return shared_from_this();\n }\n\n std::string\n get_default_value() const override\n {\n return m_default_value;\n }\n\n std::string\n get_implicit_value() const override\n {\n return m_implicit_value;\n }\n\n bool\n is_boolean() const override\n {\n return std::is_same::value;\n }\n\n const T&\n get() const\n {\n if (m_store == nullptr)\n {\n return *m_result;\n }\n return *m_store;\n }\n\n protected:\n std::shared_ptr m_result{};\n T* m_store{};\n\n bool m_default = false;\n bool m_implicit = false;\n\n std::string m_default_value{};\n std::string m_implicit_value{};\n };\n\n template \n class standard_value : public abstract_value\n {\n public:\n using abstract_value::abstract_value;\n\n CXXOPTS_NODISCARD\n std::shared_ptr\n clone() const override\n {\n return std::make_shared>(*this);\n }\n };\n\n template <>\n class standard_value : public abstract_value\n {\n public:\n ~standard_value() override = default;\n\n standard_value()\n {\n set_default_and_implicit();\n }\n\n explicit standard_value(bool* b)\n : abstract_value(b)\n {\n set_default_and_implicit();\n }\n\n std::shared_ptr\n clone() const override\n {\n return std::make_shared>(*this);\n }\n\n private:\n\n void\n set_default_and_implicit()\n {\n m_default = true;\n m_default_value = \"false\";\n m_implicit = true;\n m_implicit_value = \"true\";\n }\n };\n } // namespace values\n\n template \n std::shared_ptr\n value()\n {\n return std::make_shared>();\n }\n\n template \n std::shared_ptr\n value(T& t)\n {\n return std::make_shared>(&t);\n }\n\n class OptionAdder;\n\n class OptionDetails\n {\n public:\n OptionDetails\n (\n std::string short_,\n std::string long_,\n String desc,\n std::shared_ptr val\n )\n : m_short(std::move(short_))\n , m_long(std::move(long_))\n , m_desc(std::move(desc))\n , m_value(std::move(val))\n , m_count(0)\n {\n m_hash = std::hash{}(m_long + m_short);\n }\n\n OptionDetails(const OptionDetails& rhs)\n : m_desc(rhs.m_desc)\n , m_value(rhs.m_value->clone())\n , m_count(rhs.m_count)\n {\n }\n\n OptionDetails(OptionDetails&& rhs) = default;\n\n CXXOPTS_NODISCARD\n const String&\n description() const\n {\n return m_desc;\n }\n\n CXXOPTS_NODISCARD\n const Value&\n value() const {\n return *m_value;\n }\n\n CXXOPTS_NODISCARD\n std::shared_ptr\n make_storage() const\n {\n return m_value->clone();\n }\n\n CXXOPTS_NODISCARD\n const std::string&\n short_name() const\n {\n return m_short;\n }\n\n CXXOPTS_NODISCARD\n const std::string&\n long_name() const\n {\n return m_long;\n }\n\n CXXOPTS_NODISCARD\n const std::string&\n essential_name() const\n {\n return m_long.empty() ? m_short : m_long;\n }\n\n size_t\n hash() const\n {\n return m_hash;\n }\n\n private:\n std::string m_short{};\n std::string m_long{};\n String m_desc{};\n std::shared_ptr m_value{};\n int m_count;\n\n size_t m_hash{};\n };\n\n struct HelpOptionDetails\n {\n std::string s;\n std::string l;\n String desc;\n bool has_default;\n std::string default_value;\n bool has_implicit;\n std::string implicit_value;\n std::string arg_help;\n bool is_container;\n bool is_boolean;\n };\n\n struct HelpGroupDetails\n {\n std::string name{};\n std::string description{};\n std::vector options{};\n };\n\n class OptionValue\n {\n public:\n void\n parse\n (\n const std::shared_ptr& details,\n const std::string& text\n )\n {\n ensure_value(details);\n ++m_count;\n m_value->parse(text);\n m_long_name = &details->long_name();\n }\n\n void\n parse_default(const std::shared_ptr& details)\n {\n ensure_value(details);\n m_default = true;\n m_long_name = &details->long_name();\n m_value->parse();\n }\n\n void\n parse_no_value(const std::shared_ptr& details)\n {\n m_long_name = &details->long_name();\n }\n\n#if defined(CXXOPTS_NULL_DEREF_IGNORE)\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wnull-dereference\"\n#endif\n\n CXXOPTS_NODISCARD\n size_t\n count() const noexcept\n {\n return m_count;\n }\n\n#if defined(CXXOPTS_NULL_DEREF_IGNORE)\n#pragma GCC diagnostic pop\n#endif\n\n // TODO: maybe default options should count towards the number of arguments\n CXXOPTS_NODISCARD\n bool\n has_default() const noexcept\n {\n return m_default;\n }\n\n template \n const T&\n as() const\n {\n if (m_value == nullptr) {\n throw_or_mimic(\n m_long_name == nullptr ? \"\" : *m_long_name);\n }\n\n#ifdef CXXOPTS_NO_RTTI\n return static_cast&>(*m_value).get();\n#else\n return dynamic_cast&>(*m_value).get();\n#endif\n }\n\n private:\n void\n ensure_value(const std::shared_ptr& details)\n {\n if (m_value == nullptr)\n {\n m_value = details->make_storage();\n }\n }\n\n\n const std::string* m_long_name = nullptr;\n // Holding this pointer is safe, since OptionValue's only exist in key-value pairs,\n // where the key has the string we point to.\n std::shared_ptr m_value{};\n size_t m_count = 0;\n bool m_default = false;\n };\n\n class KeyValue\n {\n public:\n KeyValue(std::string key_, std::string value_)\n : m_key(std::move(key_))\n , m_value(std::move(value_))\n {\n }\n\n CXXOPTS_NODISCARD\n const std::string&\n key() const\n {\n return m_key;\n }\n\n CXXOPTS_NODISCARD\n const std::string&\n value() const\n {\n return m_value;\n }\n\n template \n T\n as() const\n {\n T result;\n values::parse_value(m_value, result);\n return result;\n }\n\n private:\n std::string m_key;\n std::string m_value;\n };\n\n using ParsedHashMap = std::unordered_map;\n using NameHashMap = std::unordered_map;\n\n class ParseResult\n {\n public:\n class Iterator\n {\n public:\n using iterator_category = std::forward_iterator_tag;\n using value_type = KeyValue;\n using difference_type = void;\n using pointer = const KeyValue*;\n using reference = const KeyValue&;\n\n Iterator() = default;\n Iterator(const Iterator&) = default;\n\n Iterator(const ParseResult *pr, bool end=false)\n : m_pr(pr)\n , m_iter(end? pr->m_defaults.end(): pr->m_sequential.begin())\n {\n }\n\n Iterator& operator++()\n {\n ++m_iter;\n if(m_iter == m_pr->m_sequential.end())\n {\n m_iter = m_pr->m_defaults.begin();\n return *this;\n }\n return *this;\n }\n\n Iterator operator++(int)\n {\n Iterator retval = *this;\n ++(*this);\n return retval;\n }\n\n bool operator==(const Iterator& other) const\n {\n return m_iter == other.m_iter;\n }\n\n bool operator!=(const Iterator& other) const\n {\n return !(*this == other);\n }\n\n const KeyValue& operator*()\n {\n return *m_iter;\n }\n\n const KeyValue* operator->()\n {\n return m_iter.operator->();\n }\n\n private:\n const ParseResult* m_pr;\n std::vector::const_iterator m_iter;\n };\n\n ParseResult() = default;\n ParseResult(const ParseResult&) = default;\n\n ParseResult(NameHashMap&& keys, ParsedHashMap&& values, std::vector sequential, \n std::vector default_opts, std::vector&& unmatched_args)\n : m_keys(std::move(keys))\n , m_values(std::move(values))\n , m_sequential(std::move(sequential))\n , m_defaults(std::move(default_opts))\n , m_unmatched(std::move(unmatched_args))\n {\n }\n\n ParseResult& operator=(ParseResult&&) = default;\n ParseResult& operator=(const ParseResult&) = default;\n\n Iterator\n begin() const\n {\n return Iterator(this);\n }\n\n Iterator\n end() const\n {\n return Iterator(this, true);\n }\n\n size_t\n count(const std::string& o) const\n {\n auto iter = m_keys.find(o);\n if (iter == m_keys.end())\n {\n return 0;\n }\n\n auto viter = m_values.find(iter->second);\n\n if (viter == m_values.end())\n {\n return 0;\n }\n\n return viter->second.count();\n }\n\n const OptionValue&\n operator[](const std::string& option) const\n {\n auto iter = m_keys.find(option);\n\n if (iter == m_keys.end())\n {\n throw_or_mimic(option);\n }\n\n auto viter = m_values.find(iter->second);\n\n if (viter == m_values.end())\n {\n throw_or_mimic(option);\n }\n\n return viter->second;\n }\n\n const std::vector&\n arguments() const\n {\n return m_sequential;\n }\n\n const std::vector&\n unmatched() const\n {\n return m_unmatched;\n }\n\n const std::vector&\n defaults() const\n {\n return m_defaults;\n }\n\n const std::string\n arguments_string() const\n {\n std::string result;\n for(const auto& kv: m_sequential)\n {\n result += kv.key() + \" = \" + kv.value() + \"\\n\";\n }\n for(const auto& kv: m_defaults)\n {\n result += kv.key() + \" = \" + kv.value() + \" \" + \"(default)\" + \"\\n\";\n }\n return result;\n }\n\n private:\n NameHashMap m_keys{};\n ParsedHashMap m_values{};\n std::vector m_sequential{};\n std::vector m_defaults{};\n std::vector m_unmatched{};\n };\n\n struct Option\n {\n Option\n (\n std::string opts,\n std::string desc,\n std::shared_ptr value = ::cxxopts::value(),\n std::string arg_help = \"\"\n )\n : opts_(std::move(opts))\n , desc_(std::move(desc))\n , value_(std::move(value))\n , arg_help_(std::move(arg_help))\n {\n }\n\n std::string opts_;\n std::string desc_;\n std::shared_ptr value_;\n std::string arg_help_;\n };\n\n using OptionMap = std::unordered_map>;\n using PositionalList = std::vector;\n using PositionalListIterator = PositionalList::const_iterator;\n\n class OptionParser\n {\n public:\n OptionParser(const OptionMap& options, const PositionalList& positional, bool allow_unrecognised)\n : m_options(options)\n , m_positional(positional)\n , m_allow_unrecognised(allow_unrecognised)\n {\n }\n\n ParseResult\n parse(int argc, const char* const* argv);\n\n bool\n consume_positional(const std::string& a, PositionalListIterator& next);\n\n void\n checked_parse_arg\n (\n int argc,\n const char* const* argv,\n int& current,\n const std::shared_ptr& value,\n const std::string& name\n );\n\n void\n add_to_option(OptionMap::const_iterator iter, const std::string& option, const std::string& arg);\n\n void\n parse_option\n (\n const std::shared_ptr& value,\n const std::string& name,\n const std::string& arg = \"\"\n );\n\n void\n parse_default(const std::shared_ptr& details);\n\n void\n parse_no_value(const std::shared_ptr& details);\n\n private:\n\n void finalise_aliases();\n\n const OptionMap& m_options;\n const PositionalList& m_positional;\n\n std::vector m_sequential{};\n std::vector m_defaults{};\n bool m_allow_unrecognised;\n\n ParsedHashMap m_parsed{};\n NameHashMap m_keys{};\n };\n\n class Options\n {\n public:\n\n explicit Options(std::string program, std::string help_string = \"\")\n : m_program(std::move(program))\n , m_help_string(toLocalString(std::move(help_string)))\n , m_custom_help(\"[OPTION...]\")\n , m_positional_help(\"positional parameters\")\n , m_show_positional(false)\n , m_allow_unrecognised(false)\n , m_width(76)\n , m_tab_expansion(false)\n , m_options(std::make_shared())\n {\n }\n\n Options&\n positional_help(std::string help_text)\n {\n m_positional_help = std::move(help_text);\n return *this;\n }\n\n Options&\n custom_help(std::string help_text)\n {\n m_custom_help = std::move(help_text);\n return *this;\n }\n\n Options&\n show_positional_help()\n {\n m_show_positional = true;\n return *this;\n }\n\n Options&\n allow_unrecognised_options()\n {\n m_allow_unrecognised = true;\n return *this;\n }\n\n Options&\n set_width(size_t width)\n {\n m_width = width;\n return *this;\n }\n\n Options&\n set_tab_expansion(bool expansion=true)\n {\n m_tab_expansion = expansion;\n return *this;\n }\n\n ParseResult\n parse(int argc, const char* const* argv);\n\n OptionAdder\n add_options(std::string group = \"\");\n\n void\n add_options\n (\n const std::string& group,\n std::initializer_list