byterazor/yaap
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

ADD: added current version of parser

Browse Source
This commit is contained in:
Dominik Meyer 2018-03-31 00:42:50 +02:00
parent f6c876cb70
commit 768096ab3a
No known key found for this signature in database
GPG Key ID: B4C312B600606B64
2 changed files with 446 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

313
src/argparse.c Normal file
View File

@ -0,0 +1,313 @@
/*
argparse functions
Copyright (C) 2018 Dominik Meyer
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file argparse.c
* @brief file for all argparse functions
* @author Dominik Meyer <dmeyer@federationhq.de>
* @copyright 2018 by Dominik Meyer
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "argparse.h"
/**
* @brief initialize the argparse context
*
* This function has to be called at every start of the programm and before
* any other argparse functions are called!!!
*
* @return returns an initialized arg parse structure
*/
struct arg_parse_ctx * argparse_init()
{
// allocate memory for the arg_parse_ctx structure
struct arg_parse_ctx *ctx = (struct arg_parse_ctx *) calloc(sizeof(struct arg_parse_ctx),1);
if (ctx == NULL)
{
return NULL;
}
// allocate memory for the arg_parse_cmd array
ctx->arguments=(void **)calloc(sizeof(void *), ARGPARSE_INITIAL_COMMAND_NR);
if (ctx->arguments == NULL)
{
free(ctx);
return NULL;
}
return ctx;
}
/**
* @brief free an arg_parse context (all memory will be freed)
*
* this function should be called at the end of the programm
*
* @param ctx - the arg_parse_ctx structure to free
*/
void argparse_free(struct arg_parse_ctx *ctx)
{
// free the arg_parse_cmd array
free(ctx->arguments);
// free the context itself
free(ctx);
}
/**
* @brief add an arg_parse_cmd to the context for later parsing
*
* @param ctx - the context the command should be added to
* @param cmd - the command to add to the context
*
* @return 0 = everything is fine, -1 error occured
*/
int argparse_add_command(struct arg_parse_ctx *ctx, struct arg_parse_cmd *cmd)
{
if (ctx == NULL || cmd == NULL)
{
return -1;
}
cmd->base.type=ARG_CMD;
// check if the array size has to be increased
if (ctx->nr_arguments % ARGPARSE_INITIAL_COMMAND_NR == 0)
{
ctx->arguments= (void **) realloc(ctx->arguments, sizeof(void *)*(ctx->nr_arguments+ARGPARSE_INITIAL_COMMAND_NR));
}
// append the command to the array
ctx->arguments[ctx->nr_arguments]=cmd;
ctx->nr_arguments++;
return 0;
}
/**
* @brief add an arg_str to the context for later parsing
*
* @param ctx - the context the command should be added to
* @param str - the arg_str to add
*
* @return 0 = everything is fine, -1 error occured
*/
int argparse_add_string(struct arg_parse_ctx *ctx, struct arg_str *str)
{
if (ctx == NULL || str == NULL)
{
return -1;
}
str->base.type=ARG_STR;
// check if the array size has to be increased
if (ctx->nr_arguments % ARGPARSE_INITIAL_COMMAND_NR == 0)
{
ctx->arguments= (void **) realloc(ctx->arguments, sizeof(void *)*(ctx->nr_arguments+ARGPARSE_INITIAL_COMMAND_NR));
}
// append the command to the array
ctx->arguments[ctx->nr_arguments]=str;
ctx->nr_arguments++;
return 0;
}
/**
* @brief internal function to print usage information, not exported to user
*
* @param ctx - the context for which to print the usage information
* @param program - the program name the application was called with
*
*/
void argparse_usage(struct arg_parse_ctx *ctx, char *program)
{
int i=0;
printf("usage: %s <command> [<args>]\n",program);
printf("\n");
printf("Available commands: \n");
for(i=0; i<ctx->nr_arguments; i++)
{
switch (to_argbase(ctx->arguments[i])->type)
{
case ARG_CMD:
printf("\t%20s\t\t%s\n", to_cmd(ctx->arguments[i])->command, to_cmd(ctx->arguments[i])->description);
break;
default:
break;
};
}
printf("\nAvailable Arguments: \n");
for(i=0; i<ctx->nr_arguments; i++)
{
switch (to_argbase(ctx->arguments[i])->type)
{
case ARG_STR:
printf("\t-%c <string>|--%s=<string>\t\t%s\n", to_str(ctx->arguments[i])->short_flag,
to_str(ctx->arguments[i])->long_flag,
to_str(ctx->arguments[i])->description);
default:
break;
};
}
printf("\n");
}
/**
* @brief internal function to print usage information, if an unknown command has been found
*
* @param ctx - the context for which to print the usage information
* @param program - the program name the application was called with
* @param command - the command found
*
*/
void argparse_unknown_command(struct arg_parse_ctx *ctx, char *program, char *command)
{
printf("%s: \'%s\' is not a supported command.\n\n", program, command);
argparse_usage(ctx, program);
}
/**
* @brief parse the given commandline
*
* @param ctx - the arg parse context to use
* @param argc - the argument count of the commandline
* @param argv - the argument list of the commandline
*
* @return 0 - everything is fine
* @return <0 - parsing failed
*/
int argparse_parse(struct arg_parse_ctx *ctx, int argc, char **argv)
{
int i=0;
int r=0;
int found=0;
int newargc=argc;
char **newargv=argv;
if (ctx == NULL)
{
return -1;
}
// check if there are arguments to check for
if (ctx->nr_arguments == 0)
{
return 0;
}
// check if one of the command line args matches a given argument type
if (argc > 1)
{
for (i=1; i< argc; i++)
{
found=0;
for(r=0; r < ctx->nr_arguments; r++)
{
// check if the argument is a command
if (argv[i][0]!='-' && to_argbase(ctx->arguments[r])->type == ARG_CMD )
{
if (strcmp(to_cmd(ctx->arguments[r])->command,argv[i])==0)
{
found=1;
newargc--;
newargv=&argv[i];
return to_cmd(ctx->arguments[r])->cb(newargc,newargv);
}
}
// check if the argument is a string argument
else if (argv[i][0]=='-' && to_argbase(ctx->arguments[r])->type == ARG_STR)
{
// check for long argument format or short
if(argv[i][1]=='-')
{
}
else
{
if(argv[i][1] == to_str(ctx->arguments[r])->short_flag)
{
found=1;
if (i+1<argc)
{
strncpy(to_str(ctx->arguments[r])->value, argv[i+1], to_str(ctx->arguments[r])->maxchars);
i++;
}
else
{
printf("value missing for -%c parameter\n\n",to_str(ctx->arguments[r])->short_flag);
argparse_usage(ctx, argv[0]);
return -1;
}
to_argbase(ctx->arguments[r])->set=1;
}
}
}
}
if (found == 0)
{
printf("%s is an unknown command/argument\n\n", argv[i]);
argparse_usage(ctx, argv[0]);
return -1;
}
}
}
// check if all mandatory parameters have been found
for(i=0; i<ctx->nr_arguments; i++)
{
if (to_argbase(ctx->arguments[i])->mandatory==1 && to_argbase(ctx->arguments[i])->set==0)
{
printf("mandatory parameter missing ");
switch (to_argbase(ctx->arguments[i])->type)
{
case ARG_STR:
printf("-%c|--%s\n\n",to_str(ctx->arguments[i])->short_flag,to_str(ctx->arguments[i])->long_flag);
break;
default:
printf("\n");
break;
};
argparse_usage(ctx, argv[0]);
return -1;
}
}
return 0;
}

