668 lines
15 KiB
C++
668 lines
15 KiB
C++
#include "CmdHelper.hpp"
|
|
|
|
namespace Unvirt::CmdHelper {
|
|
|
|
#pragma region CmdSplitter
|
|
|
|
std::deque<std::string> CmdSplitter::Convert(const std::string& u8cmd) {
|
|
// set up variables
|
|
std::deque<std::string> result;
|
|
std::string buffer;
|
|
mBuffer = &buffer;
|
|
mResult = &result;
|
|
mState = mPreState = StateType::SPACE;
|
|
|
|
// split
|
|
for (auto& c : u8cmd) {
|
|
mCmdChar = c;
|
|
|
|
// skip all invalid characters, \0 and etc.
|
|
// mCmdChar >= 0 to ensure all non-ASCII UTF8 char can be accepted directly.
|
|
if (mCmdChar >= 0 && (!std::isprint(mCmdChar)))
|
|
continue;
|
|
|
|
switch (mState) {
|
|
case StateType::SPACE:
|
|
ProcSpace();
|
|
break;
|
|
case StateType::SINGLE:
|
|
ProcSingle();
|
|
break;
|
|
case StateType::DOUBLE:
|
|
ProcDouble();
|
|
break;
|
|
case StateType::ESCAPE:
|
|
ProcEscape();
|
|
break;
|
|
case StateType::NORMAL:
|
|
ProcNormal();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// final proc
|
|
switch (mState) {
|
|
case StateType::SPACE:
|
|
break;
|
|
case StateType::NORMAL:
|
|
// push the last one
|
|
mResult->push_back(*mBuffer);
|
|
break;
|
|
case StateType::SINGLE:
|
|
case StateType::DOUBLE:
|
|
case StateType::ESCAPE:
|
|
// error
|
|
result.clear();
|
|
break;
|
|
}
|
|
|
|
// return value
|
|
return result;
|
|
}
|
|
|
|
void CmdSplitter::ProcSpace(void) {
|
|
switch (mCmdChar) {
|
|
case '\'':
|
|
mState = StateType::SINGLE;
|
|
break;
|
|
case '"':
|
|
mState = StateType::DOUBLE;
|
|
break;
|
|
case '\\':
|
|
mState = StateType::ESCAPE;
|
|
mPreState = StateType::NORMAL;
|
|
break;
|
|
case ' ':
|
|
break; // skip blank
|
|
default:
|
|
mBuffer->push_back(mCmdChar);
|
|
mState = StateType::NORMAL;
|
|
break;
|
|
}
|
|
}
|
|
void CmdSplitter::ProcSingle(void) {
|
|
switch (mCmdChar) {
|
|
case '\'':
|
|
mState = StateType::NORMAL;
|
|
break;
|
|
case '"':
|
|
mBuffer->push_back('"');
|
|
break;
|
|
case '\\':
|
|
mState = StateType::ESCAPE;
|
|
mPreState = StateType::SINGLE;
|
|
break;
|
|
case ' ':
|
|
mBuffer->push_back(' ');
|
|
break;
|
|
default:
|
|
mBuffer->push_back(mCmdChar);
|
|
break;
|
|
}
|
|
}
|
|
void CmdSplitter::ProcDouble(void) {
|
|
switch (mCmdChar) {
|
|
case '\'':
|
|
mBuffer->push_back('\'');
|
|
break;
|
|
case '"':
|
|
mState = StateType::NORMAL;
|
|
break;
|
|
case '\\':
|
|
mState = StateType::ESCAPE;
|
|
mPreState = StateType::DOUBLE;
|
|
break;
|
|
case ' ':
|
|
mBuffer->push_back(' ');
|
|
break;
|
|
default:
|
|
mBuffer->push_back(mCmdChar);
|
|
break;
|
|
}
|
|
}
|
|
void CmdSplitter::ProcEscape(void) {
|
|
// add itself
|
|
mBuffer->push_back(mCmdChar);
|
|
// restore state
|
|
mState = mPreState;
|
|
}
|
|
void CmdSplitter::ProcNormal(void) {
|
|
switch (mCmdChar) {
|
|
case '\'':
|
|
mBuffer->push_back('\'');
|
|
break;
|
|
case '"':
|
|
mBuffer->push_back('"');
|
|
break;
|
|
case '\\':
|
|
mState = StateType::ESCAPE;
|
|
mPreState = StateType::NORMAL;
|
|
break;
|
|
case ' ':
|
|
mResult->push_back(*mBuffer);
|
|
mBuffer->clear();
|
|
mState = StateType::SPACE;
|
|
break;
|
|
default:
|
|
mBuffer->push_back(mCmdChar);
|
|
break;
|
|
}
|
|
}
|
|
#pragma endregion
|
|
|
|
#pragma region Help Document
|
|
|
|
HelpDocument::HelpDocument() : m_Stack(), m_Results() {}
|
|
|
|
HelpDocument::~HelpDocument() {}
|
|
|
|
void HelpDocument::Push(const std::string& arg_name, const std::string& arg_desc) {
|
|
m_Stack.emplace_back(StackItem { arg_name, arg_desc });
|
|
}
|
|
|
|
void HelpDocument::Pop() {
|
|
m_Stack.pop_back();
|
|
}
|
|
|
|
void HelpDocument::Terminate(std::string& command_desc) {
|
|
// create new result and copy stack
|
|
ResultItem result(command_desc);
|
|
result.m_ArgDesc.insert(result.m_ArgDesc.end(), m_Stack.begin(), m_Stack.end());
|
|
// add into result
|
|
m_Results.emplace_back(std::move(result));
|
|
}
|
|
|
|
void HelpDocument::Print() {
|
|
for (auto& item : m_Results) {
|
|
fputs("Syntax: ", stdout);
|
|
for (auto& cmd : item.m_ArgDesc) {
|
|
fputs(cmd.m_Name.c_str(), stdout);
|
|
fputc(' ', stdout);
|
|
}
|
|
fputc('\n', stdout);
|
|
|
|
if (!item.m_CmdDesc.empty()) {
|
|
fprintf(stdout, "Description: %s\n", item.m_CmdDesc.c_str());
|
|
}
|
|
|
|
for (auto& cmd : item.m_ArgDesc) {
|
|
if (!cmd.m_Desc.empty()) {
|
|
fprintf(stdout, "\t%s: %s\n", cmd.m_Name.c_str(), cmd.m_Desc.c_str());
|
|
}
|
|
}
|
|
|
|
fputc('\n', stdout);
|
|
}
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Abstract Node
|
|
|
|
AbstractNode::AbstractNode() :
|
|
m_Execution(nullptr), m_Comment(),
|
|
m_Literals(), m_Choices(), m_Args() {}
|
|
|
|
AbstractNode::~AbstractNode() {
|
|
for (auto& ptr : m_Literals) {
|
|
delete ptr;
|
|
}
|
|
for (auto& ptr : m_Choices) {
|
|
delete ptr;
|
|
}
|
|
for (auto& ptr : m_Args) {
|
|
delete ptr;
|
|
}
|
|
}
|
|
|
|
AbstractNode* AbstractNode::Then(AbstractNode* node) {
|
|
// check conflict
|
|
for (auto& pnode : m_Literals) {
|
|
if (pnode->IsConflictWith(node))
|
|
throw std::invalid_argument("conflict node.");
|
|
}
|
|
for (auto& pnode : m_Choices) {
|
|
if (pnode->IsConflictWith(node))
|
|
throw std::invalid_argument("conflict node.");
|
|
}
|
|
for (auto& pnode : m_Args) {
|
|
if (pnode->IsConflictWith(node))
|
|
throw std::invalid_argument("conflict node.");
|
|
}
|
|
|
|
// add into list
|
|
switch (node->GetNodeType()) {
|
|
case NodeType::Literal:
|
|
m_Literals.emplace_back(node);
|
|
break;
|
|
case NodeType::Choice:
|
|
m_Choices.emplace_back(node);
|
|
break;
|
|
case NodeType::Argument:
|
|
m_Args.emplace_back(node);
|
|
break;
|
|
default:
|
|
throw std::runtime_error("No such node type.");
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
AbstractNode* AbstractNode::Executes(ExecutionFct fct, const char* cmt) {
|
|
if (m_Execution != nullptr) throw std::invalid_argument("duplicated executions.");
|
|
if (fct == nullptr) throw std::invalid_argument("no function.");
|
|
m_Execution = fct;
|
|
m_ExecutionDesc = cmt == nullptr ? "" : cmt;
|
|
return this;
|
|
}
|
|
|
|
AbstractNode* AbstractNode::Comment(const char* cmt) {
|
|
if (cmt == nullptr)
|
|
throw std::invalid_argument("no comment.");
|
|
m_Comment = cmt;
|
|
return this;
|
|
}
|
|
|
|
void AbstractNode::Help(HelpDocument* doc) {
|
|
// add self
|
|
std::string symbol(GetHelpSymbol());
|
|
doc->Push(symbol, m_Comment);
|
|
|
|
// check terminal
|
|
if (m_Execution != nullptr) {
|
|
doc->Terminate(m_ExecutionDesc);
|
|
}
|
|
|
|
// iterate children
|
|
for (auto& pnode : m_Literals) {
|
|
pnode->Help(doc);
|
|
}
|
|
for (auto& pnode : m_Choices) {
|
|
pnode->Help(doc);
|
|
}
|
|
for (auto& pnode : m_Args) {
|
|
pnode->Help(doc);
|
|
}
|
|
|
|
// pop self
|
|
doc->Pop();
|
|
}
|
|
|
|
bool AbstractNode::Consume(std::deque<std::string>& arglist, ArgumentsMap* argmap) {
|
|
// if no data can consume, return
|
|
if (arglist.empty()) return false;
|
|
|
|
// backup current value
|
|
std::string cur = arglist.front();
|
|
// consume self
|
|
if (!BeginAccept(cur, argmap)) {
|
|
// fail to consume self. not matched. return
|
|
return false;
|
|
}
|
|
|
|
// pop front for following code
|
|
arglist.pop_front();
|
|
|
|
#define CONSUME_DEFER \
|
|
arglist.push_front(cur); \
|
|
EndAccept(argmap);
|
|
|
|
if (arglist.empty()) {
|
|
// this is must be a terminal.
|
|
// check whether we have execution.
|
|
if (m_Execution == nullptr) {
|
|
CONSUME_DEFER;
|
|
return false;
|
|
} else {
|
|
m_Execution(argmap);
|
|
CONSUME_DEFER;
|
|
return true;
|
|
}
|
|
} else {
|
|
// have following command, try match them
|
|
// iterate literal and argument to check terminal
|
|
for (auto& pnode : m_Literals) {
|
|
if (pnode->Consume(arglist, argmap)) {
|
|
CONSUME_DEFER;
|
|
return true;
|
|
}
|
|
}
|
|
for (auto& pnode : m_Choices) {
|
|
if (pnode->Consume(arglist, argmap)) {
|
|
CONSUME_DEFER;
|
|
return true;
|
|
}
|
|
}
|
|
for (auto& pnode : m_Args) {
|
|
if (pnode->Consume(arglist, argmap)) {
|
|
CONSUME_DEFER;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// if still nothing to match, return false
|
|
CONSUME_DEFER;
|
|
return false;
|
|
}
|
|
|
|
#undef CONSUME_DEFER
|
|
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Command Root
|
|
|
|
CommandRoot::CommandRoot() : AbstractNode() {}
|
|
|
|
CommandRoot::~CommandRoot() {}
|
|
|
|
bool CommandRoot::RootConsume(std::deque<std::string>& arglist) {
|
|
// if no data can consume, return
|
|
if (arglist.empty()) return false;
|
|
|
|
// create a argument map
|
|
ArgumentsMap amap;
|
|
|
|
// and we only just need iterate all children
|
|
for (auto& pnode : m_Literals) {
|
|
if (pnode->Consume(arglist, &amap)) {
|
|
return true;
|
|
}
|
|
}
|
|
for (auto& pnode : m_Choices) {
|
|
if (pnode->Consume(arglist, &amap)) {
|
|
return true;
|
|
}
|
|
}
|
|
for (auto& pnode : m_Args) {
|
|
if (pnode->Consume(arglist, &amap)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// no matched
|
|
return false;
|
|
}
|
|
|
|
HelpDocument* CommandRoot::RootHelp() {
|
|
HelpDocument* doc = new HelpDocument();
|
|
|
|
// we only just need iterate all children
|
|
for (auto& pnode : m_Literals) {
|
|
pnode->Help(doc);
|
|
}
|
|
for (auto& pnode : m_Choices) {
|
|
pnode->Help(doc);
|
|
}
|
|
for (auto& pnode : m_Args) {
|
|
pnode->Help(doc);
|
|
}
|
|
|
|
return doc;
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Literal
|
|
|
|
Literal::Literal(const char* words) :
|
|
AbstractNode(),
|
|
m_Literal(words == nullptr ? "" : words) {
|
|
if (words == nullptr || m_Literal.empty())
|
|
throw std::invalid_argument("Invalid literal.");
|
|
}
|
|
|
|
Literal::~Literal() {}
|
|
|
|
NodeType Literal::GetNodeType() {
|
|
return NodeType::Literal;
|
|
}
|
|
|
|
bool Literal::IsConflictWith(AbstractNode* node) {
|
|
switch (node->GetNodeType()) {
|
|
case NodeType::Literal:
|
|
return dynamic_cast<Literal*>(node)->m_Literal == m_Literal;
|
|
case NodeType::Choice:
|
|
for (const auto& item : dynamic_cast<Choice*>(node)->m_Vocabulary) {
|
|
if (item == m_Literal) return true;
|
|
}
|
|
return false;
|
|
case NodeType::Argument:
|
|
return false;
|
|
default:
|
|
throw std::runtime_error("No such node type.");
|
|
}
|
|
}
|
|
|
|
std::string Literal::GetHelpSymbol() {
|
|
return m_Literal;
|
|
}
|
|
|
|
bool Literal::BeginAccept(const std::string& strl, ArgumentsMap*) {
|
|
return strl == m_Literal;
|
|
}
|
|
|
|
void Literal::EndAccept(ArgumentsMap*) {}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Choice
|
|
|
|
Choice::Choice(const char* argname, const std::initializer_list<std::string>& vocabulary) :
|
|
AbstractNode(),
|
|
m_GottenIndex(0u), m_Accepted(false),
|
|
m_ChoiceName(argname == nullptr ? "" : argname), m_Vocabulary(vocabulary) {
|
|
if (argname == nullptr || m_ChoiceName.empty())
|
|
throw std::invalid_argument("Invalid choice name.");
|
|
if (m_Vocabulary.size() < 2)
|
|
throw std::invalid_argument("Too less vocabulary. At least 2 items.");
|
|
}
|
|
|
|
Choice::~Choice() {}
|
|
|
|
size_t* Choice::GetIndex() {
|
|
return &m_GottenIndex;
|
|
}
|
|
|
|
NodeType Choice::GetNodeType() {
|
|
return NodeType::Choice;
|
|
}
|
|
|
|
bool Choice::IsConflictWith(AbstractNode* node) {
|
|
switch (node->GetNodeType()) {
|
|
case NodeType::Literal:
|
|
{
|
|
Literal* pliteral = dynamic_cast<Literal*>(node);
|
|
for (const auto& word : m_Vocabulary) {
|
|
if (word == pliteral->m_Literal)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
case NodeType::Choice:
|
|
{
|
|
Choice* pchoice = dynamic_cast<Choice*>(node);
|
|
if (pchoice->m_ChoiceName == m_ChoiceName)
|
|
return true;
|
|
|
|
for (const auto& thisword : m_Vocabulary) {
|
|
for (const auto& thatword : pchoice->m_Vocabulary) {
|
|
if (thisword == thatword)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
case NodeType::Argument:
|
|
return m_ChoiceName == dynamic_cast<AbstractArgument*>(node)->m_ArgName;
|
|
default:
|
|
throw std::runtime_error("No such node type.");
|
|
}
|
|
}
|
|
|
|
std::string Choice::GetHelpSymbol() {
|
|
std::string switches;
|
|
for (const auto& item : m_Vocabulary) {
|
|
if (!switches.empty()) switches += " | ";
|
|
switches += item;
|
|
}
|
|
return "[" + switches + "]";
|
|
}
|
|
|
|
bool Choice::BeginAccept(const std::string& strl, ArgumentsMap* amap) {
|
|
for (size_t i = 0; i < m_Vocabulary.size(); ++i) {
|
|
if (strl == m_Vocabulary[i]) {
|
|
m_Accepted = true;
|
|
m_GottenIndex = i;
|
|
amap->Add(m_ChoiceName, this);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void Choice::EndAccept(ArgumentsMap* amap) {
|
|
if (m_Accepted) {
|
|
m_Accepted = false;
|
|
amap->Remove(m_ChoiceName);
|
|
}
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Abstract Argument
|
|
|
|
AbstractArgument::AbstractArgument(const char* argname) :
|
|
AbstractNode(),
|
|
m_ArgName(argname == nullptr ? "" : argname),
|
|
m_Accepted(false), m_ParsedData(nullptr) {
|
|
if (argname == nullptr || m_ArgName.empty())
|
|
throw std::invalid_argument("Invalid argument name.");
|
|
}
|
|
|
|
AbstractArgument::~AbstractArgument() {}
|
|
|
|
NodeType AbstractArgument::GetNodeType() {
|
|
return NodeType::Argument;
|
|
}
|
|
|
|
bool AbstractArgument::IsConflictWith(AbstractNode* node) {
|
|
switch (node->GetNodeType()) {
|
|
case NodeType::Literal:
|
|
return false;
|
|
case NodeType::Choice:
|
|
return m_ArgName == dynamic_cast<Choice*>(node)->m_ChoiceName;
|
|
case NodeType::Argument:
|
|
return m_ArgName == dynamic_cast<AbstractArgument*>(node)->m_ArgName;
|
|
default:
|
|
throw std::runtime_error("No such node type.");
|
|
}
|
|
}
|
|
|
|
std::string AbstractArgument::GetHelpSymbol() {
|
|
std::string newargname = "<";
|
|
newargname.append(m_ArgName);
|
|
newargname.append(">");
|
|
return newargname;
|
|
}
|
|
|
|
bool AbstractArgument::BeginAccept(const std::string& strl, ArgumentsMap* amap) {
|
|
m_Accepted = BeginParse(strl);
|
|
if (m_Accepted) amap->Add(m_ArgName, this);
|
|
return m_Accepted;
|
|
}
|
|
|
|
void AbstractArgument::EndAccept(ArgumentsMap* amap) {
|
|
if (m_Accepted) {
|
|
amap->Remove(m_ArgName);
|
|
EndParse();
|
|
m_Accepted = false;
|
|
}
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Argument Detail Impl
|
|
|
|
bool IntArgument::BeginParse(const std::string& val) {
|
|
char* pend = nullptr;
|
|
errno = 0;
|
|
int64_t v = std::strtoll(val.c_str(), &pend, 10);
|
|
|
|
if (pend == val.c_str() || errno == ERANGE) return false;
|
|
|
|
// check limit
|
|
int32_t value = static_cast<int32_t>(v);
|
|
if (m_IntLimit != nullptr && !m_IntLimit(value)) {
|
|
return false;
|
|
}
|
|
|
|
m_ParsedData = new IntArgument::vType(value);
|
|
return true;
|
|
}
|
|
|
|
void IntArgument::EndParse() {
|
|
delete reinterpret_cast<IntArgument::vType*>(m_ParsedData);
|
|
m_ParsedData = nullptr;
|
|
}
|
|
|
|
bool StringArgument::BeginParse(const std::string& strl) {
|
|
// string always accept every text
|
|
m_ParsedData = new StringArgument::vType(strl);
|
|
return true;
|
|
}
|
|
|
|
void StringArgument::EndParse() {
|
|
delete reinterpret_cast<StringArgument::vType*>(m_ParsedData);
|
|
m_ParsedData = nullptr;
|
|
}
|
|
|
|
// Copy from Gamepiaynmo/BallanceModLoader
|
|
std::vector<std::string> SplitString(const std::string& str, const std::string& de) {
|
|
size_t lpos, pos = 0;
|
|
std::vector<std::string> res;
|
|
|
|
lpos = str.find_first_not_of(de, pos);
|
|
while (lpos != std::string::npos) {
|
|
pos = str.find_first_of(de, lpos);
|
|
res.push_back(str.substr(lpos, pos - lpos));
|
|
if (pos == std::string::npos) break;
|
|
|
|
lpos = str.find_first_not_of(de, pos);
|
|
}
|
|
|
|
if (pos != std::string::npos)
|
|
res.push_back("");
|
|
|
|
return res;
|
|
}
|
|
|
|
bool EncodingArgument::BeginParse(const std::string& strl) {
|
|
// encoding always accept every text
|
|
m_ParsedData = new EncodingArgument::vType(SplitString(strl, ","));
|
|
return true;
|
|
}
|
|
|
|
void EncodingArgument::EndParse() {
|
|
delete reinterpret_cast<EncodingArgument::vType*>(m_ParsedData);
|
|
m_ParsedData = nullptr;
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region Argument Map
|
|
|
|
void ArgumentsMap::Add(const std::string& k, AbstractNode* v) {
|
|
m_Data.emplace(std::make_pair(k, v));
|
|
}
|
|
|
|
void ArgumentsMap::Remove(const std::string& k) {
|
|
m_Data.erase(k);
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
}
|