Argx.c File Reference

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include "../inc/Argx.h"
#include "../inc/types.h"

Go to the source code of this file.

Data Structures
struct	Argxc

Functions
void	argxcAddOption (Argxc *argxc, ArgxcOptions option)
	Add a new option to the Argxc instance.
void	argxcAddSubOption (ArgxcOptions *parent, ArgxcOptions subOption)
	Add a sub-option to a parent option.
bool	argxcCompareArgs (ArgxcOptions *options, size_t optionsCount, char **argv, size_t argvCount)
	Compare if the given argv matches a list of ArgxcOptions.
Argxc *	argxcCreate (const char *id, int argc, char *argv[])
	Create a new Argxc instance with a specified ID and command-line arguments.
Argxc *	argxcCreateDefault (void)
	Create a new Argxc instance with default values (empty ID and no arguments).
char *	argxcCreateDocs (Argxc *argxc, ArgxcStyle style, const char *title, const char *mainInfo)
	Generate documentation for the defined options.
ArgxcError	argxcCreateError (const char *type, const char *error, const char *help, int code)
	Create an ArgxcError object.
ArgxcOptions	argxcCreateOption (const char *id, const char *param, const char *sparam, const char *info, bool hasSubParams, bool hasAnySubParams)
	Create a new option.
void	argxcDestroy (Argxc *argxc)
	Destroy an Argxc instance and free all associated memory.
int	argxcFindParam (Argxc *argxc, const char *id)
	Find the index of a parameter by ID.
void	argxcFreeError (ArgxcError *error)
	Free resources associated with an ArgxcError struct.
void	argxcFreeOption (ArgxcOptions *option)
	Free resources associated with an ArgxcOptions struct.
void	argxcFreeParam (ArgxcParam *param)
	Free resources associated with an ArgxcParam struct.
void	argxcFreeStringArray (char **array, size_t count)
	Free a string array returned from Argxc (e.g., argv array).
int	argxcGetArgc (Argxc *argxc)
	Get the number of command-line arguments passed.
const char *	argxcGetId (Argxc *argxc)
	Get the identifier of the Argxc instance.
char **	argxcGetMainArgs (Argxc *argxc, size_t *count)
	Get the raw command-line arguments passed to Argxc.
ArgxcOptions *	argxcGetOptions (Argxc *argxc, size_t *count)
	Get all top-level options defined for the Argxc instance.
ArgxcParam	argxcGetParam (Argxc *argxc, const char *id)
	Retrieve a parameter by ID.
bool	argxcGetSubParam (Argxc *argxc, const ArgxcParam *param, const char *id)
	Retrieve a sub-parameter from a given parameter by ID.
bool	argxcParamExists (Argxc *argxc, const char *id)
	Check if a parameter with the given ID exists.
static void	freeOptionsArray (ArgxcOptions *options, size_t count)
static void	freeStringArray (char **array, size_t count)
static char *	stringDuplicate (const char *str)

Function Documentation

argxcAddOption()

void argxcAddOption	(	Argxc *	argxc,
		ArgxcOptions	option )

Add a new option to the Argxc instance.

Parameters

argxc	Pointer to the Argxc instance.
option	The option to add.

Definition at line 124 of file Argx.c.

{
    if (!argxc) return;
 
    if (argxc->optionsCount >= argxc->optionsCapacity)
    {
        argxc->optionsCapacity *= 2;
        argxc->options = realloc(argxc->options, argxc->optionsCapacity * sizeof(ArgxcOptions));
        if (!argxc->options) return;
    }
 
    argxc->options[argxc->optionsCount++] = option;
}

References Argxc::options, Argxc::optionsCapacity, and Argxc::optionsCount.

argxcAddSubOption()

void argxcAddSubOption	(	ArgxcOptions *	parent,
		ArgxcOptions	subOption )

Add a sub-option to a parent option.

Parameters

parent	Pointer to the parent option.
subOption	Sub-option to add under the parent.

Definition at line 138 of file Argx.c.

