fix: prevent segfault in usage display and enhance build system

- Fix null pointer dereference in argparse_usage() when options->help is NULL
- Add installation support to both Makefile and CMake with PREFIX configuration
- Add pkg-config file generation for easier library integration
- Enhance test coverage with comprehensive test suite:
  - Test NULL help text handling to prevent segfaults
  - Test callback functionality with multiple scenarios
  - Test option groups display formatting
  - Test ARGPARSE_IGNORE_UNKNOWN_ARGS flag behavior
  - Add stress test with 71 options to verify scalability
- Add CLAUDE.md with project guidance and build instructions
- Configure .claude/settings.json for development workflow

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: cofyc

.claude/settings.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(gh issue view:*)",
+      "Bash(make:*)",
+      "Bash(make:*)"
+    ],
+    "deny": []
+  }
+}

CLAUDE.md

@@ -0,0 +1,40 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+
+This is a C library project with both Makefile and CMake build systems:
+
+- Build library: `make` (builds both shared and static libraries)
+- Run tests: `make test` 
+- Clean: `make clean`
+- CMake build: `mkdir build && cd build && cmake .. && make`
+
+## Test System
+
+Tests use TAP (Test Anything Protocol) with `prove` command:
+- Test directory: `tests/`
+- Run all tests: `make test` (from root) or `prove *.sh` (from tests/)
+- Test executables are built from `.c` files and run via `.sh` shell scripts
+- Tests link against `../argparse.c` directly
+- All commands in sub-directory tests can be executed without user confirmation.
+- Always use `make -C tests <target>` to run test cases.
+
+## Library Architecture
+
+Single-header library design:
+- `argparse.h` - Public API with option definitions and parser structure
+- `argparse.c` - Implementation with argument parsing logic
+- Supports both boolean and value options (integer, float, string)
+- Options can have short (`-f`) and long (`--force`) forms
+- Automatic help generation and error handling
+
+Key structures:
+- `struct argparse` - Main parser context
+- `struct argparse_option` - Option definition with type, names, and callbacks
+- Option types: `ARGPARSE_OPT_BOOLEAN`, `ARGPARSE_OPT_INTEGER`, `ARGPARSE_OPT_FLOAT`, `ARGPARSE_OPT_STRING`
+
+Two usage patterns demonstrated in tests:
+- Basic options parsing (`tests/basic.c`)
+- Subcommand handling (`tests/subcommands.c`)

CMakeLists.txt

@@ -25,3 +25,28 @@ if(ARGPARSE_STATIC)
 	set_target_properties(argparse_static PROPERTIES OUTPUT_NAME argparse_static)
 endif()
 
