Reworked the way arg_parse treats it's arguments

`arg_parse` function now reads `not_keys_size` argument's value at function invocation to determine the size of the `not_keys` array, then, after the function invocation, rewrites it with the the amount of "not key" arguments read.

Fixed some illegal memory access bugs, changed the example.c file in accordance to the new behavior of the `arg_parse` function, changed the CMakeLists.txt to ease the debugging.

Author: slayers-git

CMakeLists.txt

@@ -1,11 +1,18 @@
 # This file is part of the argparse library.
-# Copyright (C) 2021 by Sergey Lafin
+# Copyright (C) 2021-2022 by Sergey Lafin
 # Licensed under the LGPL v2.1, see the file LICENSE in base directory.
 
 cmake_minimum_required (VERSION 3.12)
 project (argparse)
 
-set (CMAKE_C_FLAGS "-O3")
+if (UNIX)
+    set (CMAKE_C_FLAGS_RELEASE "-O2")
+    set (CMAKE_C_FLAGS_DEBUG   "-g -O0")
+elseif (MSVC)
+    set (CMAKE_C_FLAGS_RELEASE "/O2")
+    set (CMAKE_C_FLAGS_DEBUG   "/g /O0")
+endif ()
+
 option (ARGPARSE_ERRORS "builtin error description via arg_geterror ()" ON)
 option (ARGPARSE_EXAMPLES "build examples" OFF)
 

argparse.c

@@ -1,6 +1,6 @@
 /* This file is part of the argparse library.
  *
- * Copyright (C) 2021 by Sergey Lafin
+ * Copyright (C) 2021-2022 by Sergey Lafin
  *
  * Licensed under the LGPL v2.1, see the file LICENSE in base directory. */
 
@@ -31,36 +31,36 @@
 
 /* A simple implementation of some important "string.h" functions */
 #ifdef ARG_STANDALONE
-#	define ARG_ASSERT(x)
+#   define ARG_ASSRT(str) /* Pretty much impossible to implement in standalone */
 #	define ARG_STRLEN(str) arg_strlen(str)
 #	define ARG_STRCPY(dest, src) arg_strcpy(dest, src)
 #	define ARG_MEMCPY(dest, src, n) arg_memcpy(dest, src, n)
 #	define ARG_STRCMP(a, b) arg_strcmp(a, b)
 