{
    if (!parent) return;
 
    if (parent->subParamsCount >= parent->subParamsCapacity)
    {
        size_t newCapacity = parent->subParamsCapacity == 0 ? 2 : parent->subParamsCapacity * 2;
        ArgxcOptions *newSubParams = realloc(parent->subParams, newCapacity * sizeof(ArgxcOptions));
        if (!newSubParams) return;
 
        parent->subParams = newSubParams;
        parent->subParamsCapacity = newCapacity;
    }
 
    parent->subParams[parent->subParamsCount++] = subOption;
}

References ArgxcOptions::subParams, ArgxcOptions::subParamsCapacity, and ArgxcOptions::subParamsCount.

argxcCompareArgs()

bool argxcCompareArgs	(	ArgxcOptions *	options,
		size_t	optionsCount,
		char **	argv,
		size_t	argvCount )

Compare if the given argv matches a list of ArgxcOptions.

Parameters

options	Array of ArgxcOptions.
optionsCount	Number of options.
argv	Array of argument strings.
argvCount	Number of argument strings.

Returns

true if argv matches the options, false otherwise.

Definition at line 499 of file Argx.c.

{
    if (!options || !argv) return false;
 
    for (size_t i = 1; i < argvCount; i++)
    {
        const char *arg = argv[i];
 
        bool found = false;
        bool hasSubParams = false;
        bool hasAnySubParams = false;
        ArgxcOptions *matchedOption = NULL;
 
        // Find the matching option
        for (size_t j = 0; j < optionsCount; j++)
        {
            if ((options[j].sparam && strcmp(options[j].sparam, arg) == 0) ||
                    (options[j].param && strcmp(options[j].param, arg) == 0))
            {
                found = true;
                hasSubParams = options[j].hasSubParams;
                hasAnySubParams = options[j].hasAnySubParams;
                matchedOption = &options[j];
                break;
            }
        }
 
        if (!found) return false;
 
        if (hasSubParams || hasAnySubParams)
        {
            // Check if there's a next argument
            if (i + 1 < argvCount)
            {
                const char *nextArg = argv[i + 1];
 
                // Check if next argument is a sub-parameter
                bool isSubParam = false;
 
                if (nextArg && strlen(nextArg) > 0 && nextArg[0] != '-')
                {
                    // Validate if it's a valid sub-parameter
                    for (size_t k = 0; k < matchedOption->subParamsCount; k++)
                    {
                        if ((matchedOption->subParams[k].param && strcmp(matchedOption->subParams[k].param, nextArg) == 0) ||
                                (matchedOption->subParams[k].sparam && strcmp(matchedOption->subParams[k].sparam, nextArg) == 0))
                        {
                            isSubParam = true;
                            break;
                        }
                    }
 
                    if (isSubParam)
                    {
                        i++; // Skip the sub-parameter
                    } else if (hasSubParams || hasAnySubParams)
                    {
                        return false;
                    }
                } else if (hasSubParams || hasAnySubParams)
                {
                    return false;
                }
            }
        }
    }
 
    return true;
}

References ArgxcOptions::hasAnySubParams, ArgxcOptions::hasSubParams, ArgxcOptions::param, ArgxcOptions::sparam, ArgxcOptions::subParams, and ArgxcOptions::subParamsCount.

argxcCreate()

Argxc * argxcCreate	(	const char *	id,
		int	argc,
		char *	argv[] )

Create a new Argxc instance with a specified ID and command-line arguments.

Parameters

id	Identifier for the parser instance.
argc	Number of command-line arguments.
argv	Array of command-line argument strings.

Returns

Argxc* Pointer to the created Argxc instance.

Definition at line 64 of file Argx.c.

