static void TestTypeArgHandler
(
const char* arg
)
{
TestType = arg;
if (strcmp(arg, "TestWaitingList") == 0)
{
// do nothing
}
else if ((strcmp(arg, "1toN-1Threads") == 0) ||
(strcmp(arg, "Sem1toN-1Threads") == 0))
{
le_arg_AddPositionalCallback(DelInvArgHandler);
le_arg_AddPositionalCallback(NumThreadArgHandler);
}
else if ((strcmp(arg, "Sem1stThread") == 0) ||
(strcmp(arg, "SemMidThread") == 0) ||
(strcmp(arg, "1stThread") == 0) ||
(strcmp(arg, "MidThread") == 0) ||
(strcmp(arg, "None") == 0))
{
le_arg_AddPositionalCallback(NumThreadArgHandler);
}
else
{
PrintHelp();
}
}
static void TestTypeArgHandler
(
const char* arg
)
{
TestType = arg;
if ((strcmp(arg, "TestWaitingList") == 0) ||
(strcmp(arg, "TestRecursive") == 0) ||
(strcmp(arg, "TestTraceableRecursive") == 0))
{
// do nothing
}
else if ((strcmp(arg, "1toN-1") == 0) ||
(strcmp(arg, "AllMutexes1stThread") == 0) ||
(strcmp(arg, "AllMutexesMidThread") == 0) ||
(strcmp(arg, "1stThread") == 0) ||
(strcmp(arg, "MidThread") == 0) ||
(strcmp(arg, "None") == 0))
{
le_arg_AddPositionalCallback(DelInvArgHandler);
le_arg_AddPositionalCallback(NumMutexArgHandler);
le_arg_AddPositionalCallback(NumThreadArgHandler);
}
else
{
PrintHelp();
}
}
//--------------------------------------------------------------------------------------------------
static void CommandArgHandler
(
const char* command
)
{
if (strcmp(command, "help") == 0)
{
PrintHelpAndExit();
}
else if (strcmp(command, "level") == 0)
{
Command = LOG_CMD_SET_LEVEL;
// Expect a log level next.
le_arg_AddPositionalCallback(LogLevelArgHandler);
}
else if (strcmp(command, "trace") == 0)
{
Command = LOG_CMD_ENABLE_TRACE;
// Expect a trace keyword next.
le_arg_AddPositionalCallback(TraceKeywordArgHandler);
}
else if (strcmp(command, "stoptrace") == 0)
{
Command = LOG_CMD_DISABLE_TRACE;
// Expect a trace keyword next.
le_arg_AddPositionalCallback(TraceKeywordArgHandler);
}
else if (strcmp(command, "list") == 0)
{
Command = LOG_CMD_LIST_COMPONENTS;
// This command has no parameters and no destination.
}
else if (strcmp(command, "forget") == 0)
{
Command = LOG_CMD_FORGET_PROCESS;
// This command has only a process name (or pid) as a parameter.
le_arg_AddPositionalCallback(ProcessIdArgHandler);
}
else
{
char errorMsg[100];
snprintf(errorMsg, sizeof(errorMsg), "Invalid log command (%s)", command);
ExitWithErrorMsg(errorMsg);
}
}
//--------------------------------------------------------------------------------------------------
static void TraceKeywordArgHandler
(
const char* keyword
)
{
CommandParamPtr = keyword;
// Wait for an optional log session identifier next.
le_arg_AddPositionalCallback(SessionIdArgHandler);
le_arg_AllowLessPositionalArgsThanCallbacks();
}
//--------------------------------------------------------------------------------------------------
static void NodeValueArgHandler
(
const char* nodeValue
)
//--------------------------------------------------------------------------------------------------
{
NodeValue = nodeValue;
// Could optionally have a node type argument after the node value.
le_arg_AddPositionalCallback(DataTypeArgHandler);
le_arg_AllowLessPositionalArgsThanCallbacks();
}
//--------------------------------------------------------------------------------------------------
static void LogLevelArgHandler
(
const char* logLevel
)
{
// Check that string is one of the level strings.
le_log_Level_t level = ParseSeverityLevel(logLevel);
if (level == (le_log_Level_t)(-1))
{
ExitWithErrorMsg("Invalid log level.");
}
const char* levelStr = log_SeverityLevelToStr(level);
LE_ASSERT(levelStr != NULL);
CommandParamPtr = levelStr;
// Wait for an optional log session identifier next.
le_arg_AddPositionalCallback(SessionIdArgHandler);
le_arg_AllowLessPositionalArgsThanCallbacks();
}
//--------------------------------------------------------------------------------------------------
static void SetCommandHandler
(
const char* argPtr ///< [IN] Command-line argument.
)
{
if (strcmp(argPtr, "ls") == 0)
{
CommandHandler = ListEntries;
le_arg_AddPositionalCallback(SetPath);
le_arg_SetFlagVar(&ListSizeFlag, "s", NULL);
le_arg_AllowLessPositionalArgsThanCallbacks();
}
else if (strcmp(argPtr, "read") == 0)
{
CommandHandler = PrintEntry;
le_arg_AddPositionalCallback(SetPath);
}
else if (strcmp(argPtr, "write") == 0)
{
CommandHandler = WriteEntry;
le_arg_AddPositionalCallback(SetInputFile);
le_arg_AddPositionalCallback(SetPath);
}
else if (strcmp(argPtr, "rm") == 0)
{
CommandHandler = DeletePath;
le_arg_AddPositionalCallback(SetPath);
}
else if (strcmp(argPtr, "size") == 0)
{
CommandHandler = PrintSize;
le_arg_AddPositionalCallback(SetPath);
le_arg_AllowLessPositionalArgsThanCallbacks();
}
else if (strcmp(argPtr, "total") == 0)
{
CommandHandler = PrintTotalSizes;
}
else if (strcmp(argPtr, "readmeta") == 0)
{
CommandHandler = ReadMeta;
}
else
{
fprintf(stderr, "Unknown command.\n");
exit(EXIT_FAILURE);
}
}
//--------------------------------------------------------------------------------------------------
static void SessionIdArgHandler
(
const char* sessionId
)
{
// Check that the session identifier is formatted correctly.
if (strchr(sessionId, '/') == NULL)
{
// Permit an optional "in" here, once.
if (strcmp(sessionId, "in") == 0)
{
static bool optionalInSeen = false;
if (!optionalInSeen)
{
optionalInSeen = true;
le_arg_AddPositionalCallback(SessionIdArgHandler);
}
}
ExitWithErrorMsg("Invalid destination.");
}
SessionIdPtr = sessionId;
}
//--------------------------------------------------------------------------------------------------
static void CommandArgHandler
(
const char* command
)
//--------------------------------------------------------------------------------------------------
{
if (strcmp(command, "get") == 0)
{
CommandHandler = HandleGet;
// Get the node path from our command line arguments and accept an optional --format=X arg.
le_arg_AddPositionalCallback(NodePathArgHandler);
le_arg_SetStringCallback(FormatArgHandler, NULL, "format");
}
else if (strcmp(command, "set") == 0)
{
CommandHandler = HandleSet;
// Get the node path and value from our command line arguments.
le_arg_AddPositionalCallback(NodePathArgHandler);
le_arg_AddPositionalCallback(NodeValueArgHandler);
}
else if (strcmp(command, "move") == 0)
{
CommandHandler = HandleCopy;
DeleteAfterCopy = true;
le_arg_AddPositionalCallback(NodePathArgHandler);
le_arg_AddPositionalCallback(NodeDestPathArgHandler);
}
else if (strcmp(command, "copy") == 0)
{
CommandHandler = HandleCopy;
DeleteAfterCopy = false;
le_arg_AddPositionalCallback(NodePathArgHandler);
le_arg_AddPositionalCallback(NodeDestPathArgHandler);
}
else if (strcmp(command, "import") == 0)
{
CommandHandler = HandleImport;
// Expect a node path and a file path, with an optional --format= argument.
le_arg_AddPositionalCallback(NodePathArgHandler);
le_arg_AddPositionalCallback(FilePathArgHandler);
le_arg_SetStringCallback(FormatArgHandler, NULL, "format");
}
else if (strcmp(command, "export") == 0)
{
CommandHandler = HandleExport;
// Expect a node path and a file path, with an optional --format= argument.
le_arg_AddPositionalCallback(NodePathArgHandler);
le_arg_AddPositionalCallback(FilePathArgHandler);
le_arg_SetStringCallback(FormatArgHandler, NULL, "format");
}
else if (strcmp(command, "delete") == 0)
{
CommandHandler = HandleDelete;
// Need a node path from our command line arguments.
le_arg_AddPositionalCallback(NodePathArgHandler);
}
else if (strcmp(command, "clear") == 0)
{
CommandHandler = HandleClear;
// Need a node path from our command line arguments.
le_arg_AddPositionalCallback(NodePathArgHandler);
}
else if (strcmp(command, "list") == 0)
{
CommandHandler = HandleList;
// No additional command-line parameters for this command.
}
else if (strcmp(command, "rmtree") == 0)
{
CommandHandler = HandleDeleteTree;
// The only parameter is the tree name.
le_arg_AddPositionalCallback(TreeNameArgHandler);
}
else if (strcmp(command, "help") == 0)
{
PrintHelpAndExit();
}
else
{
fprintf(stderr,
"Error, unrecognized command, '%s'.\n"
"For more details please run:\n"
"\t%s help\n\n",
command,
ProgramName);
exit(EXIT_FAILURE);
}
}
