stamen

Static Menu Generator
git clone git://git.dimitrijedobrota.com/stamen.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit 26a75511cae93934528c2c3e09c1307d20086552
parent 77eabec835fddbe4e8d83608b538090d8de2c3cb
author Dimitrije Dobrota < mail@dimitrijedobrota.com >
date Fri, 17 Nov 2023 02:22:39 +0000

Rebrand

* Rebrand project to stamen
* Add header guard to generated include file
* Fix bug where -1 would not go back

Diffstat:
M CMakeLists.txt | +++ ---
M README.md | + -
M demo/CMakeLists.txt | +++ ---
M demo/main.cpp | + -
M demo/shared.h | ++ --
D include/menu.h | ---------------------------------------------------------------------------------
A include/stamen.h | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M src/CMakeLists.txt | ++++++++ --------
M src/generate.cpp | + -
D src/menu.cpp | ---------------------------------------------------------------------------------
A src/stamen.cpp | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

11 files changed, 242 insertions(+), 239 deletions(-)

diff --git a/ CMakeLists.txt b/ CMakeLists.txt

@@ -2,9 +2,9 @@ cmake_minimum_required(VERSION 3.25.2)

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

project(
Menu
VERSION 0.0.7
DESCRIPTION "Experimentation with dinamic menus"
Stamen
VERSION 0.0.8
DESCRIPTION "Static menu generator"
LANGUAGES CXX
)

diff --git a/ README.md b/ README.md

@@ -107,7 +107,7 @@ will create source file and include file in the current directory with the name

as the configuration file but with extensions `.cpp` and `.h` respectively.

Include file will contain declarations for all of the menu functions inside
`menu` namespace. You should include this file in your code.
`stamen` namespace. You should include this file in your code.

Source file contains definitions for the menu functions. It also includes
`shared.h` file which should contain declarations for all of the free functions

diff --git a/ demo/CMakeLists.txt b/ demo/CMakeLists.txt

@@ -4,13 +4,13 @@ add_executable(demo

)

target_link_libraries(demo
menu
stamen
)

ADD_CUSTOM_COMMAND(
OUTPUT demo_menu.h demo_menu.cpp
COMMAND ${CMAKE_BINARY_DIR}/bin/generate ${CMAKE_CURRENT_SOURCE_DIR}/demo_menu.conf
DEPENDS demo_menu.conf generate
COMMAND ${CMAKE_BINARY_DIR}/bin/stamen-generate ${CMAKE_CURRENT_SOURCE_DIR}/demo_menu.conf
DEPENDS demo_menu.conf stamen-generate
COMMENT "Generating menu files"
)

diff --git a/ demo/main.cpp b/ demo/main.cpp

@@ -27,7 +27,7 @@ int finish(void) {

exit(0);
}

int menu_static_run(void) { return menu::menu_main(); }
int menu_static_run(void) { return stamen::menu_main(); }
int menu_dynamic_run(void) { return Menu::start("menu_main"); }