{
    Argxc *argxc = malloc(sizeof(Argxc));
    if (!argxc) return NULL;
 
    argxc->id = stringDuplicate(id);
    argxc->mainArgc = argc;
    argxc->mainArgsCount = argc;
    argxc->mainArgs = malloc(argc * sizeof(char*));
    argxc->optionsCount = 0;
    argxc->optionsCapacity = 10;
    argxc->options = malloc(argxc->optionsCapacity * sizeof(ArgxcOptions));
 
    if (!argxc->mainArgs || !argxc->options)
    {
        argxcDestroy(argxc);
        return NULL;
    }
 
    for (int i = 0; i < argc; i++)
    {
        argxc->mainArgs[i] = stringDuplicate(argv[i]);
    }
 
    return argxc;
}

References argxcDestroy(), Argxc::id, Argxc::mainArgc, Argxc::mainArgs, Argxc::mainArgsCount, Argxc::options, Argxc::optionsCapacity, Argxc::optionsCount, and stringDuplicate().

argxcCreateDefault()

Argxc * argxcCreateDefault

(

void

)

Create a new Argxc instance with default values (empty ID and no arguments).

Returns

Argxc* Pointer to the default Argxc instance.

Definition at line 91 of file Argx.c.

{
    Argxc *argxc = malloc(sizeof(Argxc));
    if (!argxc) return NULL;
 
    argxc->id = NULL;
    argxc->mainArgs = NULL;
    argxc->mainArgsCount = 0;
    argxc->mainArgc = 0;
    argxc->optionsCount = 0;
    argxc->optionsCapacity = 10;
    argxc->options = malloc(argxc->optionsCapacity * sizeof(ArgxcOptions));
 
    if (!argxc->options)
    {
        free(argxc); argxc = NULL;
        return NULL;
    }
 
    return argxc;
}

References Argxc::id, Argxc::mainArgc, Argxc::mainArgs, Argxc::mainArgsCount, Argxc::options, Argxc::optionsCapacity, and Argxc::optionsCount.

argxcCreateDocs()

char * argxcCreateDocs	(	Argxc *	argxc,
		ArgxcStyle	style,
		const char *	title,
		const char *	mainInfo )

Generate documentation for the defined options.

Parameters

argxc	Pointer to the Argxc instance.
style	Documentation output style.
title	Title of the documentation.
mainInfo	Additional info to be displayed in the documentation.

Returns

char* Documentation string (must be freed by caller).

Definition at line 375 of file Argx.c.