133
src/argparse.h Normal file
View File

@ -0,0 +1,133 @@
#ifndef __ARGPARSE_H__
#define __ARGPARSE_H__
/*
argparse functions
Copyright (C) 2018 Dominik Meyer
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file argparse.h
* @brief header file for all argparse functions
* @author Dominik Meyer <dmeyer@federationhq.de>
* @copyright 2018 by Dominik Meyer
*/
/** @mainpage
*
* \section intro_sec Introduction
* YAAP is a simple command line argument parser for C.
* It uses functions and structures to add arguments to the parsing context and
* parse the command line.
* \section Features
* - git like command support (git commit)
* - short and long flag support ( -t YAAP or --title=YAAP)
* - string argument support ( -t YAAP or -- title=YAAP)
*
* \section coming
* - simple flags (-v, -V, -h, --help)
* - integer arguments (-c 10)
* - hex arguments ( -c 0x5A)
*
* \section Installation
* YAAP is intented to be copied into your project directory. Different approaches are
* available:
* - simpe copy argparse.h and argparse.c into your source directory
* - add the github repository as a submodule
* - add the github repository as a subtree
* - add the github repository as a subrepo
*
* In all cases you have to make sure that argparse.c is compiled into an object file
* and is appended to your link stage.
*
* \section Functions
* All available functions can be found in argparse.c.
*
* @example example1.c
*/
#define ARGPARSE_INITIAL_COMMAND_NR 5 ///< initial size for the command array
#define to_argbase(ptr) ((struct arg_base *) ptr) ///< convert a pointer to an arg_base structure pointer
#define to_cmd(ptr) ((struct arg_parse_cmd *)ptr) ///< convert a pointer to an arg_parse_cmd structure pointer
#define to_str(ptr) ((struct arg_str *)ptr) ///< convert a pointer to an arg_str structure pointer
/**
* @brief supported argument types
*/
enum argtypes {
ARG_CMD, ///< a command argument like git uses it (git commit)
ARG_FLAG, ///< a simple flag like -v without additional parameter
ARG_STR, ///< an argument with a string parameter (-t hallo, --title=hallo)
ARG_INT ///< an argument with a integer parameter (-s 10, --size=10)
};
/**
* @brief base structure for a command line argument
*/
struct arg_base
{
enum argtypes type; ///< type of the argument
int mandatory; ///< is the argument mandatory
int set; ///< has the argument been set
};
/**
* @brief structure representing a command
*/
struct arg_parse_cmd
{
struct arg_base base; ///< base of the command line argument
int no_command; ///< if this is 1, the callback will be called if no command is given
const char *command; ///< the name of the command on the commandline, no spaces or special chars allowed, only ascii
const char *description; ///< short description of the command
int (*cb)(int argc, char **argv); ///< function to call if the command is found on commandline
};
/**
* @brief structure representing a string command line argument
*/
struct arg_str {
struct arg_base base; ///< base of the command line argument
const char short_flag; ///< one char flag identifying the argument, ignored if NULL
const char *long_flag; ///< multi char flag identifying the argument, ignore if NULL
char *value; ///< memory already allocated for the string parameter
int maxchars; ///< the maximum number of chars for the string parameters
const char *description; ///< short description of the argument
};
/**
* @brief structure for the argparse context, holding argparse specific data structures
*/
struct arg_parse_ctx
{
void **arguments; ///< array for all argparse elementsdd
int nr_arguments; ///< how many arguments are currently registered
};
struct arg_parse_ctx * argparse_init(); ///< initialize parsing context
void argparse_free(struct arg_parse_ctx *ctx); ///< free the parsing context at program end
int argparse_add_command(struct arg_parse_ctx *ctx, struct arg_parse_cmd *cmd); ///< add a commandline command to the context
int argparse_add_string(struct arg_parse_ctx *ctx, struct arg_str *str); ///< add a string argument to the context
int argparse_parse(struct arg_parse_ctx *ctx,int argc, char **argv); ///< parse the given commandline in the context
#endif