Code refactoring

Refactored code: `arg_string_handler` now changes the pointer of retval to the corresponding argv element, instead of copying it. To replicate the previous functionality (copy the value to the static buffer) `arg_strcpy_handler` can be used.
Renewed Makefile.
Fixed the bug where long arguments' values were ignored if its key was preceeded by short flags.

Author: slayers-git

README.md

@@ -13,45 +13,65 @@ static char is_verbose = 0;
 static char jump = 0;
 static char jump_last = 0;
 static char should_create = 0;
-static char project_name [5000];
+
+static char * project_name;
+
+static char * move_to = NULL;
+static char * not_moving = "not moving anywhere";
 
 int main (int argc, char ** argv) {
+	/* argparse does not check if a program had recieved any arguments */
 	if (argc == 1) {
 		return 0;
 	}
-	char buffer[5000] = { 0x0 };
+
+	/* An array, describing the options, that this program accepts */
 	arg_list list = {
-		{ 'v', "verbose", NULL, &is_verbose },
-		{ 'c', "create", NULL, &should_create },
-		{ 'j', "jump", NULL, &jump },
-		{ 'J', "jump-last", NULL, &jump_last },
-		{ 'm', "move", arg_string_handler, buffer },
+		/* s ,  long opt  ,      handler      ,  value buffer  */ 
+		{ 'v', "verbose"  , NULL              , &is_verbose    },
+		{ 'c', "create"   , NULL              , &should_create },
+		{ 'j', "jump"     , NULL              , &jump          },
+		{ 'J', "jump-last", NULL              , &jump_last     },
+		{ 'm', "move"     , arg_string_handler, &move_to       },
 		{ 0 }
+		/* NOTE */
+		/* 's' stands for "short option" here
+		 * "handler" is a function that accepts a parsed value
+		 * of the argument, modifying and writing it into the 
+		 * value buffer */
 	};
 
+	/* return code of the parser */
 	arg_return code;
+	/* in case of an error, this is going to point to the program's argument
+	 * that was the cause of it */
 	char ** ptr;
 
-	/* buffer for elements, that are not keys */
-	char * nk_buffer[3];
-	/* size of the written buffer */
+	/* buffer for the elements, that are not keys */
+	char * nk_buffer = NULL;
+	/* size of the nk_buffer */
 	size_t buf_size;
 
-	if ((ptr = arg_parse (argc, argv, list, nk_buffer, &buf_size, &code)) != NULL) {
+	/* parse the program's arguments */
+	if ((ptr = arg_parse (argc, argv, list, &nk_buffer, &buf_size, &code)) != NULL) {
 		printf ("An error occured here: %s", *ptr);
 		return code;
 	}
 
-	if (nk_buffer[0]) {
-		ARG_STRCPY(project_name, nk_buffer[0]);
-	}
+	/* if the user entered an argument, that does not belong to any key */
+	if (nk_buffer)
+		project_name = nk_buffer;
+
+	if (move_to == NULL)
+		move_to = not_moving;
 
-	printf ("Name: %s\nCreate? %i\nVerbose? %i\nJump? %i\nJump-last? %i\nMove to: %s\n", (const char *)project_name, should_create, is_verbose, jump, jump_last, buffer);
+	printf ("Name: %s\nCreate? %i\nVerbose? %i\nJump? %i\nJump-last? %i\nMove to: %s\n", (const char *)project_name, should_create, is_verbose, jump, jump_last, move_to);
 
 	return 0;
 }
+
 ```
 
 ## Installation
 
-To install argparse on a unix system just type `make && doas make install`
+To install argparse on a unix system just type `make && sudo make install`

argparse.c

@@ -23,21 +23,18 @@
  *
  * RETURN: return code */
 static ARG_INLINE arg_return arg_parse_value (int * argc, char *** argv, void ** data, size_t * size) {
-	if (!(***argv)) {
-		if (*argc == 1)
-			return ARG_NVALUE;
-		else {
-			--(*argc);
-			++(*argv);
-		}
+	if (*argc <= 1)
+		return ARG_NVALUE;
+	else {
+		--(*argc);
+		++(*argv);
 	}
 	*size = ARG_STRLEN (**argv);
 	if (*size == 0) {
 		*data = NULL;
 		return ARG_NVALUE;
 	}
 	*data = **argv;
-	**argv += *size;
 	return ARG_SUCCESS;
 }
 
@@ -48,18 +45,18 @@ static ARG_INLINE arg_return arg_parse_call_handler (int * argc, char *** argv,
 	/* TODO: Add a freaking check for non-value arguments */
 	if (ptr->handler) {
 		arg_return ret_code;
-		++(**argv);
 		ret_code = arg_parse_value(argc, argv, &data, &size);
 		if (ret_code == ARG_NVALUE) {
 			return ret_code;
 		}
 		if ((ret_code = ptr->handler(data, size, ptr->retval)) != 0)
 			return ret_code;
 	} else {
-		++(**argv);
 		*(char *)ptr->retval = 1;
-		if (*argc > 1 && (***argv + 1) == 0x0)
+		++(**argv);
+		if ((**argv + 1) == 0x0) {
 			++(*argv);
+		}
 	}
 	return ARG_SUCCESS;
 }
@@ -74,8 +71,11 @@ static ARG_INLINE arg_return arg_parse_long (int * argc, char *** argv, arg_list
 	size_t i;
 	for (i = 0; i < len; ++i) {
 		if (ARG_STREQ(list[i].long_arg, &(**argv))) {
-
-			return arg_parse_call_handler (argc, argv, &list[i]);
+			arg_return code;
+			if ((code = arg_parse_call_handler (argc, argv, &list[i])) != ARG_SUCCESS)
+				return code;
+			++(*argv); 
+			return ARG_SUCCESS;
 		}
 	}
 	return ARG_NMATCH;
@@ -100,12 +100,17 @@ static ARG_INLINE arg_return arg_parse_short (int * argc, char *** argv, arg_lis
 			if (list[i].short_arg == ***argv) {
 				if ((code = arg_parse_call_handler (argc, argv, &list[i])) != ARG_SUCCESS) 
 					return code;
+				if (list[i].handler) {
+					++(*argv);
+					return ARG_SUCCESS;
+				}
 				its_a_match = 1;
 				break;
 			}
 		}
 		if (!its_a_match) return ARG_NMATCH;
 	}
+	++(*argv);
 	return ARG_SUCCESS;
 }
 
@@ -143,42 +148,42 @@ char ** arg_parse (int argc, char ** argv, arg_list list, char ** not_keys, size
 
 	char accept_args = 1;
 
-	while (--argc) {
+	while ((--argc) > 0) {
 		if (**argv == '-' && accept_args) {
-			if (*(*argv) == 0x0) {
+			if ((**argv + 1) == 0x0) {
 				*code = ARG_UNEXP;
 				return argv;
 			}
 			if (*(++*argv) == '-') { /* If the "--" is passed we have to stop accepting the arguments */ 
-
 				if (**argv == '-' && !*(*argv + 1)) {
 					accept_args = 0;
 					++argv;
+					--argc;
 					continue;
 				}
 				++(*argv);
 				if ((ret_code = arg_parse_long (&argc, &argv, list, list_len)) != 0) {
 					*code = ret_code;
 					return argv;
 				}
-				++argv;
 				continue;
 			}
 
 			if ((ret_code = arg_parse_short (&argc, &argv, list, list_len)) != 0) {
 				*code = ret_code;
 				return argv;
-			} else {
-				++argv;
-				continue;
 			}
+			continue;
+			
 		}
 		/* Not a key */
 		if (not_keys) {
 			*not_keys = *argv;
 			++(*not_keys_len);
 			++not_keys;
-			++argv;
+			if (argc > 0) {
+				++argv; 
+			}
 			continue;
 		} else {
 			*code = ARG_UNEXP;

argparse.h

@@ -125,8 +125,16 @@ typedef p_arg_handler * arg_handler;
 
 /* A handler for a generic string. */
 static p_arg_handler arg_string_handler;
+/* A handler for a generic string, copies the data
+ * to the static buffer */
+static p_arg_handler arg_strcpy_handler;
 
 static int arg_string_handler (void * data_ptr, size_t blksize, void * retval) {
+	void ** _retval = (void **)retval;
+	*_retval = data_ptr;
+	return 0;
+}
+static int arg_strcpy_handler (void * data_ptr, size_t blksize, void * retval) {
 	if (blksize == 0) {
 		retval = NULL;
 		return 0;