{
    if (!argxc) return NULL;
 
    size_t bufferSize = 4096;
    char *contentStr = malloc(bufferSize);
    if (!contentStr) return NULL;
 
    contentStr[0] = '\0';
 
    if (style == ARGX_STYLE_PROFESSIONAL)
    {
        for (size_t i = 0; i < argxc->optionsCount; i++)
        {
            ArgxcOptions *opt = &argxc->options[i];
 
            // Main option header line
            char temp[512];
            snprintf(temp, sizeof(temp), "ID: %s\n", opt->id ? opt->id : "");
            strcat(contentStr, temp);
 
            snprintf(temp, sizeof(temp), "[ %s | %s", 
                    opt->sparam ? opt->sparam : "", 
                    opt->param ? opt->param : "");
            strcat(contentStr, temp);
 
            if (opt->hasSubParams && opt->subParamsCount > 0)
            {
                strcat(contentStr, " [ ");
 
                for (size_t j = 0; j < opt->subParamsCount; j++)
                {
                    strcat(contentStr, opt->subParams[j].param ? opt->subParams[j].param : "");
 
                    if (j < opt->subParamsCount - 1)
                    {
                        strcat(contentStr, " | ");
                    } else if (j <= opt->subParamsCount)
                    {
                        strcat(contentStr, " ");
                    }
                }
 
                strcat(contentStr, "] ] ");
            } else {
                strcat(contentStr, " ] ");
            }
 
            strcat(contentStr, opt->info ? opt->info : "");
            strcat(contentStr, "\n");
 
            // Print all sub-options
            if (opt->hasSubParams && opt->subParamsCount > 0)
            {
                for (size_t j = 0; j < opt->subParamsCount; j++)
                {
                    ArgxcOptions *sub = &opt->subParams[j];
 
                    // Create spacing for alignment
                    size_t paramLen = opt->param ? strlen(opt->param) : 0;
                    for (size_t k = 0; k < paramLen; k++)
                    {
                        strcat(contentStr, " ");
                    }
 
                    snprintf(temp, sizeof(temp), "  [ %s | %s ] %s\n",
                            sub->sparam ? sub->sparam : "",
                            sub->param ? sub->param : "",
                            sub->info ? sub->info : "");
                    strcat(contentStr, temp);
                }
            }
        }
    } else if (style == ARGX_STYLE_SIMPLE)
    {
        for (size_t i = 0; i < argxc->optionsCount; i++)
        {
            ArgxcOptions *opt = &argxc->options[i];
 
            char temp[256];
            snprintf(temp, sizeof(temp), "%s, %s - %s\n",
                    opt->sparam ? opt->sparam : "",
                    opt->param ? opt->param : "",
                    opt->info ? opt->info : "");
            strcat(contentStr, temp);
 
            if (opt->hasSubParams && opt->subParamsCount > 0)
            {
                for (size_t j = 0; j < opt->subParamsCount; j++)
                {
                    ArgxcOptions *sub = &opt->subParams[j];
 
                    snprintf(temp, sizeof(temp), "  %s, %s - %s\n",
                            sub->sparam ? sub->sparam : "",
                            sub->param ? sub->param : "",
                            sub->info ? sub->info : "");
                    strcat(contentStr, temp);
                }
            }
        }
    }
 
    // Combine title, mainInfo, and content
    size_t titleLen = title ? strlen(title) : 0;
    size_t mainInfoLen = mainInfo ? strlen(mainInfo) : 0;
    size_t contentLen = strlen(contentStr);
    size_t totalLen = titleLen + mainInfoLen + contentLen + 10; // Extra space for newlines
 
    char *result = malloc(totalLen);
    if (!result)
    {
        free(contentStr); contentStr = NULL;
        return NULL;
    }
 
    snprintf(result, totalLen, "%s\n%s\n%s",
            title ? title : "",
            mainInfo ? mainInfo : "",
            contentStr);
 
    free(contentStr); contentStr = NULL;
    return result;
}

References ARGX_STYLE_PROFESSIONAL, ARGX_STYLE_SIMPLE, ArgxcOptions::hasSubParams, ArgxcOptions::id, ArgxcOptions::info, Argxc::options, Argxc::optionsCount, ArgxcOptions::param, ArgxcOptions::sparam, ArgxcOptions::subParams, and ArgxcOptions::subParamsCount.

argxcCreateError()

ArgxcError argxcCreateError	(	const char *	type,
		const char *	error,
		const char *	help,
		int	code )

Create an ArgxcError object.

Parameters

type	Type/category of the error.
error	Error message.
help	Help message for resolving the error.
code	Exit code or error code.

Returns

ArgxcError The created error struct.

Definition at line 667 of file Argx.c.

{
    ArgxcError err = {0};
 
    err.type = stringDuplicate(type);
    err.error = stringDuplicate(error);
    err.help = stringDuplicate(help);
    err.code = code;
 
    return err;
}

References ArgxcError::code, ArgxcError::error, ArgxcError::help, stringDuplicate(), and ArgxcError::type.

argxcCreateOption()

ArgxcOptions argxcCreateOption	(	const char *	id,
		const char *	param,
		const char *	sparam,
		const char *	info,
		bool	hasSubParams,
		bool	hasAnySubParams )

Create a new option.

Parameters

id	Option identifier.
param	Parameter name (e.g., –param).
sparam	Short form (e.g., -p).
info	Description of the option.
hasSubParams	Whether the option has sub-parameters.
hasAnySubParams	Whether the option accepts any sub-parameters.

Returns

ArgxcOptions The created option.

Definition at line 607 of file Argx.c.

{
    ArgxcOptions option = {0};
 
    option.id = stringDuplicate(id);
    option.param = stringDuplicate(param);
    option.sparam = stringDuplicate(sparam);
    option.info = stringDuplicate(info);
    option.hasSubParams = hasSubParams;
    option.hasAnySubParams = hasAnySubParams;
    option.subParams = NULL;
    option.subParamsCount = 0;
 
    return option;
}

