Add parse_func

argparser.c

@@ -8,6 +8,10 @@
 
 #define INITIAL_SIZE 30
 
+INTERNAL arg_t help_arg = {ARG_TYPE_FLAG, "h", "help"};
+
+void print_usage(argparser_t *parser);
+
 struct argparser {
   arg_t *args;
   u64 size;
@@ -17,7 +21,7 @@ struct argparser {
   u64 flag_count;
 };
 
-argparser_t *create_parser(void) {
+argparser_t *create_parser(parse_func_t parse_func) {
   argparser_t *parser = (argparser_t *)malloc(sizeof(argparser_t));
 
   if (!parser) {
@@ -35,7 +39,7 @@ argparser_t *create_parser(void) {
   parser->args_count = parser->positional_count = parser->named_count =
       parser->flag_count = 0;
 
-  add_argument(parser, (arg_t){ARG_TYPE_FLAG, "h", "help"});
+  add_argument(parser, help_arg);
 
   return parser;
 }
@@ -69,19 +73,19 @@ void add_argument(argparser_t *parser, arg_t arg) {
     return;
   }
 
-  if (parser->args_count + 1 == parser->size) {
-    arg_t *new_args =
-        (arg_t *)malloc((parser->size + INITIAL_SIZE) * sizeof(arg_t));
+  if (parser->args_count == parser->size) {
+    parser->size += INITIAL_SIZE;
 
-    if (!new_args) {
+    // clang-format off
+    parser->args = (arg_t *)realloc(
+			(void *)(parser->args),
+			parser->size * sizeof(arg_t)
+		);
+    // clang-format on
+
+    if (!(parser->args)) {
       return;
     }
-
-    memcpy(new_args, parser->args, parser->args_count);
-
-    free(parser->args);
-
-    parser->args = new_args;
   }
 
   parser->args[(parser->args_count)++] = arg;
@@ -101,6 +105,26 @@ void add_argument(argparser_t *parser, arg_t arg) {
   }
 }
 
+void parse_args(argparser_t *parser, i32 argc, char *argv[]) {
+  for (u32 i = 0; i < argc; ++i) {
+    const char *short_name = &(argv[i][1]);
+    const char *long_name = &(argv[i][2]);
+
+    if (strcmp(short_name, help_arg.short_name) == 0 ||
+        strcmp(long_name, help_arg.long_name) == 0) {
+      print_usage(parser);
+
+      exit(0);
+    }
+  }
+
+  if (argc - 1 < parser->positional_count) {
+    print_usage(parser);
+
+    exit(1);
+  }
+}
+
 void print_usage(argparser_t *parser) {
   arg_t positional[parser->positional_count];
   memset(positional, 0, parser->positional_count);

argparser.h

@@ -19,9 +19,11 @@ typedef struct {
   const char *long_name;
 } arg_t;
 
-argparser_t *create_parser(void);
+typedef void (*parse_func_t)(arg_t arg, void *user_data);
+
+argparser_t *create_parser(parse_func_t parse_func);
 void destroy_parser(argparser_t **parser);
 void add_argument(argparser_t *parser, arg_t arg);
-void print_usage(argparser_t *parser);
+void parse_args(argparser_t *parser, i32 argc, char *argv[]);
 
 #endif // !ARGPARSER_H

build

@@ -1,7 +1,7 @@
 #!/usr/bin/bash
 
 CC=clang
-CFLAGS="-g -Wall -Werror -pedantic"
+CFLAGS="-g -Wall -Werror -Wpedantic"
 SRC=*.c
 OUT=main
 

main.c

@@ -1,8 +1,11 @@
 #include "argparser.h"
+#include <stdbool.h>
 #include <stdio.h>
 
+void parse_func(arg_t arg, void *user_data);
+
 int main(int argc, char *argv[]) {
-  argparser_t *parser = create_parser();
+  argparser_t *parser = create_parser(parse_func);
 
   add_argument(parser, (arg_t){ARG_TYPE_POSITIONAL, "c", "count"});
   add_argument(parser, (arg_t){ARG_TYPE_POSITIONAL, "g", "group"});
@@ -12,9 +15,11 @@ int main(int argc, char *argv[]) {
   add_argument(parser, (arg_t){ARG_TYPE_FLAG, "u", "undo"});
   add_argument(parser, (arg_t){ARG_TYPE_FLAG, "d", "delete"});
 
-  print_usage(parser);
+  parse_args(parser, argc, argv);
 
   destroy_parser(&parser);
 
   return 0;
 }
+
+void parse_func(arg_t arg, void *user_data) {}