Design Pattern for invoking a Parser in a callback - c++

Question

I have an application that invokes callback function when a certain action is performed on the application.
Inside this callback function, I would like to invoke a Parser (a command line parser for instance).
This Parser would be running in a while loop and exits and comes back to the callback only when the user uses the command 'quit' on the command line.
Inside the while loop, the user always has access to the command line. Based on the user input on the command line, the Parser takes a unique action. For instance, it will set a variable and it goes to a database like so:
command-line>a 100
command-line>
Here the parameter a in DB would be set to 100.
I want to model the Parser using Object-Oriented Design. Which Design Pattern can I use in this case?

Answer 1

First and foremost, most design patterns are obsoleted by the introduction of first-class functions. What you need is a dispatch table of names to actions, which is basically the Command pattern.
Assuming the following definitions:
using Tokens = std::vector<std::string>;
using Action = std::function<void(const Tokens&)>;
Tokens read_and_tokenize_line();
void larger_command(const Tokens&);
std::map<std::string, Action> dispatch_table = {
{"a", [&](const Tokens& tokens){ my_database->set("a", tokens[1]); }},
{"larger_command", &larger_command},
};
You could write your core loop as follows:
while (true) {
auto tokens = read_and_tokenize_line();
if (tokens[0] == "quit")
break;
if (auto it = dispatch_table.find(tokens[0]); it != dispatch_table.end()) {
it->second(tokens);
} else {
std::cerr << "command " << tokens[0] << " not known" << std::endl;
}
}

Answer 2

The main problem you have is that your parser run in a while loop and that will obviously block your UI. I assume this issue is the (unstated) problem you are trying to solve.
First, there exist parsers that don't need to run in a while loop. bison can generate such parsers when in push mode. By using this kind of parser you can still rely on your main GUI event loop and feed the parser with tokens inside a callback without blocking.
Then, if you are writing yourself a recursive-descent parser, you can generate a parser that will interrupt itself and save its state each time it needs some input. This is going to be very tricky as you have to save the whole state of the parser including its stack. The way to do it is to use an explicit stack (or many stacks, one for each operand type) for all functions and rewrite the function calls as a big loop inside a switch statement. This is (very) hard and not maintainable. You can start by reading this article (which deals with a simpler version of the problem).
Finally, you can use a background thread to host your parser's while loop. Send data to the parser using a pipe or a queue with a semaphore (if you can customize the input method). The issue here is that this background thread will (probably) not be able to update the UI because most framework are not thread-safe. So you will need a mechanism to send back information from the parser to the main UI thread (something like PostMessage.
References
Bison - push-parser interface, GNU, https://www.gnu.org/software/bison/manual/html_node/Push-Parser-Function.html
Coroutines in C, Simon Tatham, https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
Win32 API - PostMessage, Microsoft, https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-postmessagea