References ArgxcOptions::hasAnySubParams, ArgxcOptions::hasSubParams, ArgxcOptions::id, ArgxcOptions::info, ArgxcOptions::param, ArgxcOptions::sparam, stringDuplicate(), ArgxcOptions::subParams, and ArgxcOptions::subParamsCount.

argxcDestroy()

void argxcDestroy

(

Argxc *

argxc

)

Destroy an Argxc instance and free all associated memory.

Parameters

argxc

Pointer to the Argxc instance to destroy.

Definition at line 113 of file Argx.c.

{
    if (!argxc) return;
 
    free(argxc->id); argxc->id = NULL;
    if (argxc->mainArgs) freeStringArray(argxc->mainArgs, argxc->mainArgsCount);
    if (argxc->options) freeOptionsArray(argxc->options, argxc->optionsCount);
    free(argxc); argxc = NULL;
}

References freeOptionsArray(), freeStringArray(), Argxc::id, Argxc::mainArgs, Argxc::mainArgsCount, Argxc::options, and Argxc::optionsCount.

Referenced by argxcCreate().

argxcFindParam()

int argxcFindParam	(	Argxc *	argxc,
		const char *	id )

Find the index of a parameter by ID.

Parameters

argxc	Pointer to the Argxc instance.
id	The identifier of the parameter to find.

Returns

int Index of the parameter, or -1 if not found.

Definition at line 155 of file Argx.c.

{
    if (!argxc || !id) return -1;
 
    // First check if it's a main parameter
    for (size_t i = 0; i < argxc->optionsCount; i++)
    {
        if (argxc->options[i].id && strcmp(argxc->options[i].id, id) == 0)
        {
            // Check if this main parameter exists in arguments
            for (size_t j = 0; j < argxc->mainArgsCount; j++)
            {
                if ((argxc->options[i].param && strcmp(argxc->mainArgs[j], argxc->options[i].param) == 0) ||
                        (argxc->options[i].sparam && strcmp(argxc->mainArgs[j], argxc->options[i].sparam) == 0))
                {
                    return (int)i;
                }
            }
        }
    }
 
    // Then look for sub-parameters
    for (size_t i = 0; i < argxc->optionsCount; i++)
    {
        ArgxcOptions *opt = &argxc->options[i];
 
        // Check if the parent option exists in the arguments
        bool parentExists = false;
        for (size_t j = 0; j < argxc->mainArgsCount; j++)
        {
            if ((opt->param && strcmp(argxc->mainArgs[j], opt->param) == 0) ||
                    (opt->sparam && strcmp(argxc->mainArgs[j], opt->sparam) == 0))
            {
                parentExists = true;
                break;
            }
        }
 
        if (parentExists)
        {
            // Find the index of the requested sub-parameter
            for (size_t j = 0; j < opt->subParamsCount; j++)
            {
                if (opt->subParams[j].id && strcmp(opt->subParams[j].id, id) == 0)
                {
                    return (int)j;
                }
            }
        }
    }
 
    return -1; // Not found
}

References ArgxcOptions::id, Argxc::mainArgs, Argxc::mainArgsCount, Argxc::options, Argxc::optionsCount, ArgxcOptions::param, ArgxcOptions::sparam, ArgxcOptions::subParams, and ArgxcOptions::subParamsCount.

Referenced by argxcGetSubParam(), and argxcParamExists().

argxcFreeError()

void argxcFreeError

(

ArgxcError *

error

)

Free resources associated with an ArgxcError struct.

Parameters

error

Pointer to the error to free.

Definition at line 679 of file Argx.c.

{
    if (!error) return;
 
    free(error->type); error->type = NULL;
    free(error->error); error->error = NULL;
    free(error->help); error->help = NULL;
    memset(error, 0, sizeof(ArgxcError));
}

References ArgxcError::error, ArgxcError::help, and ArgxcError::type.

argxcFreeOption()

void argxcFreeOption

