Commit 069301a

Better arg parsing

Author	Mitja Felicijan <mitja.felicijan@gmail.com>	2026-01-22 02:24:44 +0100
Committer	Mitja Felicijan <mitja.felicijan@gmail.com>	2026-01-22 02:24:44 +0100
Commit	`069301a603ad07338179bafed0c35b6fe3b372f2` (patch)

`-rw-r--r--`	list.c	6
`-rw-r--r--`	list.h	2
`-rw-r--r--`	main.c	54
`-rwxr-xr-x`	tests.sh	28
`-rw-r--r--`	tests/depth_test/level0.c	1
`-rw-r--r--`	tests/depth_test/sub/level1.c	1
`-rw-r--r--`	tests/test.c	5

7 files changed, 81 insertions, 16 deletions

 	*head = new;
 }
-void list_files_recursively(char *base_path, Node **head) {
+void list_files_recursively(char *base_path, Node **head, int max_depth, int current_depth) {
 	struct stat statbuf;
 	if (stat(base_path, &statbuf) == -1) {
 		perror("stat");
 			if (stat(path, &statbuf) != -1) {
 				if (S_ISDIR(statbuf.st_mode)) {
-					list_files_recursively(path, head);
+					if (max_depth == -1 || current_depth < max_depth) {
+						list_files_recursively(path, head, max_depth, current_depth + 1);
+					}
 				} else if (S_ISREG(statbuf.st_mode)) {
 					add_file_path(head, path);
 				}

diff --git a/list.h b/list.h
...
7	} Node;	7	} Node;
8		8
9	void add_file_path(Node *head, char file_path);	9	void add_file_path(Node *head, char file_path);
10	void list_files_recursively(char base_path, Node *head);	10	void list_files_recursively(char base_path, Node *head, int max_depth, int current_depth);
11	void free_file_list(Node *head);	11	void free_file_list(Node *head);
12	int size_of_file_list(Node *head);	12	int size_of_file_list(Node *head);
13		13
...

 // TODO:
-//  - Add language specific filter (by default all but it can also passed
-//    with -tpy -tc -trb) which would only parse python, c and ruby files.
-//  - By default its case insensitive but with passing -cs it tells that
-//    all matching should be done in case sensitive way.
 //  - Add Levenshtein distance for matching and expose distance as arg with
 //    something like -d5 which would allow distance of 5 on a match.
-//  - Allow DEBUG to be provided as environmental variable.
-//  - Added depth flag (-r means recursive, -l2 means 2 levels deep).
 // FIXME:
 //  - Truncate longer argument list.
+#define _GNU_SOURCE
 #include <assert.h>
+#include <getopt.h>
 #include <pthread.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "queries/c.h"
 #include "queries/cpp.h"
 #include "queries/go.h"
+#include "queries/javascript.h"
 #include "queries/php.h"
 #include "queries/python.h"
 #include "queries/rust.h"
-#include "queries/javascript.h"
 int debug_enabled = 0;
 	const char *query_string;
 	uint32_t query_len;
 	const char *cfname;
+	int case_sensitive;
 };
 // void parse_source_file(const char *file_path, const char *source_code,
 	const char *source_code = args->source_code;
 	TSLanguage *language = args->language;
 	const char *cfname = args->cfname;
+	int case_sensitive = args->case_sensitive;
 	TSParser *parser = ts_parser_new();
 	ts_parser_set_language(parser, language);
 		// Substring matching.
 		// FIXME: Add Levenshtein distance.
 		if (fn.fname != NULL) {
-			char *result = strstr(fn.fname, cfname);
+			char *result;
+			if (case_sensitive) {
+				result = strstr(fn.fname, cfname);
+			} else {
+				result = strcasestr(fn.fname, cfname);
+			}
 			if (result != NULL) {
 				char *fparams_formatted = remove_newlines(fn.fparams);
 				printf("%s:%zu: %s %s %s\n", file_path, fn.lineno, fn.ftype ? fn.ftype : "", fn.fname, fparams_formatted ? fparams_formatted : "");
 }
 int main(int argc, char *argv[]) {
-	if (argc < 2) {
+	int case_sensitive = 0;
-		printf("Usage: %s <search term> [directory|file]\n", argv[0]);
+	int max_depth = -1;
+	int opt;
+	struct option long_options[] = {
+		{"case-sensitive", no_argument, 0, 'c'},
+		{"depth", required_argument, 0, 'd'},
+		{0, 0, 0, 0}};
+	while ((opt = getopt_long(argc, argv, "cd:", long_options, NULL)) != -1) {
+		switch (opt) {
+		case 'c':
+			case_sensitive = 1;
+			break;
+		case 'd':
+			max_depth = atoi(optarg);
+			break;
+		default:
+			fprintf(stderr, "Usage: %s [-c|--case-sensitive] [-d|--depth <level>] <search term> [directory|file]\n", argv[0]);
+			return 1;
+		}
+	}
+	if (optind >= argc) {
+		fprintf(stderr, "Usage: %s [-c|--case-sensitive] [-d|--depth <level>] <search term> [directory|file]\n", argv[0]);
 		return 1;
 	}
-	const char *cfname = argv[1];
+	const char *cfname = argv[optind];
-	char *directory = (argc > 2) ? argv[2] : ".";
+	char *directory = (optind + 1 < argc) ? argv[optind + 1] : ".";
 	Node *head = NULL;
-	list_files_recursively(directory, &head);
+	list_files_recursively(directory, &head, max_depth, 0);
 	int list_size = size_of_file_list(head);
 	const char *debug_env = getenv("DEBUG");
 				thread_args->query_string = query_string;
 				thread_args->query_len = query_len;
 				thread_args->cfname = cfname;
+				thread_args->case_sensitive = case_sensitive;
 				tp_add_job(pool, (thread_func_t)parse_source_file, thread_args);
 			} else {

diff --git a/tests.sh b/tests.sh
...
29	fi	29	fi
30	}	30	}
31		31
		32	run_test_with_flags() {
		33	local label=$1
		34	local flags=$2
		35	local search_term=$3
		36	local file=$4
		37	local expected_pattern=$5
		38
		39	printf "Testing %-50s " "$label ($flags $search_term)"
		40	output=$($CREP $flags "$search_term" "$file")
		41
		42	if echo "$output" \| grep -q "$expected_pattern"; then
		43	echo "PASSED"
		44	else
		45	echo "FAILED"
		46	echo " Expected pattern: $expected_pattern"
		47	echo " Actual output: $output"
		48	failed=$((failed + 1))
		49	fi
		50	}
		51
32	echo "Starting tests..."	52	echo "Starting tests..."
33	echo "----------------"	53	echo "----------------"
34		54
...
76	run_test "C++ Class" "MyClass" "$TEST_DIR/test.cpp" "class MyClass"	96	run_test "C++ Class" "MyClass" "$TEST_DIR/test.cpp" "class MyClass"
77	run_test "C++ Struct" "MyStruct" "$TEST_DIR/test.cpp" "struct MyStruct"	97	run_test "C++ Struct" "MyStruct" "$TEST_DIR/test.cpp" "struct MyStruct"
78	run_test "C++ Method" "myMethod" "$TEST_DIR/test.cpp" "void myMethod ()"	98	run_test "C++ Method" "myMethod" "$TEST_DIR/test.cpp" "void myMethod ()"
		99
		100	# Case Sensitivity Tests
		101	run_test "Default Case Insensitive" "foo" "tests/test.c" "void FooBar"
		102	run_test_with_flags "Case Sensitive -c" "-c" "foobar" "tests/test.c" "void foobar"
		103
		104	# Depth Tests
		105	run_test_with_flags "Depth 0 (root)" "-d 0" "level" "tests/depth_test" "void level0"
		106	run_test_with_flags "Depth 1 (recursive)" "-d 1" "level" "tests/depth_test" "void level1"
79		107
80	echo "----------------"	108	echo "----------------"
81	if [ $failed -eq 0 ]; then	109	if [ $failed -eq 0 ]; then
...

diff --git a/tests/depth_test/level0.c b/tests/depth_test/level0.c
		1	void level0() {}

diff --git a/tests/depth_test/sub/level1.c b/tests/depth_test/sub/level1.c
		1	void level1() {}

diff --git a/tests/test.c b/tests/test.c
...
30	hello();	30	hello();
31	return 0;	31	return 0;
32	}	32	}
		33
		34	// Case sensitivity tests
		35	void FooBar() {}
		36	void foobar() {}
		37	void FOOBAR() {}