Added global parser flags and merged key-value arguments

ARG_PARSE_MERGED can now be passed to `arg_parse` function flags to enable merged key-value arguments (i.e objdump -Mintel ...)*

Author: slayers-git

README.md

@@ -53,7 +53,7 @@ int main (int argc, char ** argv) {
 	size_t buf_size;
 
 	/* parse the program's arguments */
-	if ((ptr = arg_parse (&argc, &argv, list, &nk_buffer, &buf_size, &code)) != NULL) {
+	if ((ptr = arg_parse (&argc, &argv, list, &nk_buffer, &buf_size, ARG_PARSE_DEFAULT, &code)) != NULL) {
 		printf ("An error occured here: %s", ptr);
 		return code;
 	}

argparse.c

@@ -81,29 +81,30 @@ static int arg_strcmp (char * f, char * s) {
 #	define ARG_INLINE 
 #endif
 
-int arg_string_handler (void * data_ptr, size_t blksize, void * retval) {
+arg_return arg_string_handler (void * data_ptr, size_t blksize, void * retval) {
 	void ** _retval = (void **)retval;
 	*_retval = data_ptr;
 	return 0;
 }
-int arg_strcpy_handler (void * data_ptr, size_t blksize, void * retval) {
+arg_return arg_strcpy_handler (void * data_ptr, size_t blksize, void * retval) {
 	if (blksize == 0) {
 		retval = NULL;
 		return 0;
 	}
 	ARG_STRCPY((char *)retval, (char *)data_ptr);
 	return 0;
 }
+
 struct arg_state {
 	size_t   len;
 	int   * argc;
-	int    flags; /* NOT IMPLEMENTED YET */
+	int    flags;
 
 	char ** argv;
 	struct arg_argument * list;
 	struct arg_argument * ptr;
 
-	char type; /* NOT IMPLEMENTED YET */
+	char type;
 };
 
 static ARG_INLINE size_t arg_list_len (arg_list list) {
@@ -141,11 +142,32 @@ static ARG_INLINE arg_return arg_call_handler (struct arg_state * state) {
 
 		arg_return code;
 
-		if (*state->argc <= 1 || (state->type == ARG_SHORT && *(*state->argv + 1) != 0x0)) {
-			return ARG_NVALUE;
-		} 
-		++state->argv;
-		--(*state->argc);
+		switch (state->type) {
+		case ARG_SHORT:
+			if (state->flags & ARG_PARSE_MERGED) {
+				if (*(*state->argv + 1) == 0x0) {
+					if (*state->argc == 1)
+						return ARG_NVALUE;
+					++state->argv;
+					--(*state->argc);
+					break;
+				}
+				++(*state->argv);
+				break;
+			}
+			if (*(*state->argv + 1) != 0x0 || *state->argc == 1)
+				return ARG_NVALUE;
+			++state->argv;
+			--(*state->argc);
+			break;
+		case ARG_LONG:
+			if (*state->argc == 1) {
+				return ARG_NVALUE;
+			}
+			++state->argv;
+			--(*state->argc);
+			break;
+		}
 		arg_parse_value (state, &data, &size);
 
 		if ((code = state->ptr->handler (data, size, state->ptr->retval)) != ARG_SUCCESS) {
@@ -154,7 +176,8 @@ static ARG_INLINE arg_return arg_call_handler (struct arg_state * state) {
 		return ARG_SUCCESS;
 	}
 	/* A flag */
-	*(char *)state->ptr->retval = state->ptr->flags & ARG_FLAG_UNSET ? 0 : 1;
+	if (state->ptr->retval != NULL)
+		*(char *)state->ptr->retval = state->ptr->flags & ARG_FLAG_UNSET ? 0 : 1;
 	++(*state->argv);
 
 	if (state->ptr->flags & ARG_FLAG_HALT)
@@ -204,7 +227,7 @@ static ARG_INLINE arg_return arg_parse_long (struct arg_state * state) {
 	return ARG_NMATCH;
 }
 
-char * arg_parse (int * argc, char *** argv, arg_list list, char ** nk, size_t * nk_size, arg_return * code) {
+char * arg_parse (int * argc, char *** argv, arg_list list, char ** nk, size_t * nk_size, arg_flags flags, arg_return * code) {
 	ARG_ASSERT (*argc > 1);
 	ARG_ASSERT (argv != NULL);
 	ARG_ASSERT (list != NULL);
@@ -218,7 +241,7 @@ char * arg_parse (int * argc, char *** argv, arg_list list, char ** nk, size_t *
 	struct arg_state state;
 	state.argc   =    argc;
 	state.argv   =   *argv;
-	state.flags  =       0;
+	state.flags  =   flags;
 	state.list   =    list;
 	state.ptr    =    NULL;
 	state.len    =     len;

argparse.h

@@ -22,7 +22,9 @@
  * 		short, meaning that the data can be inserted after a whitespace
  * 		long, meaning that the data can be inserted after a space char 
  *
- * 	flags can be merged together, if they are flags (i.e: tar -xzvf ...) */
+ * 	keys can be merged together, if they are flags (i.e: tar -xzvf ...) or,
+ * 	if ARG_PARSE_MERGED is passed to the arg_parse function, merged key-value
+ * 	arguments can be used (i.e objdump -Mintel ...) */
 
 
 #ifndef __SL_ARGPARSE_H__
@@ -42,7 +44,10 @@
 #define ARG_NMATCH -6
 #define ARG_NVALUE -7
 
-typedef int p_arg_handler (void * data_ptr, size_t blksize, void * retval);
+/* Type for the return codes */
+typedef signed char arg_return;
+
+typedef arg_return p_arg_handler (void * data_ptr, size_t blksize, void * retval);
 
 /* The handler is the parser for the value of the argument
  * if NULL is passed instead of a valid handler function,
@@ -56,22 +61,24 @@ p_arg_handler arg_string_handler;
  * to the static buffer */
 p_arg_handler arg_strcpy_handler;
 
-
 /* This flag tells the parser to set the flag argument value to 0 instead of 1 */
 #define ARG_FLAG_UNSET    0x01
 /* This flag tells the parser that the value for this argument is optional */
 #define ARG_FLAG_OPTIONAL 0x04
 /* This flag tells the parser to stop when the argument is met and parsed */
 #define ARG_FLAG_HALT     0x08
 
+/* Global parser flags */
+/* Defaults */
+#define ARG_PARSE_DEFAULT   0x0
+/* Allow merged arguments (i.e: objdump -Mintel ...) */
+#define ARG_PARSE_MERGED   0x01
+
 /* Flags define the behaviour of the arguments parser 
  * As example, ARG_FLAG_HALT will cause parser to be stopped when 
  * the specified argument is met. */
 typedef unsigned char arg_flags;
 
-/* Type for the return codes */
-typedef signed char arg_return;
-
 /* struct arg_argument
  *   Contains a basic description of the argument list
  *   char short_arg: a short variant of the argument's key (i.e: -r)
@@ -92,25 +99,33 @@ struct arg_argument {
 typedef struct arg_argument arg_list[];
 
 /* char * arg_parse:
- *   IN int * argc: argument count 
- *   IN char *** argv: arguments array 
- *   IN arg_list list: list, defining the accepted arguments 
- *   IN char ** not_keys: a buffer for random values
- *   IN size_t * not_keys_size: size of the not_keys buffer
- *   OUT arg_return * return_code: a return code of the status
- *     ARG_SUCCESS [0] if the parsing is done without failures
+ *   @param argc
+ *     argument count 
+ *   @param argv
+ *     arguments array 
+ *   @param list
+ *     list, defining the accepted arguments 
+ *   @param not_keys
+ *     a buffer for random values
+ *   @param not_keys_size
+ *     size of the not_keys buffer
+ *   @param flags
+ *     flags, defining the behaviour of the parser
+ *   @param return_code
+ *     return code of the parser
+ *     NOTE: ARG_SUCCESS [0] is returned on success
  *
  *   RETURN char * arg: 
  *     - NULL on a complete success.
  *     - A pointer to the argv list's element which failed the parsing on
  *     a failure.
  *
  *   NOTES:
- *   1 this function is reentrant, meaning, that if an error occured, you
+ *   1 this function is re-entrant, meaning, that if an error occured, you
  *     can call this function again with the same set of variables and
  *     continue parsing.
  *   2 this function changes the addresses of the pointers, to save them
  *     as they were, consider writing them into another set of variables. */
-char * arg_parse (int * argc, char *** argv, arg_list list, char ** not_keys, size_t * not_keys_size, arg_return * return_code);
+char * arg_parse (int * argc, char *** argv, arg_list list, char ** not_keys, size_t * not_keys_size, arg_flags flags, arg_return * return_code);
 
 #endif