(

ArgxcOptions *

option

)

Free resources associated with an ArgxcOptions struct.

Parameters

option

Pointer to the option to free.

Definition at line 624 of file Argx.c.

{
    if (!option) return;
 
    if (option->id)
    { free(option->id); option->id = NULL; }
    if (option->param)
    { free(option->param); option->param = NULL; }
    if (option->sparam)
    { free(option->sparam); option->sparam = NULL; }
    if (option->info)
    { free(option->info); option->info = NULL; }
 
    if (option->subParams)
    {
        for (size_t i = 0; i < option->subParamsCount; i++)
        {
            argxcFreeOption(&option->subParams[i]);
        }
 
        free(option->subParams); 
        option->subParams = NULL;
        option->subParamsCapacity = 0;
        option->subParamsCount = 0;
    }
 
    memset(option, 0, sizeof(ArgxcOptions));
}

References argxcFreeOption(), ArgxcOptions::id, ArgxcOptions::info, ArgxcOptions::param, ArgxcOptions::sparam, ArgxcOptions::subParams, ArgxcOptions::subParamsCapacity, and ArgxcOptions::subParamsCount.

Referenced by argxcFreeOption(), and freeOptionsArray().

argxcFreeParam()

void argxcFreeParam

(

ArgxcParam *

param

)

Free resources associated with an ArgxcParam struct.

Parameters

param

Pointer to the parameter to free.

Definition at line 653 of file Argx.c.

{
    if (!param) return;
 
    free(param->subExists); param->subExists = NULL;
    memset(param, 0, sizeof(ArgxcParam));
}

References ArgxcParam::subExists.

argxcFreeStringArray()

void argxcFreeStringArray	(	char **	array,
		size_t	count )

Free a string array returned from Argxc (e.g., argv array).

Parameters

array	The array to free.
count	Number of elements in the array.

Definition at line 661 of file Argx.c.

{
    freeStringArray(array, count);
}

References freeStringArray().

argxcGetArgc()

int argxcGetArgc

(

Argxc *

argxc

)

Get the number of command-line arguments passed.

Parameters

argxc

Pointer to the Argxc instance.

Returns

int Number of arguments.

Definition at line 588 of file Argx.c.

{
    return argxc ? argxc->mainArgc : 0;
}

References Argxc::mainArgc.

argxcGetId()

const char * argxcGetId

(

Argxc *

argxc

)

Get the identifier of the Argxc instance.

Parameters

argxc

Pointer to the Argxc instance.

Returns

const char* The ID string.

Definition at line 601 of file Argx.c.

{
    return argxc ? argxc->id : NULL;
}

References Argxc::id.

argxcGetMainArgs()

char ** argxcGetMainArgs	(	Argxc *	argxc,
		size_t *	count )

Get the raw command-line arguments passed to Argxc.

Parameters

argxc	Pointer to the Argxc instance.
count	Output: number of arguments returned.

Returns

char** Array of argument strings.

Definition at line 570 of file Argx.c.

{
    if (!argxc || !count) return NULL;
 
    *count = argxc->mainArgsCount;
 
    // Create a copy of the array
    char **copy = malloc(argxc->mainArgsCount * sizeof(char*));
    if (!copy) return NULL;
 
    for (size_t i = 0; i < argxc->mainArgsCount; i++)
    {
        copy[i] = stringDuplicate(argxc->mainArgs[i]);
    }
 
    return copy;
}

References Argxc::mainArgs, Argxc::mainArgsCount, and stringDuplicate().

argxcGetOptions()

ArgxcOptions * argxcGetOptions	(	Argxc *	argxc,
		size_t *	count )

Get all top-level options defined for the Argxc instance.

Parameters

argxc	Pointer to the Argxc instance.
count	Output: number of options returned.

Returns

ArgxcOptions* Array of options.

Definition at line 593 of file Argx.c.

{
    if (!argxc || !count) return NULL;
 
    *count = argxc->optionsCount;
    return argxc->options; // Return direct reference (be careful with modification)
}

References Argxc::options, and Argxc::optionsCount.

