ilusha/Modules
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Apply formating to all files. CLeanup

Browse source
This commit is contained in:
IlyaShurupov 2023-10-22 17:07:28 +03:00 • committed by Ilya Shurupov
parent b4ae5dde77
commit 91fb72bd49
928 changed files with 14515 additions and 21479 deletions
Download patch file Download diff file Expand all files Collapse all files

5
CommandLine/private/CmdLineInterpreter.cpp
View file

@ -38,14 +38,11 @@ void CmdLineInterpreter::help(const CommandLine& args) const {
}
CmdLineInterpreter::CmdLineInterpreter() {
auto helpArgs = new CommandLine{
{ "CommandName", "_none_" }
};
auto helpArgs = new CommandLine{ { "CommandName", "_none_" } };
addCommand("help", helpArgs, (CommandFunction) helpFunction, this);
}
void CmdLineInterpreter::addCommand(const String& id, CommandLine* args, CommandFunction function, void* customData) {
ASSERT(!mCommands.presents(id))
mCommands.put(id, { args, function, customData });

876
CommandLine/private/CommandLine.cpp
View file

@ -1,412 +1,466 @@
#include "NewPlacement.hpp"
#include "CommandLine.hpp"
using namespace tp;
static ModuleManifest* sModuleDependencies[] = { &gModuleTokenizer, &gModuleConnection, nullptr };
ModuleManifest tp::gModuleCommandLine = ModuleManifest("CommandLine", nullptr, nullptr, sModuleDependencies);
const char* regexSpace = "\n|\t| |\r";
const char* regexFalse = "N|n|(False)|(false)";
const char* regexTrue = "Y|y|(True)|(true)";
const char* regexInt = "((\\-)|(\\+))?[0-9]+";
const char* regexFloat = R"(((\-)|(\+))?([0-9]+)(\.)([0-9]*)?)";
const char* regexString = "'{'-'}*'";
CommandLine::Arg::Arg(const Arg& arg) {
mId = arg.mId;
switch (arg.mType) {
case CommandLine::Arg::INT: mType = INT; mInt = arg.mInt; break;
case CommandLine::Arg::FLOAT: mType = FLOAT; mFloat = arg.mFloat; break;
case CommandLine::Arg::BOOL: mType = BOOL; mBool = arg.mBool; break;
case CommandLine::Arg::STR: mType = STR; new (&mStr) StringArg(); mStr = arg.mStr; break;
case CommandLine::Arg::FILE_IN: mType = FILE_IN; new (&mFile) FileInputArg(); mFile = arg.mFile; break;
default:
ASSERT(false)
}
mOptional = arg.mOptional;
}
CommandLine::Arg::Arg(const String& id, Type type) {
mId = id;
switch (type) {
case CommandLine::Arg::INT: mType = INT; new (&mInt) IntArg(); break;
case CommandLine::Arg::FLOAT: mType = FLOAT; new (&mFloat) FloatArg(); break;
case CommandLine::Arg::BOOL: mType = BOOL; new (&mBool) BoolArg(); break;
case CommandLine::Arg::STR: mType = STR; new (&mStr) StringArg(); break;
case CommandLine::Arg::FILE_IN: mType = FILE_IN; new (&mFile) FileInputArg(); break;
default: ASSERT(false)
}
mOptional = false;
}
CommandLine::Arg::Arg(const String& id, const Range<alni>& aAcceptingRange) {
mId = id;
mType = FLOAT;
mInt = { 0, 0, aAcceptingRange };
mOptional = false;
}
CommandLine::Arg::Arg(const String& id, const Range<alnf>& aAcceptingRange) {
mId = id;
mType = FLOAT;
mFloat = { 0, 0, aAcceptingRange };
mOptional = false;
}
CommandLine::Arg::Arg(const String& id, const Range<alni>& aAcceptingRange, alni aDefault) {
mId = id;
mType = INT;
mInt = { 0, aDefault, aAcceptingRange };
}
CommandLine::Arg::Arg(const String& id, const Range<alnf>& aAcceptingRange, alnf aDefault) {
mId = id;
mType = FLOAT;
mFloat = { 0, aDefault, aAcceptingRange };
}
CommandLine::Arg::Arg(const String& id, bool aDefault) {
mId = id;
mType = BOOL;
mBool.mDefault = aDefault;
}
CommandLine::Arg::Arg(const String& id, const char* aDefault) {
mId = id;
mType = STR;
new (&mStr) StringArg();
mStr.mDefault = aDefault;
}
CommandLine::Arg::~Arg() {
switch (mType) {
case CommandLine::Arg::STR:
mStr.~StringArg();
break;
case CommandLine::Arg::FILE_IN:
mFile.~FileInputArg();
break;
default:
break;
}
}
CommandLine::CommandLine(const InitialierList<Arg>& args) {
bool optional_start = false;
for (auto& arg : args) {
ASSERT(!mArgs.presents(arg.mId) && "Argument Redefinition")
auto copy_arg = new Arg(arg);
mArgs.put(arg.mId, copy_arg);
mArgsOrder.pushBack(mArgs.get(arg.mId));
if (arg.mOptional) {
mOptionals++;
}
if (optional_start) {
ASSERT(arg.mOptional && "Not Optional Argument After Optionals")
}
else if (arg.mOptional) {
optional_start = true;
}
}
mTokenizer.build({
{ regexSpace, TokType::SPACE },
{ regexFalse, TokType::BOOL_FALSE },
{ regexTrue, TokType::BOOL_TRUE },
{ regexInt, TokType::INT },
{ regexFloat, TokType::FLOAT },
{ regexString, TokType::STR },
});
ASSERT(mTokenizer.isBuild() && "Internal Error")
mArgumentTokenizer.build({
{ regexSpace, ArgTokType::SPACE },
{ "{ - }*", ArgTokType::ARG }
});
ASSERT(mTokenizer.isBuild() && "Internal Error")
}
CommandLine::~CommandLine() {
for (auto arg : mArgsOrder) {
delete arg.data();
}
}
bool CommandLine::parse(char argc, const char* argv[], bool logError, ualni skipArgs) {
// discard some arguments
argc -= (char) skipArgs;
argv += skipArgs;
if (argc < mArgs.size() - mOptionals) {
ErrInvalidArgCount();
if (logError) {
ErrLog();
}
return false;
}
ualni idx = 0;
for (auto arg : mArgsOrder) {
if (idx < argc) {
parseArg(*arg.data(), argv[idx]);
} else {
initDefault(*arg.data());
}
if (mError) {
if (logError) ErrLog();
return false;
}
idx++;
}
return true;
}
bool CommandLine::parse(const char* args, bool logError) {
mArgumentTokenizer.bindSource(args);
mArgumentTokenizer.reset();
ualni argc = 0;
auto tok = mArgumentTokenizer.readTok();
auto argument = mArgsOrder.first();
while (tok != ArgTokType::FAILURE && tok != ArgTokType::END) {
if (tok != ArgTokType::ARG) {
tok = mArgumentTokenizer.readTok();
continue;
}
if (!argument) {
ErrInvalidArgCount();
if (logError) ErrLog();
return false;
}
parseArg(*argument->data, mArgumentTokenizer.extractVal().read());
if (mError && logError) {
ErrLog();
return false;
}
argc++;
argument = argument->next;
tok = mArgumentTokenizer.readTok();
}
ualni idx = 0;
for (auto arg : mArgsOrder) {
if (idx >= argc) {
initDefault(*arg.data());
}
if (mError) {
if (logError) ErrLog();
return false;
}
idx++;
}
return true;
}
alni CommandLine::getInt(const String& id) const { auto& arg = getArg(id, Arg::INT); return arg.mInt.mVal; }
alnf CommandLine::getFloat(const String& id) const { auto& arg = getArg(id, Arg::FLOAT); return arg.mFloat.mVal; }
bool CommandLine::getBool(const String& id) const { auto& arg = getArg(id, Arg::BOOL); return arg.mBool.mFlag; }
const String& CommandLine::getString(const String& id) const { auto& arg = getArg(id, Arg::STR); return arg.mStr.mStr; }
const LocalConnection::Location& CommandLine::getFile(const String& id) const { auto& arg = getArg(id, Arg::FILE_IN); return arg.mFile.mFileLocation; }
CommandLine::Arg& CommandLine::getArg(const String& id, Arg::Type type) {
auto idx = mArgs.presents(id);
ASSERT(idx && "Invalid Id")
auto& arg = mArgs.getSlotVal(idx);
ASSERT(arg->mType == type && "Invalid Type Requested")
return *arg;
}
const CommandLine::Arg& CommandLine::getArg(const String& id, Arg::Type type) const {
auto idx = mArgs.presents(id);
ASSERT(idx && "Invalid Id")
auto& arg = mArgs.getSlotVal(idx);
ASSERT(arg->mType == type && "Invalid Type Requested")
return *arg;
}
void CommandLine::ErrInvalidArgCount() { mError = { "Invalid Number Of Arguments Passed", nullptr }; }
void CommandLine::ErrInvalidArgSyntax(Arg* arg) { mError = { "Invalid Syntax Of Argument", arg }; }
void CommandLine::ErrInvalidArgType(Arg* arg) { mError = { "Invalid Type Of Argument", arg }; }
void CommandLine::ErrFileNotExists(Arg* arg) { mError = { "File Not Exists", arg }; }
void CommandLine::ErrFileCouldNotOpen(Arg* arg) { mError = { "Could Not Open File", arg }; }
void CommandLine::ErrValNotinRange(Arg* arg) { mError = { "Value Not In Range", arg }; }
void CommandLine::ErrLog() {
printf("\nERROR : Invalid Command Line\n");
if (mError.mArg) {
alni idx = 0;
for (auto arg : mArgsOrder) {
if (mError.mArg == arg.data()) break;
idx++;
}
printf("\nArgument: %lli\n", idx);
logArg(*mError.mArg);
}
printf("Error Description: %s. \n", mError.mDescr);
printf("\nExpected Arguments are: \n");
ualni idx = 0;
for (auto arg : mArgsOrder) {
printf(" -- %lli -- \n", idx);
logArg(*arg.data());
idx++;
}
printf("\nNote regex for types are:\n");
printf(" False - %s\n", regexFalse);
printf(" True - %s\n", regexTrue);
printf(" Int - %s\n", regexInt);
printf(" Float - %s\n", regexFloat);
printf(" String - %s\n", regexString);
printf(" File - else\n");
}
void CommandLine::logArg(const Arg& arg) {
switch (arg.mType) {
case Arg::INT: {
printf("Type : Int\n");
printf("Range : %lli - %lli\n", arg.mInt.mAcceptingRange.mBegin, arg.mInt.mAcceptingRange.mEnd);
if (arg.mOptional) {
printf("Default : %lli\n", arg.mInt.mDefault);
}
printf("Value : %lli\n", arg.mInt.mVal);
} break;
case Arg::FLOAT: {
printf("Type : Float\n");
printf("Range : %f - %f\n", (halnf) arg.mFloat.mAcceptingRange.mBegin, (halnf) arg.mFloat.mAcceptingRange.mEnd);
if (arg.mOptional) {
printf("Default : %f\n", arg.mFloat.mDefault);
}
printf("Value : %f\n", arg.mFloat.mVal);
} break;
case Arg::BOOL: {
printf("Type : Bool\n");
if (arg.mOptional) {
printf("Default : %s\n", arg.mBool.mDefault ? "True" : "False");
}
printf("Value : %s\n", arg.mBool.mFlag ? "True" : "False");
} break;
case Arg::STR: {
printf("Type : String\n");
if (arg.mOptional) {
printf("Default : %s\n", arg.mStr.mDefault.read());
}
printf("Value : %s\n", arg.mStr.mStr.read());
} break;
case Arg::FILE_IN: {
printf("Type : File Input\n");
printf("Value Path : %s\n", arg.mFile.mFileLocation.getLocation().read());
} break;
default: ASSERT(false)
}
}
void CommandLine::initDefault(Arg& arg) {
switch (arg.mType) {
case Arg::INT: arg.mInt.mVal = arg.mInt.mDefault; break;
case Arg::FLOAT: arg.mFloat.mVal = arg.mFloat.mDefault; break;
case Arg::BOOL: arg.mBool.mFlag = arg.mBool.mDefault; break;
case Arg::STR: arg.mStr.mStr = arg.mStr.mDefault; break;
default:
break;
}
}
void CommandLine::parseArg(Arg& arg, const char* src) {
mTokenizer.reset();
mTokenizer.bindSource(src);
auto tok = mTokenizer.readTok();
if (tok < TokType::INT || tok > TokType::STR) {
ErrInvalidArgSyntax(&arg);
return;
}
auto val = mTokenizer.extractVal();
switch (arg.mType) {
case Arg::INT: {
if (tok != TokType::INT) {
ErrInvalidArgType(&arg);
return;
}
auto converted = String::Logic::convertStringToValue(val.read(), arg.mInt.mVal);
if (converted && arg.mInt.mVal < arg.mInt.mAcceptingRange.mBegin || arg.mInt.mVal > arg.mInt.mAcceptingRange.mEnd) {
ErrValNotinRange(&arg);
return;
}
} break;
case Arg::FLOAT: {
if (tok != TokType::FLOAT) {
ErrInvalidArgType(&arg);
return;
}
auto converted = String::Logic::convertStringToValue(val.read(), arg.mFloat.mVal);
if (converted && arg.mFloat.mVal < arg.mFloat.mAcceptingRange.mBegin || arg.mFloat.mVal > arg.mFloat.mAcceptingRange.mEnd) {
ErrValNotinRange(&arg);
return;
}
} break;
case Arg::STR: {
if (tok != TokType::STR) {
ErrInvalidArgType(&arg);
return;
}
arg.mStr.mStr.resize(val.size() - 2);
memCopy(arg.mStr.mStr.write(), val.read() + 1, val.size() - 2);
} break;
case Arg::BOOL: {
if (tok != TokType::BOOL_FALSE && tok != TokType::BOOL_TRUE) {
ErrInvalidArgType(&arg);
return;
}
arg.mBool.mFlag = tok == TokType::BOOL_TRUE;
} break;
case Arg::FILE_IN: {
if (tok != TokType::STR) {
ErrInvalidArgType(&arg);
return;
}
arg.mFile.mFileLocation.setLocation(val);
if (!arg.mFile.mFileLocation.exists()) {
ErrFileNotExists(&arg);
return;
}
} break;
default: ASSERT(false)
}
arg.mIsPassed = true;
}
void CommandLine::help() const {
printf("Arguments:\n");
for (auto arg : mArgsOrder) {
logArg(*arg.data());
}
#include "NewPlacement.hpp"
#include "CommandLine.hpp"
using namespace tp;
static ModuleManifest* sModuleDependencies[] = { &gModuleTokenizer, &gModuleConnection, nullptr };
ModuleManifest tp::gModuleCommandLine = ModuleManifest("CommandLine", nullptr, nullptr, sModuleDependencies);
const char* regexSpace = "\n|\t| |\r";
const char* regexFalse = "N|n|(False)|(false)";
const char* regexTrue = "Y|y|(True)|(true)";
const char* regexInt = "((\\-)|(\\+))?[0-9]+";
const char* regexFloat = R"(((\-)|(\+))?([0-9]+)(\.)([0-9]*)?)";
const char* regexString = "'{'-'}*'";
CommandLine::Arg::Arg(const Arg& arg) {
mId = arg.mId;
switch (arg.mType) {
case CommandLine::Arg::INT:
mType = INT;
mInt = arg.mInt;
break;
case CommandLine::Arg::FLOAT:
mType = FLOAT;
mFloat = arg.mFloat;
break;
case CommandLine::Arg::BOOL:
mType = BOOL;
mBool = arg.mBool;
break;
case CommandLine::Arg::STR:
mType = STR;
new (&mStr) StringArg();
mStr = arg.mStr;
break;
case CommandLine::Arg::FILE_IN:
mType = FILE_IN;
new (&mFile) FileInputArg();
mFile = arg.mFile;
break;
default: ASSERT(false)
}
mOptional = arg.mOptional;
}
CommandLine::Arg::Arg(const String& id, Type type) {
mId = id;
switch (type) {
case CommandLine::Arg::INT:
mType = INT;
new (&mInt) IntArg();
break;
case CommandLine::Arg::FLOAT:
mType = FLOAT;
new (&mFloat) FloatArg();
break;
case CommandLine::Arg::BOOL:
mType = BOOL;
new (&mBool) BoolArg();
break;
case CommandLine::Arg::STR:
mType = STR;
new (&mStr) StringArg();
break;
case CommandLine::Arg::FILE_IN:
mType = FILE_IN;
new (&mFile) FileInputArg();
break;
default: ASSERT(false)
}
mOptional = false;
}
CommandLine::Arg::Arg(const String& id, const Range<alni>& aAcceptingRange) {
mId = id;
mType = FLOAT;
mInt = { 0, 0, aAcceptingRange };
mOptional = false;
}
CommandLine::Arg::Arg(const String& id, const Range<alnf>& aAcceptingRange) {
mId = id;
mType = FLOAT;
mFloat = { 0, 0, aAcceptingRange };
mOptional = false;
}
CommandLine::Arg::Arg(const String& id, const Range<alni>& aAcceptingRange, alni aDefault) {
mId = id;
mType = INT;
mInt = { 0, aDefault, aAcceptingRange };
}
CommandLine::Arg::Arg(const String& id, const Range<alnf>& aAcceptingRange, alnf aDefault) {
mId = id;
mType = FLOAT;
mFloat = { 0, aDefault, aAcceptingRange };
}
CommandLine::Arg::Arg(const String& id, bool aDefault) {
mId = id;
mType = BOOL;
mBool.mDefault = aDefault;
}
CommandLine::Arg::Arg(const String& id, const char* aDefault) {
mId = id;
mType = STR;
new (&mStr) StringArg();
mStr.mDefault = aDefault;
}
CommandLine::Arg::~Arg() {
switch (mType) {
case CommandLine::Arg::STR: mStr.~StringArg(); break;
case CommandLine::Arg::FILE_IN: mFile.~FileInputArg(); break;
default: break;
}
}
CommandLine::CommandLine(const InitialierList<Arg>& args) {
bool optional_start = false;
for (auto& arg : args) {
ASSERT(!mArgs.presents(arg.mId) && "Argument Redefinition")
auto copy_arg = new Arg(arg);
mArgs.put(arg.mId, copy_arg);
mArgsOrder.pushBack(mArgs.get(arg.mId));
if (arg.mOptional) {
mOptionals++;
}
if (optional_start) {
ASSERT(arg.mOptional && "Not Optional Argument After Optionals")
} else if (arg.mOptional) {
optional_start = true;
}
}
mTokenizer.build({
{ regexSpace, TokType::SPACE },
{ regexFalse, TokType::BOOL_FALSE },
{ regexTrue, TokType::BOOL_TRUE },
{ regexInt, TokType::INT },
{ regexFloat, TokType::FLOAT },
{ regexString, TokType::STR },
});
ASSERT(mTokenizer.isBuild() && "Internal Error")
mArgumentTokenizer.build({ { regexSpace, ArgTokType::SPACE }, { "{ - }*", ArgTokType::ARG } });
ASSERT(mTokenizer.isBuild() && "Internal Error")
}
CommandLine::~CommandLine() {
for (auto arg : mArgsOrder) {
delete arg.data();
}
}
bool CommandLine::parse(char argc, const char* argv[], bool logError, ualni skipArgs) {
// discard some arguments
argc -= (char) skipArgs;
argv += skipArgs;
if (argc < mArgs.size() - mOptionals) {
ErrInvalidArgCount();
if (logError) {
ErrLog();
}
return false;
}
ualni idx = 0;
for (auto arg : mArgsOrder) {
if (idx < argc) {
parseArg(*arg.data(), argv[idx]);
} else {
initDefault(*arg.data());
}
if (mError) {
if (logError) ErrLog();
return false;
}
idx++;
}
return true;
}
bool CommandLine::parse(const char* args, bool logError) {
mArgumentTokenizer.bindSource(args);
mArgumentTokenizer.reset();
ualni argc = 0;
auto tok = mArgumentTokenizer.readTok();
auto argument = mArgsOrder.first();
while (tok != ArgTokType::FAILURE && tok != ArgTokType::END) {
if (tok != ArgTokType::ARG) {
tok = mArgumentTokenizer.readTok();
continue;
}
if (!argument) {
ErrInvalidArgCount();
if (logError) ErrLog();
return false;
}
parseArg(*argument->data, mArgumentTokenizer.extractVal().read());
if (mError && logError) {
ErrLog();
return false;
}
argc++;
argument = argument->next;
tok = mArgumentTokenizer.readTok();
}
ualni idx = 0;
for (auto arg : mArgsOrder) {
if (idx >= argc) {
initDefault(*arg.data());
}
if (mError) {
if (logError) ErrLog();
return false;
}
idx++;
}
return true;
}
alni CommandLine::getInt(const String& id) const {
auto& arg = getArg(id, Arg::INT);
return arg.mInt.mVal;
}
alnf CommandLine::getFloat(const String& id) const {
auto& arg = getArg(id, Arg::FLOAT);
return arg.mFloat.mVal;
}
bool CommandLine::getBool(const String& id) const {
auto& arg = getArg(id, Arg::BOOL);
return arg.mBool.mFlag;
}
const String& CommandLine::getString(const String& id) const {
auto& arg = getArg(id, Arg::STR);
return arg.mStr.mStr;
}
const LocalConnection::Location& CommandLine::getFile(const String& id) const {
auto& arg = getArg(id, Arg::FILE_IN);
return arg.mFile.mFileLocation;
}
CommandLine::Arg& CommandLine::getArg(const String& id, Arg::Type type) {
auto idx = mArgs.presents(id);
ASSERT(idx && "Invalid Id")
auto& arg = mArgs.getSlotVal(idx);
ASSERT(arg->mType == type && "Invalid Type Requested")
return *arg;
}
const CommandLine::Arg& CommandLine::getArg(const String& id, Arg::Type type) const {
auto idx = mArgs.presents(id);
ASSERT(idx && "Invalid Id")
auto& arg = mArgs.getSlotVal(idx);
ASSERT(arg->mType == type && "Invalid Type Requested")
return *arg;
}
void CommandLine::ErrInvalidArgCount() { mError = { "Invalid Number Of Arguments Passed", nullptr }; }
void CommandLine::ErrInvalidArgSyntax(Arg* arg) { mError = { "Invalid Syntax Of Argument", arg }; }
void CommandLine::ErrInvalidArgType(Arg* arg) { mError = { "Invalid Type Of Argument", arg }; }
void CommandLine::ErrFileNotExists(Arg* arg) { mError = { "File Not Exists", arg }; }
void CommandLine::ErrFileCouldNotOpen(Arg* arg) { mError = { "Could Not Open File", arg }; }
void CommandLine::ErrValNotinRange(Arg* arg) { mError = { "Value Not In Range", arg }; }
void CommandLine::ErrLog() {
printf("\nERROR : Invalid Command Line\n");
if (mError.mArg) {
alni idx = 0;
for (auto arg : mArgsOrder) {
if (mError.mArg == arg.data()) break;
idx++;
}
printf("\nArgument: %lli\n", idx);
logArg(*mError.mArg);
}
printf("Error Description: %s. \n", mError.mDescr);
printf("\nExpected Arguments are: \n");
ualni idx = 0;
for (auto arg : mArgsOrder) {
printf(" -- %lli -- \n", idx);
logArg(*arg.data());
idx++;
}
printf("\nNote regex for types are:\n");
printf(" False - %s\n", regexFalse);
printf(" True - %s\n", regexTrue);
printf(" Int - %s\n", regexInt);
printf(" Float - %s\n", regexFloat);
printf(" String - %s\n", regexString);
printf(" File - else\n");
}
void CommandLine::logArg(const Arg& arg) {
switch (arg.mType) {
case Arg::INT:
{
printf("Type : Int\n");
printf("Range : %lli - %lli\n", arg.mInt.mAcceptingRange.mBegin, arg.mInt.mAcceptingRange.mEnd);
if (arg.mOptional) {
printf("Default : %lli\n", arg.mInt.mDefault);
}
printf("Value : %lli\n", arg.mInt.mVal);
}
break;
case Arg::FLOAT:
{
printf("Type : Float\n");
printf("Range : %f - %f\n", (halnf) arg.mFloat.mAcceptingRange.mBegin, (halnf) arg.mFloat.mAcceptingRange.mEnd);
if (arg.mOptional) {
printf("Default : %f\n", arg.mFloat.mDefault);
}
printf("Value : %f\n", arg.mFloat.mVal);
}
break;
case Arg::BOOL:
{
printf("Type : Bool\n");
if (arg.mOptional) {
printf("Default : %s\n", arg.mBool.mDefault ? "True" : "False");
}
printf("Value : %s\n", arg.mBool.mFlag ? "True" : "False");
}
break;
case Arg::STR:
{
printf("Type : String\n");
if (arg.mOptional) {
printf("Default : %s\n", arg.mStr.mDefault.read());
}
printf("Value : %s\n", arg.mStr.mStr.read());
}
break;
case Arg::FILE_IN:
{
printf("Type : File Input\n");
printf("Value Path : %s\n", arg.mFile.mFileLocation.getLocation().read());
}
break;
default: ASSERT(false)
}
}
void CommandLine::initDefault(Arg& arg) {
switch (arg.mType) {
case Arg::INT: arg.mInt.mVal = arg.mInt.mDefault; break;
case Arg::FLOAT: arg.mFloat.mVal = arg.mFloat.mDefault; break;
case Arg::BOOL: arg.mBool.mFlag = arg.mBool.mDefault; break;
case Arg::STR: arg.mStr.mStr = arg.mStr.mDefault; break;
default: break;
}
}
void CommandLine::parseArg(Arg& arg, const char* src) {
mTokenizer.reset();
mTokenizer.bindSource(src);
auto tok = mTokenizer.readTok();
if (tok < TokType::INT || tok > TokType::STR) {
ErrInvalidArgSyntax(&arg);
return;
}
auto val = mTokenizer.extractVal();
switch (arg.mType) {
case Arg::INT:
{
if (tok != TokType::INT) {
ErrInvalidArgType(&arg);
return;
}
auto converted = String::Logic::convertStringToValue(val.read(), arg.mInt.mVal);
if (converted && arg.mInt.mVal < arg.mInt.mAcceptingRange.mBegin || arg.mInt.mVal > arg.mInt.mAcceptingRange.mEnd) {
ErrValNotinRange(&arg);
return;
}
}
break;
case Arg::FLOAT:
{
if (tok != TokType::FLOAT) {
ErrInvalidArgType(&arg);
return;
}
auto converted = String::Logic::convertStringToValue(val.read(), arg.mFloat.mVal);
if (converted && arg.mFloat.mVal < arg.mFloat.mAcceptingRange.mBegin || arg.mFloat.mVal > arg.mFloat.mAcceptingRange.mEnd) {
ErrValNotinRange(&arg);
return;
}
}
break;
case Arg::STR:
{
if (tok != TokType::STR) {
ErrInvalidArgType(&arg);
return;
}
arg.mStr.mStr.resize(val.size() - 2);
memCopy(arg.mStr.mStr.write(), val.read() + 1, val.size() - 2);
}
break;
case Arg::BOOL:
{
if (tok != TokType::BOOL_FALSE && tok != TokType::BOOL_TRUE) {
ErrInvalidArgType(&arg);
return;
}
arg.mBool.mFlag = tok == TokType::BOOL_TRUE;
}
break;
case Arg::FILE_IN:
{
if (tok != TokType::STR) {
ErrInvalidArgType(&arg);
return;
}
arg.mFile.mFileLocation.setLocation(val);
if (!arg.mFile.mFileLocation.exists()) {
ErrFileNotExists(&arg);
return;
}
}
break;
default: ASSERT(false)
}
arg.mIsPassed = true;
}
void CommandLine::help() const {
printf("Arguments:\n");
for (auto arg : mArgsOrder) {
logArg(*arg.data());
}
}

68
CommandLine/public/CmdLineInterpreter.hpp
View file

@ -1,36 +1,34 @@
#pragma once
#include "CommandLine.hpp"
#include "Map.hpp"
namespace tp {
class CmdLineInterpreter {
public:
typedef bool (*CommandFunction)(void* customData, const CommandLine& args);
private:
struct Command {
CommandLine* args;
CommandFunction function;
void* customData = nullptr;
};
Map<String, Command> mCommands;
String mName = "InterpName";
public:
CmdLineInterpreter();
~CmdLineInterpreter();
void setName(const String& name) { mName = name; }
[[nodiscard]] const String& getName() const { return mName; }
void help(const CommandLine& args) const;
void addCommand(const String& id, CommandLine* args, CommandFunction function, void* customData = nullptr);
void run();
bool processCommand(int1* command);
};
#pragma once
#include "CommandLine.hpp"
#include "Map.hpp"
namespace tp {
class CmdLineInterpreter {
public:
typedef bool (*CommandFunction)(void* customData, const CommandLine& args);
private:
struct Command {
CommandLine* args;
CommandFunction function;
void* customData = nullptr;
};
Map<String, Command> mCommands;
String mName = "InterpName";
public:
CmdLineInterpreter();
~CmdLineInterpreter();
void setName(const String& name) { mName = name; }
[[nodiscard]] const String& getName() const { return mName; }
void help(const CommandLine& args) const;
void addCommand(const String& id, CommandLine* args, CommandFunction function, void* customData = nullptr);
void run();
bool processCommand(int1* command);
};
}

242
CommandLine/public/CommandLine.hpp
View file

@ -1,114 +1,130 @@
#pragma once
#include "Map.hpp"
#include "LocalConnection.hpp"
#include "Tokenizer.hpp"
namespace tp {
extern ModuleManifest gModuleCommandLine;
struct CommandLine {
struct IntArg {
alni mVal = 0;
alni mDefault = 0;
Range<alni> mAcceptingRange = { -(std::numeric_limits<alni>::max() - 1), std::numeric_limits<alni>::max() };
};
struct FloatArg {
alnf mVal = 0.f;
alnf mDefault = 0.f;
Range<alnf> mAcceptingRange = { -(std::numeric_limits<alnf>::max() - 1), std::numeric_limits<alnf>::max() };
};
struct BoolArg {
bool mFlag = false;
bool mDefault = false;
};
struct StringArg {
String mStr;
String mDefault;
};
struct FileInputArg {
LocalConnection::Location mFileLocation;
};
struct Arg {
String mId;
enum Type { INT, FLOAT, BOOL, STR, FILE_IN, NONE } mType = NONE;
union {
IntArg mInt;
FloatArg mFloat;
BoolArg mBool;
StringArg mStr;
FileInputArg mFile;
};
bool mOptional = true;
bool mIsPassed = false;
Arg(const Arg& arg);
Arg(const String& id, Type type);
Arg(const String& id, const Range<alni>& aAcceptingRange);
Arg(const String& id, const Range<alnf>& aAcceptingRange);
Arg(const String& id, const Range<alni>& aAcceptingRange, alni aDefault);
Arg(const String& id, const Range<alnf>& aAcceptingRange, alnf aDefault);
Arg(const String& id, bool aDefault);
Arg(const String& id, const char* aDefault);
~Arg();
};
struct Error {
const char* mDescr = nullptr;
Arg* mArg = nullptr;
operator bool() { return mDescr != nullptr; }
} mError;
CommandLine(const InitialierList<Arg>& args);
~CommandLine();
void resetError() { mError.mDescr = nullptr; }
bool parse(char argc, const char* argv[], bool logError = true, ualni skipArgs = 1);
bool parse(const char* args, bool logError = true);
void help() const;
[[nodiscard]] alni getInt(const String& id) const;
[[nodiscard]] alnf getFloat(const String& id) const;
[[nodiscard]] bool getBool(const String& id) const;
[[nodiscard]] const String& getString(const String& id) const;
[[nodiscard]] const LocalConnection::Location& getFile(const String& id) const;
const CommandLine& operator=(const CommandLine&) = delete;
private:
enum class TokType { SPACE, INT, FLOAT, BOOL_FALSE, BOOL_TRUE, STR, NONE, FAILURE, END, };
typedef SimpleTokenizer<char, TokType, TokType::NONE, TokType::FAILURE, TokType::END> Tokenizer;
Tokenizer mTokenizer;
Map<String, Arg*> mArgs;
List<Arg*> mArgsOrder;
ualni mOptionals = 0;
enum class ArgTokType { SPACE, ARG, NONE, FAILURE, END, };
SimpleTokenizer<char, ArgTokType, ArgTokType::NONE, ArgTokType::FAILURE, ArgTokType::END> mArgumentTokenizer;
Arg& getArg(const String& id, Arg::Type type);
[[nodiscard]] const Arg& getArg(const String& id, Arg::Type type) const;
void ErrInvalidArgCount();
void ErrInvalidArgSyntax(Arg* arg);
void ErrInvalidArgType(Arg* arg);
void ErrFileNotExists(Arg* arg);
void ErrFileCouldNotOpen(Arg* arg);
void ErrValNotinRange(Arg* arg);
void ErrLog();
static void logArg(const Arg& arg);
static void initDefault(Arg& arg);
void parseArg(Arg& arg, const char* src);
};
#pragma once
#include "LocalConnection.hpp"
#include "Map.hpp"
#include "Tokenizer.hpp"
namespace tp {
extern ModuleManifest gModuleCommandLine;
struct CommandLine {
struct IntArg {
alni mVal = 0;
alni mDefault = 0;
Range<alni> mAcceptingRange = { -(std::numeric_limits<alni>::max() - 1), std::numeric_limits<alni>::max() };
};
struct FloatArg {
alnf mVal = 0.f;
alnf mDefault = 0.f;
Range<alnf> mAcceptingRange = { -(std::numeric_limits<alnf>::max() - 1), std::numeric_limits<alnf>::max() };
};
struct BoolArg {
bool mFlag = false;
bool mDefault = false;
};
struct StringArg {
String mStr;
String mDefault;
};
struct FileInputArg {
LocalConnection::Location mFileLocation;
};
struct Arg {
String mId;
enum Type { INT, FLOAT, BOOL, STR, FILE_IN, NONE } mType = NONE;
union {
IntArg mInt;
FloatArg mFloat;
BoolArg mBool;
StringArg mStr;
FileInputArg mFile;
};
bool mOptional = true;
bool mIsPassed = false;
Arg(const Arg& arg);
Arg(const String& id, Type type);
Arg(const String& id, const Range<alni>& aAcceptingRange);
Arg(const String& id, const Range<alnf>& aAcceptingRange);
Arg(const String& id, const Range<alni>& aAcceptingRange, alni aDefault);
Arg(const String& id, const Range<alnf>& aAcceptingRange, alnf aDefault);
Arg(const String& id, bool aDefault);
Arg(const String& id, const char* aDefault);
~Arg();
};
struct Error {
const char* mDescr = nullptr;
Arg* mArg = nullptr;
operator bool() { return mDescr != nullptr; }
} mError;
CommandLine(const InitialierList<Arg>& args);
~CommandLine();
void resetError() { mError.mDescr = nullptr; }
bool parse(char argc, const char* argv[], bool logError = true, ualni skipArgs = 1);
bool parse(const char* args, bool logError = true);
void help() const;
[[nodiscard]] alni getInt(const String& id) const;
[[nodiscard]] alnf getFloat(const String& id) const;
[[nodiscard]] bool getBool(const String& id) const;
[[nodiscard]] const String& getString(const String& id) const;
[[nodiscard]] const LocalConnection::Location& getFile(const String& id) const;
const CommandLine& operator=(const CommandLine&) = delete;
private:
enum class TokType {
SPACE,
INT,
FLOAT,
BOOL_FALSE,
BOOL_TRUE,
STR,
NONE,
FAILURE,
END,
};
typedef SimpleTokenizer<char, TokType, TokType::NONE, TokType::FAILURE, TokType::END> Tokenizer;
Tokenizer mTokenizer;
Map<String, Arg*> mArgs;
List<Arg*> mArgsOrder;
ualni mOptionals = 0;
enum class ArgTokType {
SPACE,
ARG,
NONE,
FAILURE,
END,
};
SimpleTokenizer<char, ArgTokType, ArgTokType::NONE, ArgTokType::FAILURE, ArgTokType::END> mArgumentTokenizer;
Arg& getArg(const String& id, Arg::Type type);
[[nodiscard]] const Arg& getArg(const String& id, Arg::Type type) const;
void ErrInvalidArgCount();
void ErrInvalidArgSyntax(Arg* arg);
void ErrInvalidArgType(Arg* arg);
void ErrFileNotExists(Arg* arg);
void ErrFileCouldNotOpen(Arg* arg);
void ErrValNotinRange(Arg* arg);
void ErrLog();
static void logArg(const Arg& arg);
static void initDefault(Arg& arg);
void parseArg(Arg& arg, const char* src);
};
}

12
CommandLine/tests/TestCommandLine.cpp
View file

@ -6,10 +6,10 @@ using namespace tp;
static CommandLine createCmdLine() {
CommandLine cmd({
{ "bool", CommandLine::Arg::BOOL },
{ "int", CommandLine::Arg::INT },
{ "string", CommandLine::Arg::STR },
{ "float", CommandLine::Arg::FLOAT },
{ "bool", CommandLine::Arg::BOOL },
{ "int", CommandLine::Arg::INT },
{ "string", CommandLine::Arg::STR },
{ "float", CommandLine::Arg::FLOAT },
});
return cmd;
}
@ -20,6 +20,4 @@ TEST_DEF_STATIC(Simple) {
cmd.parse(4, args, true, 0);
}
TEST_DEF(CommandLine) {
testSimple();
}
TEST_DEF(CommandLine) { testSimple(); }

5
CommandLine/tests/TestInterpreter.cpp
View file

@ -1,7 +1,7 @@
#include "NewPlacement.hpp"
#include "Tests.hpp"
#include "CmdLineInterpreter.hpp"
#include "Tests.hpp"
using namespace tp;
@ -14,7 +14,6 @@ TEST_DEF_STATIC(Simple) {
printf("Test Val - %i\n", (int) args.getBool("bool"));
return false;
}
};
TestStruct self;
@ -32,5 +31,5 @@ TEST_DEF_STATIC(Simple) {
}
TEST_DEF(Interpreter) {
//testSimple();
// testSimple();
}

36
CommandLine/tests/Tests.cpp
View file

@ -1,18 +1,18 @@
#include "NewPlacement.hpp"
#include "Tests.hpp"
int main() {
tp::ModuleManifest* deps[] = { &tp::gModuleUtils, &tp::gModuleTokenizer, nullptr };
tp::ModuleManifest testModule("CommandLineTest", nullptr, nullptr, deps);
if (!testModule.initialize()) {
return 1;
}
// testCommandLine();
testInterpreter();
testModule.deinitialize();
}
#include "NewPlacement.hpp"
#include "Tests.hpp"
int main() {
tp::ModuleManifest* deps[] = { &tp::gModuleUtils, &tp::gModuleTokenizer, nullptr };
tp::ModuleManifest testModule("CommandLineTest", nullptr, nullptr, deps);
if (!testModule.initialize()) {
return 1;
}
// testCommandLine();
testInterpreter();
testModule.deinitialize();
}

2
CommandLine/tests/Tests.hpp
View file

@ -1,8 +1,8 @@
#pragma once
#include "Testing.hpp"
#include "Allocators.hpp"
#include "CommandLine.hpp"
#include "Testing.hpp"
void testCommandLine();
void testInterpreter();