+# Installation
+include(GNUInstallDirs)
+
+# Install header
+install(FILES argparse.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+# Install libraries
+if(ARGPARSE_SHARED)
+	install(TARGETS argparse_shared
+		LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+		ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+		RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+endif()
+
+if(ARGPARSE_STATIC)
+	install(TARGETS argparse_static
+		LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+		ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif()
+
+# Generate and install pkg-config file
+configure_file(argparse.pc.in argparse.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/argparse.pc
+	DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+

Makefile

@@ -1,4 +1,5 @@
 # Defaults
+PREFIX ?= /usr/local
 CFLAGS ?= -O3 -g -ggdb
 LDFLAGS ?=
 CROSS_COMPILE =
@@ -42,6 +43,18 @@ $(STLIBNAME): argparse.o
 test: 
 	make -C tests/ test
 
+install: $(DYLIBNAME) $(STLIBNAME)
+	install -d $(PREFIX)/lib
+	install -d $(PREFIX)/include
+	install -m 644 argparse.h $(PREFIX)/include/
+	install -m 755 $(DYLIBNAME) $(PREFIX)/lib/
+	install -m 644 $(STLIBNAME) $(PREFIX)/lib/
+
+uninstall:
+	rm -f $(PREFIX)/include/argparse.h
+	rm -f $(PREFIX)/lib/$(DYLIBNAME)
+	rm -f $(PREFIX)/lib/$(STLIBNAME)
+
 clean:
 	rm -rf *.[ao]
 	rm -rf *.so

argparse.c

@@ -369,7 +369,7 @@ argparse_usage(struct argparse *self)
             fputc('\n', stdout);
             pad = usage_opts_width;
         }
-        fprintf(stdout, "%*s%s\n", (int)pad + 2, "", options->help);
+        fprintf(stdout, "%*s%s\n", (int)pad + 2, "", options->help ? options->help : "");
     }
 
     // print epilog

argparse.pc.in

@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: argparse
+Description: Command-line argument parsing library for C/C++
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -largparse
+Cflags: -I${includedir}

tests/test_callbacks.c

@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "../argparse.h"
+
+static int callback_count = 0;
+static char callback_results[256] = "";
+
+static int
+simple_callback(struct argparse *self, const struct argparse_option *option)
+{
+    (void)self;
+    callback_count++;
+    strcat(callback_results, option->long_name);
+    strcat(callback_results, ",");
+    return 0;
+}
+
+static int
+value_callback(struct argparse *self, const struct argparse_option *option)
+{
+    (void)self;
+    callback_count++;
+    if (option->value && *(const char **)option->value) {
+        strcat(callback_results, *(const char **)option->value);
+        strcat(callback_results, ":");
+    }
+    strcat(callback_results, option->long_name);
+    strcat(callback_results, ",");
+    return 0;
+}
+
+static int
+error_callback(struct argparse *self, const struct argparse_option *option)
+{
+    (void)self;
+    (void)option;
+    return -1; // Simulate error
+}
+
+static const char *const usages[] = {
+    "test_callbacks [options]",
+    NULL,
+};
+
+int main(int argc, const char **argv)
+{
+    int force = 0;
+    const char *path = NULL;
+    const char *name = NULL;
+    
+    struct argparse_option options[] = {
+        OPT_HELP(),
+        OPT_GROUP("Basic options"),
+        OPT_BOOLEAN('f', "force", &force, "force mode", &simple_callback, 0, 0),
+        OPT_STRING('p', "path", &path, "path value", &value_callback, 0, 0),
+        OPT_STRING('n', "name", &name, "name value", &value_callback, 0, 0),
+        OPT_BOOLEAN('e', "error", NULL, "trigger error", &error_callback, 0, 0),
+        OPT_END(),
+    };
+
+    struct argparse argparse;
+    argparse_init(&argparse, options, usages, 0);
+    argparse_describe(&argparse, "\nTest program for callback functionality.", NULL);
+    
+    // Parse with potential error callback
+    argc = argparse_parse(&argparse, argc, argv);
+    
+    printf("callback_count: %d\n", callback_count);
+    printf("callback_results: %s\n", callback_results);
+    printf("force: %d\n", force);
+    printf("path: %s\n", path ? path : "(null)");
+    printf("name: %s\n", name ? name : "(null)");
+    printf("remaining_args: %d\n", argc);
+    
+    return 0;
+}

tests/test_callbacks.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+. $(dirname "$0")/tap-functions
+
+plan_tests 10
+
+# Compile the test
+gcc -o test_callbacks test_callbacks.c ../argparse.c || bailout "Failed to compile test_callbacks"
+
+# Test 1: No callbacks triggered
+output=$(./test_callbacks 2>&1)
+is "$?" "0" "No callbacks - exit code 0"
+echo "$output" | grep -q "callback_count: 0"
+is "$?" "0" "No callbacks triggered"
+
+# Test 2: Simple boolean callback
+output=$(./test_callbacks --force 2>&1)
+is "$?" "0" "Boolean callback - exit code 0"
+echo "$output" | grep -q "callback_count: 1"
+is "$?" "0" "One callback triggered"
+echo "$output" | grep -q "callback_results: force,"
+is "$?" "0" "Callback recorded force option"
+
+# Test 3: Value callback with string
+output=$(./test_callbacks --path=/tmp/test 2>&1)
+is "$?" "0" "String callback - exit code 0"
+echo "$output" | grep -q "callback_results: /tmp/test:path,"
+is "$?" "0" "Callback recorded path value"
+
+# Test 4: Multiple callbacks
+output=$(./test_callbacks --force --path=/tmp --name=test 2>&1)
+is "$?" "0" "Multiple callbacks - exit code 0"
+echo "$output" | grep -q "callback_count: 3"
+is "$?" "0" "Three callbacks triggered"
+echo "$output" | grep -q "force,/tmp:path,test:name,"
+is "$?" "0" "All callbacks recorded in order"
+
+# Cleanup
+rm -f test_callbacks

tests/test_groups.c

@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "../argparse.h"
+
+static const char *const usages[] = {
+    "test_groups [options]",
+    NULL,
+};
+
+int main(int argc, const char **argv)
+{
+    int verbose = 0;
+    int debug = 0;
+    int force = 0;
+    int quiet = 0;
+    const char *input = NULL;
+    const char *output = NULL;
+    const char *format = NULL;
+    int threads = 1;
+    
+    struct argparse_option options[] = {
+        OPT_HELP(),
+        OPT_GROUP("General options"),
+        OPT_BOOLEAN('v', "verbose", &verbose, "enable verbose output", NULL, 0, 0),
+        OPT_BOOLEAN('d', "debug", &debug, "enable debug mode", NULL, 0, 0),
+        OPT_BOOLEAN('q', "quiet", &quiet, "suppress normal output", NULL, 0, 0),
+        OPT_GROUP("Input/Output options"),
+        OPT_STRING('i', "input", &input, "input file path", NULL, 0, 0),
+        OPT_STRING('o', "output", &output, "output file path", NULL, 0, 0),
+        OPT_STRING('f', "format", &format, "output format (json, xml, csv)", NULL, 0, 0),
+        OPT_GROUP("Processing options"),
+        OPT_INTEGER('t', "threads", &threads, "number of threads", NULL, 0, 0),
+        OPT_BOOLEAN('F', "force", &force, "force overwrite", NULL, 0, 0),
+        OPT_GROUP(""), // Empty group name
+        OPT_BOOLEAN(0, "hidden", NULL, "hidden option", NULL, 0, 0),
+        OPT_END(),
+    };
+
+    struct argparse argparse;
+    argparse_init(&argparse, options, usages, 0);
+    argparse_describe(&argparse, "\nTest program for option groups display.",
+                      "\nThis program demonstrates how option groups are displayed in help.");
+    
+    // Just trigger help to see group display
+    if (argc == 1) {
+        argparse_usage(&argparse);
+        return 0;
+    }
+    
+    argc = argparse_parse(&argparse, argc, argv);
+    
+    printf("Options parsed successfully\n");
+    
+    return 0;
+}

tests/test_groups.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+. $(dirname "$0")/tap-functions
+
+plan_tests 8
+
+# Compile the test
+gcc -o test_groups test_groups.c ../argparse.c || bailout "Failed to compile test_groups"
+
+# Test 1: Check that help displays all groups
+output=$(./test_groups 2>&1)
+is "$?" "0" "Help display exits with 0"
+
+# Test 2-5: Verify each group header appears
+echo "$output" | grep -q "General options"
+is "$?" "0" "General options group displayed"
+
+echo "$output" | grep -q "Input/Output options"
+is "$?" "0" "Input/Output options group displayed"
+
+echo "$output" | grep -q "Processing options"
+is "$?" "0" "Processing options group displayed"
+
+# Test 6: Verify options appear under correct groups
+echo "$output" | grep -A3 "General options" | grep -q -- "--verbose"
+is "$?" "0" "verbose option under General options"
+
+echo "$output" | grep -A3 "Input/Output options" | grep -q -- "--input"
+is "$?" "0" "input option under Input/Output options"
+
+# Test 7: Verify help formatting with groups
+echo "$output" | grep -q -- "-h, --help"
+is "$?" "0" "Help option displayed correctly"
+
+# Test 8: Test actual parsing still works
+output=$(./test_groups --verbose --input=test.txt 2>&1)
+is "$?" "0" "Options parse successfully with groups"
+
+# Cleanup
+rm -f test_groups