argxcGetParam()

ArgxcParam argxcGetParam	(	Argxc *	argxc,
		const char *	id )

Retrieve a parameter by ID.

Parameters

argxc	Pointer to the Argxc instance.
id	The identifier of the parameter to retrieve.

Returns

ArgxcParam The parameter object.

Definition at line 214 of file Argx.c.

{
    ArgxcParam result = {false, NULL, 0};
 
    if (!argxc || !id || argxc->mainArgc <= 1)
    {
        return result;
    }
 
    // First, check if this is a top-level option
    for (size_t i = 0; i < argxc->optionsCount; i++)
    {
        ArgxcOptions *opt = &argxc->options[i];
 
        if (opt->id && strcmp(opt->id, id) == 0)
        {
            // Find the position of the main option in arguments
            int mainOptionPos = -1;
 
            for (size_t j = 0; j < argxc->mainArgsCount; j++)
            {
                if ((opt->param && strcmp(argxc->mainArgs[j], opt->param) == 0) ||
                        (opt->sparam && strcmp(argxc->mainArgs[j], opt->sparam) == 0))
                {
                    result.exists = true;
                    mainOptionPos = j;
                    break;
                }
            }
 
            if (result.exists)
            {
                if (opt->hasSubParams || opt->hasAnySubParams)
                {
                    // Allocate memory for sub-parameter existence array
                    result.subExistsCount = opt->subParamsCount;
                    result.subExists = malloc(result.subExistsCount * sizeof(bool));
 
                    if (result.subExists)
                    {
                        // Check each sub-parameter
                        for (size_t j = 0; j < opt->subParamsCount; j++)
                        {
                            bool subMatched = false;
                            ArgxcOptions *sub = &opt->subParams[j];
 
                            // Look for sub-parameters after the main option
                            for (size_t k = mainOptionPos + 1; k < argxc->mainArgsCount; k++)
                            {
                                if ((sub->param && strcmp(argxc->mainArgs[k], sub->param) == 0) ||
                                        (sub->sparam && strcmp(argxc->mainArgs[k], sub->sparam) == 0))
                                {
                                    subMatched = true;
                                    break;
                                }
                            }
 
                            result.subExists[j] = subMatched;
                        }
                    }
                }
 
                return result;
            }
        }
    }
 
    // If not found as top-level, check if it's a sub-parameter
    for (size_t i = 0; i < argxc->optionsCount; i++)
    {
        ArgxcOptions *opt = &argxc->options[i];
 
        // Find if the parent option exists and get its position
        int parentPos = -1;
 
        for (size_t j = 0; j < argxc->mainArgsCount; j++)
        {
            if ((opt->param && strcmp(argxc->mainArgs[j], opt->param) == 0) ||
                    (opt->sparam && strcmp(argxc->mainArgs[j], opt->sparam) == 0))
            {
                parentPos = j;
                break;
            }
        }
 
        if (parentPos >= 0 && (opt->hasSubParams || opt->hasAnySubParams))
        {
            // Check if the requested sub-parameter exists after the parent
            for (size_t j = 0; j < opt->subParamsCount; j++)
            {
                ArgxcOptions *sub = &opt->subParams[j];
 
                if (sub->id && strcmp(sub->id, id) == 0)
                {
                    for (size_t k = parentPos + 1; k < argxc->mainArgsCount; k++)
                    {
                        if ((sub->param && strcmp(argxc->mainArgs[k], sub->param) == 0) ||
                                (sub->sparam && strcmp(argxc->mainArgs[k], sub->sparam) == 0))
                        {
                            result.exists = true;
                            break;
                        }
                    }
 
                    if (!result.exists && (size_t)(parentPos + 1) < argxc->mainArgsCount)
                    {
                        char *nextArg = argxc->mainArgs[parentPos + 1];
 
                        if ((sub->param && strcmp(nextArg, sub->param) == 0) ||
                                (sub->sparam && strcmp(nextArg, sub->sparam) == 0))
                        {
                            result.exists = true;
                        }
                    }
 
                    // Handle any sub-sub-parameters if they exist
                    if (result.exists && (sub->hasSubParams || sub->hasAnySubParams))
                    {
                        result.subExistsCount = sub->subParamsCount;
                        result.subExists = malloc(result.subExistsCount * sizeof(bool));
 
                        if (result.subExists)
                        {
                            for (size_t k = 0; k < sub->subParamsCount; k++)
                            {
                                bool subsubMatched = false;
                                ArgxcOptions *subsub = &sub->subParams[k];
 
                                for (size_t l = 0; l < argxc->mainArgsCount; l++)
                                {
                                    if ((subsub->param && strcmp(argxc->mainArgs[l], subsub->param) == 0) ||
                                            (subsub->sparam && strcmp(argxc->mainArgs[l], subsub->sparam) == 0))
                                    {
                                        subsubMatched = true;
                                        break;
                                    }
                                }
 
                                result.subExists[k] = subsubMatched;
                            }
                        }
                    }
 
                    return result;
                }
            }
        }
    }
 
    return result;
}