-static ARG_INLINE size_t arg_strlen (char * str) {
+static ARG_INLINE size_t arg_strlen (const char * str) {
 	size_t len = 0;
 	while (*str) {
 		++str; ++len;
 	}
 	return len;
 }
 
-static ARG_INLINE char * arg_strcpy (char * dest, char * src) {
+static ARG_INLINE char * arg_strcpy (char * dest, const char * src) {
 	while (*src) {
 		*dest++ = *src++;
 	}
 	dest = 0x0;
 	return dest;
 }
 
-static ARG_INLINE void * arg_memcpy (void * dest, void * src, size_t n) {
+static ARG_INLINE void * arg_memcpy (void * dest, const void * src, size_t n) {
 	while (*(char *)dest) {
 		*(char *)dest++ = *(char *)src++;
 	}
 	return dest;
 }
 
-static ARG_INLINE int arg_strcmp (char * f, char * s) {
+static ARG_INLINE int arg_strcmp (const char * f, const char * s) {
 	while (*f && *s) {
 		if (!(*f++ == *s++)) {
 			break;	
@@ -71,18 +71,28 @@ static ARG_INLINE int arg_strcmp (char * f, char * s) {
 
 #else
 #	include <string.h>
-#	include <assert.h>
-#	define ARG_ASSERT(x) assert(x)
 #	define ARG_STRLEN(str) strlen(str)
 #	define ARG_STRCPY(dest, src) strcpy(dest, src)
 #	define ARG_MEMCPY(dest, src, n) memcpy(dest, src, n)
 #	define ARG_STRCMP(a, b) strcmp(a, b)
+
+/* Uses my own simplified assert */
+
+#   include <stdio.h>
+#   include <stdlib.h>
+#   define ARG_ASSERT(x) { if (!(x)) arg_assert (#x); }
+static ARG_INLINE void arg_assert (const char *expr) {
+    fprintf (stderr, "argparse: assertion failed: %s\n", expr);
+    abort ();
+}
+
 #endif
 
 #define ARG_STREQ(a, b) (ARG_STRCMP(a, b) == 0)
+#define RETPTR(p) ((void **)p)
 
 arg_return arg_string_handler (char * data_ptr, size_t blksize, void * retval) {
-	void ** _retval = (void **)retval;
+	void ** _retval = RETPTR (retval);
 	*_retval = data_ptr;
 	return 0;
 }
@@ -227,15 +237,23 @@ 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_flags flags, arg_return * code) {
+char *arg_parse (int *argc, char ***argv, arg_list list, char **nk_buf, size_t *nk_size, arg_flags flags, arg_return *code) {
 	ARG_ASSERT (argv != NULL);
 	ARG_ASSERT (list != NULL);
 
 	size_t len = arg_list_len (list);
 	ARG_ASSERT (len > 0);
 
-	if (nk_size)
-		*nk_size = 0;
+    /* if nk_buf is specified, so should be the nk_size */
+    if (nk_buf)
+        ARG_ASSERT (nk_buf != NULL && nk_size != NULL);
+
+    size_t nk_lim = nk_buf ? *nk_size : 0;
+    if (nk_buf)
+        *nk_size = 0;
+
+    ++(*argv);
+
 
 	struct arg_state state;
 	state.argc   =    argc;
@@ -247,50 +265,53 @@ char * arg_parse (int * argc, char *** argv, arg_list list, char ** nk, size_t *
 
 	char accept_args = 1;
 
-	arg_return _code;
-	while (--(*state.argc)) {
-		++state.argv;
-		char * arg = *state.argv;
-		/* Not a key */
-		if ((*arg) != '-' || !accept_args) {
-			if (!nk) {
-				*code = ARG_UNEXP;
-				*argv = state.argv;
-				return arg;
-			}
-			if (nk_size) ++(*nk_size);
-			*nk = *state.argv;
-			++nk;
-			continue;
-		}
-
-		/* long */
-		if (*(arg + 1) == '-') {
-			*state.argv += 2;
-			if (!(**state.argv)) {
-				accept_args = 0;
-				continue;
-			}
-			state.type = ARG_LONG;
-			if ((_code = arg_parse_long (&state)) != ARG_SUCCESS) {
-				*code = _code;
-				*argv = state.argv;
-				return arg;
-			}
-			continue;
-		}
-
-		/* short */
-		++(*state.argv);
-		state.type = ARG_SHORT;
-		if ((_code = arg_parse_short (&state)) != ARG_SUCCESS) {
-			*code = _code;
-			*argv = state.argv;
-			return arg;
-		}
-	}
-
-	return NULL;
+    arg_return retcode;
+#define arg (*state.argv)
+    for ((*state.argc)--; *state.argc; ++state.argv, --(*state.argc)) {
+        if (*arg != '-' || !accept_args) {
+            /* if nkbuf is null, we considered the argument malformed */
+            if (!nk_buf) {
+                *code = ARG_UNEXP;
+                *argv = state.argv;
+
+                return arg;
+            }
+
+            if ((*nk_size)++ < nk_lim) {
+                *nk_buf++ = arg;
+            }
+            continue;
+        }
+
+        if (*arg == '-') {
+            ++arg;
+            if (*arg == '-') {
+                ++arg;
+                /* just "--" */
+                if (!(*arg)) {
+                    accept_args = 0;
+                } else {
+                    state.type = ARG_LONG;
+                    if ((*code = arg_parse_long (&state)) != ARG_SUCCESS) {
+                        *argv = state.argv;
+                        return arg - 2;
+                    }
+                }
+
+                continue;
+            }
+            else {
+                state.type = ARG_SHORT;
+                if ((*code = arg_parse_short (&state)) != ARG_SUCCESS) {
+                    *argv = state.argv;
+
+                    return arg - 1;
+                }
+            }
+        }
+    }
+
+    return NULL;
 }
 
 const char * arg_geterror (arg_return code) {

argparse.h

@@ -1,5 +1,5 @@
 /* argparse - fast argument parsing library
- * Copyright (C) 2021 Sergey Lafin
+ * Copyright (C) 2021-2022 Sergey Lafin
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -122,7 +122,11 @@ typedef struct arg_argument arg_list[];
  *   @param not_keys
  *     a buffer for random values
  *   @param not_keys_size
- *     size of the not_keys buffer
+ *     size of the not_keys buffer.
+ *     This variable should be initialized to represent the size of the 
+ *     not_keys array. It will be overwritten after the invocation to 
+ *     the amount of entries read to the not_keys array.  (See par. 3
+ *     in NOTES)
  *   @param flags
  *     flags, defining the behaviour of the parser
  *   @param return_code
@@ -139,7 +143,11 @@ typedef struct arg_argument arg_list[];
  *     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. */
+ *     as they were, consider writing them into another set of variables. 
+ *   3 this function READS the not_keys_size variable (unless not_keys is
+ *     not NULL in which case not_keys_size won't be read from and can be 
+ *     left as NULL), so the variable should be initialized with a value,
+ *     that represents the size of the not_keys array */
 ARGPARSE_API 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);
 
 /* const char * arg_geterror:

example.c

@@ -92,8 +92,9 @@ int main (int argc, char ** argv) {
 
 	/* the buffer for the *not-a-key* value (value, not preceeded by a key) */
 	char * nk_buf[2];
-	/* size of the written buffer */
-	size_t nk_siz;
+	/* size of the written buffer (Should be initialized, as this variable defines the 
+     * size of the existing buffer (which is of size 2 in this example)) */
+	size_t nk_siz = 2;
 
 	/* call the parser
 	 * if an error occured, the parser will stop and return the faulty argument and will write the error
@@ -104,7 +105,8 @@ int main (int argc, char ** argv) {
 	 * &argv is a pointer to the argv variable
 	 * list is the argument list
 	 * nk_buf is the buffer for storing *not-a-key* values
-	 * &nk_siz is the variable, that is going to store the size of the nk_buf
+	 * &nk_siz is the variable, that contains the size of the buffer, and then is going to store the amount of 
+     *  entries of the nk_buf array that were actually filled after parsing.
 	 * ARG_PARSE_MERGED is a flag, that tells the parser, that we allow merged key-value arguments (i.e -o+)
 	 * &code is a variable that is going to store the return code of the parser */
 	if ((err_arg = arg_parse (&argc, &argv, list, nk_buf, &nk_siz, ARG_PARSE_MERGED, &code)) != NULL) {