int menu_dynamic_print(void) {

diff --git a/ demo/shared.h b/ demo/shared.h

@@ -1,5 +1,5 @@

#ifndef DEMO_SHARED_H
#define DEMO_SHARED_H
#ifndef STAMEN_DEMO_SHARED_H
#define STAMEN_DEMO_SHARED_H

int finish(void);
int operation1(void);

diff --git a/ include/menu.h b/ include/menu.h

@@ -1,122 +0,0 @@

#ifndef MENU_H
#define MENU_H

#include <exception>
#include <format>
#include <fstream>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>

class Menu {
Menu(const Menu &) = delete;
Menu &operator=(const Menu &) = delete;

struct private_ctor_t {};

public:
typedef int (*callback_f)(void);

Menu(private_ctor_t, const std::string &code, const std::string &prompt)
: Menu(code, prompt) {}

Menu(private_ctor_t, const std::string &code, const callback_f callback)
: Menu(code, callback) {}

class EMenu : std::exception {
virtual const char *what() const noexcept override {
return "Trying to access an unknown menu";
}
};

struct item_t {
friend class Menu;

item_t(const callback_f func, const std::string &prompt)
: callback(func), prompt(prompt) {}

const std::string getPrompt(void) const { return prompt; }
const callback_f getCallback(void) const { return callback; }

int operator()(void) const {
return callback ? callback() : getMenu(code)();
}

private:
item_t(const std::string &code, const std::string &prompt)
: code(code), prompt(prompt) {}

const std::string prompt, code;
const callback_f callback = nullptr;
};

static void read(const std::string &s) {
std::string line, delim, code, prompt;
std::fstream fs(s);
char tmp;

lookup_t::iterator last = lookup.end();
while (std::getline(fs, line)) {
if (line.empty()) continue;
std::istringstream ss(line);
ss >> delim >> code;
ss.ignore(1, ' '), std::getline(ss, prompt);
if (delim == "+") {
const auto [iter, succ] = lookup.emplace(
std::piecewise_construct, std::forward_as_tuple(code),
std::forward_as_tuple(private_ctor_t{}, code, prompt));
last = iter;
} else {
last->second.items.push_back({code, prompt});
}
}
}

static int start(const std::string &entry) { return getMenu(entry)(); }
static void insert(const std::string &code, const callback_f callback) {
lookup.emplace(std::piecewise_construct, std::forward_as_tuple(code),
std::forward_as_tuple(private_ctor_t{}, code, callback));
}

static void print(const std::string &entry) { print(entry, 1); }

static void generateSource(std::ostream &os);
static void generateInclude(std::ostream &os);

typedef int (*display_f)(const std::string &, const item_t[], std::size_t);
static const display_f display;
static int builtinDisplay(const std::string &title, const item_t items[],
std::size_t size);

int operator()() const {
return callback ? callback() : display(title, items.data(), items.size());
}

private:
Menu(const std::string &code, const std::string &prompt)
: code(code), title(prompt) {}

Menu(const std::string &code, const callback_f callback)
: code(code), title(code), callback(callback) {}

typedef std::unordered_map<std::string, Menu> lookup_t;
static lookup_t lookup;

static void print(const std::string &entry, const int depth);

static const Menu &getMenu(const std::string &code) {
const auto it = lookup.find(code);
if (it == lookup.end()) throw EMenu();
return it->second;
}

const std::string code, title;
const callback_f callback = nullptr;
std::vector<item_t> items;
};

#endif

diff --git a/ include/stamen.h b/ include/stamen.h

@@ -0,0 +1,122 @@

#ifndef STAMEN_H
#define STAMEN_H

#include <exception>
#include <format>
#include <fstream>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>

class Menu {
Menu(const Menu &) = delete;
Menu &operator=(const Menu &) = delete;

struct private_ctor_t {};

public:
typedef int (*callback_f)(void);

Menu(private_ctor_t, const std::string &code, const std::string &prompt)
: Menu(code, prompt) {}

Menu(private_ctor_t, const std::string &code, const callback_f callback)
: Menu(code, callback) {}

class EMenu : std::exception {
virtual const char *what() const noexcept override {
return "Trying to access an unknown menu";
}
};

struct item_t {
friend class Menu;

item_t(const callback_f func, const std::string &prompt)
: callback(func), prompt(prompt) {}

const std::string getPrompt(void) const { return prompt; }
const callback_f getCallback(void) const { return callback; }

int operator()(void) const {
return callback ? callback() : getMenu(code)();
}

private:
item_t(const std::string &code, const std::string &prompt)
: code(code), prompt(prompt) {}

const std::string prompt, code;
const callback_f callback = nullptr;
};

static void read(const std::string &s) {
std::string line, delim, code, prompt;
std::fstream fs(s);
char tmp;

lookup_t::iterator last = lookup.end();
while (std::getline(fs, line)) {
if (line.empty()) continue;
std::istringstream ss(line);
ss >> delim >> code;
ss.ignore(1, ' '), std::getline(ss, prompt);
if (delim == "+") {
const auto [iter, succ] = lookup.emplace(
std::piecewise_construct, std::forward_as_tuple(code),
std::forward_as_tuple(private_ctor_t{}, code, prompt));
last = iter;
} else {
last->second.items.push_back({code, prompt});
}
}
}

static int start(const std::string &entry) { return getMenu(entry)(); }
static void insert(const std::string &code, const callback_f callback) {
lookup.emplace(std::piecewise_construct, std::forward_as_tuple(code),
std::forward_as_tuple(private_ctor_t{}, code, callback));
}

static void print(const std::string &entry) { print(entry, 1); }

static void generateSource(std::ostream &os);
static void generateInclude(std::ostream &os);

typedef int (*display_f)(const std::string &, const item_t[], std::size_t);
static const display_f display;
static int builtinDisplay(const std::string &title, const item_t items[],
std::size_t size);

int operator()() const {
return callback ? callback() : display(title, items.data(), items.size());
}

private:
Menu(const std::string &code, const std::string &prompt)
: code(code), title(prompt) {}

Menu(const std::string &code, const callback_f callback)
: code(code), title(code), callback(callback) {}

typedef std::unordered_map<std::string, Menu> lookup_t;
static lookup_t lookup;

static void print(const std::string &entry, const int depth);

static const Menu &getMenu(const std::string &code) {
const auto it = lookup.find(code);
if (it == lookup.end()) throw EMenu();
return it->second;
}

const std::string code, title;
const callback_f callback = nullptr;
std::vector<item_t> items;
};

#endif

diff --git a/ src/CMakeLists.txt b/ src/CMakeLists.txt

@@ -1,22 +1,22 @@

add_library(menu
menu.cpp
add_library(stamen
stamen.cpp
)

target_include_directories(menu
target_include_directories(stamen
PUBLIC ../include
)

add_executable(generate generate.cpp)
add_executable(stamen-generate generate.cpp)

target_link_libraries(generate
PRIVATE menu
target_link_libraries(stamen-generate
PRIVATE stamen
)

target_include_directories(generate
target_include_directories(stamen-generate
PUBLIC ../include
)

set_target_properties(generate PROPERTIES
set_target_properties(stamen-generate PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION ${PROJECT_VERSION_MAJOR}
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"

diff --git a/ src/generate.cpp b/ src/generate.cpp

@@ -1,4 +1,4 @@

#include "menu.h"
#include "stamen.h"
#include <string>

const Menu::display_f Menu::display = Menu::builtinDisplay;

diff --git a/ src/menu.cpp b/ src/menu.cpp

@@ -1,98 +0,0 @@

#include "../include/menu.h"
#include <cmath>
#include <format>
#include <fstream>
#include <iostream>
#include <ostream>
#include <stack>
#include <unordered_set>

std::unordered_map<std::string, Menu> Menu::lookup;

int Menu::builtinDisplay(const std::string &title, const item_t items[],
std::size_t size) {
int choice;
const int digits = std::log10(size) + 1;
while (true) {
std::cout << std::format("{}:\n", title);
for (auto i = 0ul; i < size; i++) {
std::cout << std::format(" {:{}}. {}\n", i, digits, items[i].getPrompt());
}

while (true) {
std::cout << "Choose an option: ";
if (std::cin >> choice && choice >= -1 && choice < size) {
if (choice == -1) {
std::cout << "Choice: back\n";
return 1;
}

const item_t &chosen = items[choice];
std::cout << std::format("Choice: {}\n\n", chosen.getPrompt());
const int res = chosen();
if (res > 1) return res - 1;

break;
} else if (std::cin.eof()) {
std::cerr << "encountered end of input!\n";
return std::numeric_limits<int>::max();
} else {
std::cin.clear();
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}
std::cout << "Invalid option, please choose again!\n";
}
std::cout << std::endl;
}

return 1;
}

void Menu::generateInclude(std::ostream &os) {
os << "#include \"menu.h\"\n\n";
os << "namespace menu {\n\n";
for (const auto &[code, _] : lookup) {
const Menu &menu = getMenu(code);
if (menu.callback) continue;
os << std::format("int {}(void);\n", menu.code);
}
os << "\n}\n";
}

void Menu::generateSource(std::ostream &os) {
os << "#include \"menu.h\"\n";
os << "#include \"shared.h\"\n";
os << "\nnamespace menu {\n";
for (const auto &[code, _] : lookup) {
const Menu &menu = getMenu(code);
if (menu.callback) continue;

os << std::format("int {}(void) {{\n", menu.code);
os << std::format("\tstatic const Menu::item_t items[] = {{\n");
for (const auto &item : menu.items) {
os << std::format("\t\t{{{}, \"{}\"}},\n", item.code, item.prompt);
}
os << std::format("\t}};\n");
os << std::format("\treturn Menu::display(\"{}\", items, "
"sizeof(items) / sizeof(Menu::item_t));\n",
menu.title);
os << std::format("}}\n\n");
}
os << "\n}\n";
}

void Menu::print(const std::string &code, const int depth) {
const auto it = lookup.find(code);
if (it == lookup.end()) return;
const Menu &menu = it->second;

if (depth == 1) std::cout << std::format("{}({})\n", menu.title, code);

if (!menu.callback) {
for (const auto &item : menu.items) {
std::cout << std::format("{}{}({})\n", std::string(depth << 1, ' '),
item.prompt, item.code);
menu.print(item.code, depth + 1);
}
}
}

diff --git a/ src/stamen.cpp b/ src/stamen.cpp

@@ -0,0 +1,101 @@

#include "../include/stamen.h"
#include <cmath>
#include <format>
#include <fstream>
#include <iostream>
#include <ostream>
#include <stack>
#include <unordered_set>

std::unordered_map<std::string, Menu> Menu::lookup;

int Menu::builtinDisplay(const std::string &title, const item_t items[],
std::size_t size) {
int choice;
const int digits = std::log10(size) + 1;
while (true) {
std::cout << std::format("{}:\n", title);
for (auto i = 0ul; i < size; i++) {
std::cout << std::format(" {:{}}. {}\n", i, digits, items[i].getPrompt());
}

while (true) {
std::cout << "Choose an option: ";
if (std::cin >> choice && choice >= -1 && choice < (int)size) {
if (choice == -1) {
std::cout << "Choice: back\n";
return 1;
}

const item_t &chosen = items[choice];
std::cout << std::format("Choice: {}\n\n", chosen.getPrompt());
const int res = chosen();
if (res > 1) return res - 1;

break;
} else if (std::cin.eof()) {
std::cerr << "encountered end of input!\n";
return std::numeric_limits<int>::max();
} else {
std::cin.clear();
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}
std::cout << "Invalid option, please choose again!\n";
}
std::cout << std::endl;
}

return 1;
}

void Menu::generateInclude(std::ostream &os) {
os << "#ifndef STAMEN_MENU_H\n";
os << "#define STAMEN_MENU_H\n\n";
os << "#include <stamen.h>\n\n";
os << "namespace stamen {\n\n";
for (const auto &[code, _] : lookup) {
const Menu &menu = getMenu(code);
if (menu.callback) continue;
os << std::format("int {}(void);\n", menu.code);
}
os << "\n}\n";
os << "#endif\n";
}

void Menu::generateSource(std::ostream &os) {
os << "#include <stamen.h>\n";
os << "#include \"shared.h\"\n";
os << "\nnamespace stamen {\n";
for (const auto &[code, _] : lookup) {
const Menu &menu = getMenu(code);
if (menu.callback) continue;

os << std::format("int {}(void) {{\n", menu.code);
os << std::format("\tstatic const Menu::item_t items[] = {{\n");
for (const auto &item : menu.items) {
os << std::format("\t\t{{{}, \"{}\"}},\n", item.code, item.prompt);
}
os << std::format("\t}};\n");
os << std::format("\treturn Menu::display(\"{}\", items, "
"sizeof(items) / sizeof(Menu::item_t));\n",
menu.title);
os << std::format("}}\n\n");
}
os << "\n}\n";
}

void Menu::print(const std::string &code, const int depth) {
const auto it = lookup.find(code);
if (it == lookup.end()) return;
const Menu &menu = it->second;

if (depth == 1) std::cout << std::format("{}({})\n", menu.title, code);

if (!menu.callback) {
for (const auto &item : menu.items) {
std::cout << std::format("{}{}({})\n", std::string(depth << 1, ' '),
item.prompt, item.code);
menu.print(item.code, depth + 1);
}
}
}