References ArgxcParam::exists, ArgxcOptions::hasAnySubParams, ArgxcOptions::hasSubParams, ArgxcOptions::id, Argxc::mainArgc, Argxc::mainArgs, Argxc::mainArgsCount, Argxc::options, Argxc::optionsCount, ArgxcOptions::param, ArgxcOptions::sparam, ArgxcParam::subExists, ArgxcParam::subExistsCount, ArgxcOptions::subParams, and ArgxcOptions::subParamsCount.

argxcGetSubParam()

bool argxcGetSubParam	(	Argxc *	argxc,
		const ArgxcParam *	param,
		const char *	id )

Retrieve a sub-parameter from a given parameter by ID.

Parameters

argxc	Pointer to the Argxc instance.
param	Pointer to the parent parameter.
id	The identifier of the sub-parameter.

Returns

true if the sub-parameter exists, false otherwise.

Definition at line 366 of file Argx.c.

{
    if (!argxc || !param || !id) return false;
 
    int index = argxcFindParam(argxc, id);
    return argxcParamExists(argxc, id) && param->subExists && index >= 0 && 
        (size_t)index < param->subExistsCount && param->subExists[index];
}

References argxcFindParam(), argxcParamExists(), and ArgxcParam::subExists.

argxcParamExists()

bool argxcParamExists	(	Argxc *	argxc,
		const char *	id )

Check if a parameter with the given ID exists.

Parameters

argxc	Pointer to the Argxc instance.
id	The identifier of the parameter.

Returns

true if the parameter exists, false otherwise.

Definition at line 209 of file Argx.c.

{
    return argxcFindParam(argxc, id) >= 0;
}

References argxcFindParam().

Referenced by argxcGetSubParam().

freeOptionsArray()

static void freeOptionsArray ( ArgxcOptions * options, size_t count )

static

Definition at line 50 of file Argx.c.

{
    if (!options) return;
 
    for (size_t i = 0; i < count; i++)
    {
        if (&options[i]) argxcFreeOption(&options[i]);
    }
 
    if (options)
    { free(options); options = NULL; }
}

References argxcFreeOption().

Referenced by argxcDestroy().

freeStringArray()

static void freeStringArray ( char ** array, size_t count )

static

Definition at line 38 of file Argx.c.

{
    if (!array) return;
    for (size_t i = 0; i < count; i++)
    {
        if (array[i]) free(array[i]);
    }
 
    if (array)
    { free(array); array = NULL; }
}

Referenced by argxcDestroy(), and argxcFreeStringArray().

stringDuplicate()

static char * stringDuplicate ( const char * str )

static

Definition at line 26 of file Argx.c.

{
    if (!str) return NULL;
    size_t len = strlen(str) + 1;
    char *dup = malloc(len);
    if (dup)
    {
        memcpy(dup, str, len);
    }
    return dup;
}

Referenced by argxcCreate(), argxcCreateError(), argxcCreateOption(), and argxcGetMainArgs().