Move to Chromium styleguide

6 files changed, 288 insertions, 273 deletions

diff --git a/Makefile b/Makefile
index 4e0f696..afd37e4 100644
--- a/Makefile
+++ b/Makefile
@@ -29,5 +29,8 @@ ts-clean:
 valgrind:
 	valgrind -s --leak-check=full ./$(TARGET)
 
+format:
+	clang-format -i --style=Chromium *.c *.h
+
 clean:
 	rm -f *.o $(TARGET) callgrind.out.*
diff --git a/file.c b/file.c
index 0c8a93f..1909946 100644
--- a/file.c
+++ b/file.c
@@ -3,42 +3,42 @@
 
 #include "file.h"
 
-struct FileContent read_entire_file(const char *file_path) {
-	struct FileContent file_data;
-	file_data.content = NULL;
-	file_data.count = 0;
-
-	FILE *file = fopen(file_path, "rb");
-	if (file == NULL) {
-		perror("Error opening file");
-		return file_data;
-	}
-
-	fseek(file, 0, SEEK_END);
-	long file_size = ftell(file);
-	fseek(file, 0, SEEK_SET);
-
-	if (file_size == -1) {
-		perror("Error getting file size");
-		return file_data;
-	}
-
-	file_data.content = (const char *)malloc(file_size);
-	if (file_data.content == NULL) {
-		perror("Error allocating memory");
-		return file_data;
-	}
-
-	size_t bytes_read = fread((void *)file_data.content, 1, file_size, file);
-	if (bytes_read != (size_t)file_size) {
-		perror("Error reading file");
-		free((void *)file_data.content);
-		file_data.content = NULL;
-		return file_data;
-	}
-
-	file_data.count = bytes_read;
-
-	fclose(file);
-	return file_data;
+struct FileContent read_entire_file(const char* file_path) {
+  struct FileContent file_data;
+  file_data.content = NULL;
+  file_data.count = 0;
+
+  FILE* file = fopen(file_path, "rb");
+  if (file == NULL) {
+    perror("Error opening file");
+    return file_data;
+  }
+
+  fseek(file, 0, SEEK_END);
+  long file_size = ftell(file);
+  fseek(file, 0, SEEK_SET);
+
+  if (file_size == -1) {
+    perror("Error getting file size");
+    return file_data;
+  }
+
+  file_data.content = (const char*)malloc(file_size);
+  if (file_data.content == NULL) {
+    perror("Error allocating memory");
+    return file_data;
+  }
+
+  size_t bytes_read = fread((void*)file_data.content, 1, file_size, file);
+  if (bytes_read != (size_t)file_size) {
+    perror("Error reading file");
+    free((void*)file_data.content);
+    file_data.content = NULL;
+    return file_data;
+  }
+
+  file_data.count = bytes_read;
+
+  fclose(file);
+  return file_data;
 }
diff --git a/file.h b/file.h
index f923ce0..97843b2 100644
--- a/file.h
+++ b/file.h
@@ -4,10 +4,10 @@
 #include <stdio.h>
 
 struct FileContent {
-	const char *content;
-	size_t count;
+  const char* content;
+  size_t count;
 };
 
-struct FileContent read_entire_file(const char *file_path);
+struct FileContent read_entire_file(const char* file_path);
 
 #endif
diff --git a/list.c b/list.c
index 0743543..f958ea2 100644
--- a/list.c
+++ b/list.c
@@ -1,64 +1,65 @@
+#include <dirent.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <dirent.h>
-#include <sys/stat.h>
 #include <string.h>
+#include <sys/stat.h>
 
 #include "list.h"
 
-void add_file_path(Node **head, char *file_path) {
-	Node *new = (Node *)malloc(sizeof(Node));
-	new->file_path = strdup(file_path);
-	new->next = *head;
-	*head = new;
+void add_file_path(Node** head, char* file_path) {
+  Node* new = (Node*)malloc(sizeof(Node));
+  new->file_path = strdup(file_path);
+  new->next = *head;
+  *head = new;
 }
 
-void list_files_recursively(char *base_path, Node **head) {
-	char path[1000];
-	struct dirent *dp;
-	DIR *dir = opendir(base_path);
+void list_files_recursively(char* base_path, Node** head) {
+  char path[1000];
+  struct dirent* dp;
+  DIR* dir = opendir(base_path);
 
-	if (!dir) return;
+  if (!dir)
+    return;
 
-	while ((dp = readdir(dir)) != NULL) {
-		if (strcmp(dp->d_name, ".") != 0 && strcmp(dp->d_name, "..") != 0) {
-			strcpy(path, base_path);
-			strcat(path, "/");
-			strcat(path, dp->d_name);
+  while ((dp = readdir(dir)) != NULL) {
+    if (strcmp(dp->d_name, ".") != 0 && strcmp(dp->d_name, "..") != 0) {
+      strcpy(path, base_path);
+      strcat(path, "/");
+      strcat(path, dp->d_name);
 
-			struct stat statbuf;
-			if (stat(path, &statbuf) != -1) {
-				if (S_ISDIR(statbuf.st_mode)) {
-					list_files_recursively(path, head);
-				} else {
-					add_file_path(head, path);
-				}
-			}
-		}
-	}
+      struct stat statbuf;
+      if (stat(path, &statbuf) != -1) {
+        if (S_ISDIR(statbuf.st_mode)) {
+          list_files_recursively(path, head);
+        } else {
+          add_file_path(head, path);
+        }
+      }
+    }
+  }
 
-	closedir(dir);
+  closedir(dir);
 }
 
-void free_file_list(Node *head) {
-	Node *tmp;
+void free_file_list(Node* head) {
+  Node* tmp;
 
-	while (head != NULL) {
-		tmp = head;
-		head = head->next;
-		free(tmp->file_path);
-		free(tmp);
-	}
+  while (head != NULL) {
+    tmp = head;
+    head = head->next;
+    free(tmp->file_path);
+    free(tmp);
+  }
 }
 
-int size_of_file_list(Node *head) {
-	int count = 0;
+int size_of_file_list(Node* head) {
+  int count = 0;
 
-	Node *current = head;
-	while (current != NULL) {
-		count++;
-		current = current->next;
-	}
+  Node* current = head;
+  while (current != NULL) {
+    count++;
+    current = current->next;
+  }
 
-	return count;
+  return count;
 }
diff --git a/list.h b/list.h
index c958836..24705e1 100644
--- a/list.h
+++ b/list.h
@@ -2,13 +2,13 @@
 #define LIST_H
 
 typedef struct node {
-	char *file_path;
-	struct node *next;
+  char* file_path;
+  struct node* next;
 } Node;
 
-void add_file_path(Node **head, char *file_path);
-void list_files_recursively(char *base_path, Node **head);
-void free_file_list(Node *head);
-int size_of_file_list(Node *head);
+void add_file_path(Node** head, char* file_path);
+void list_files_recursively(char* base_path, Node** head);
+void free_file_list(Node* head);
+int size_of_file_list(Node* head);
 
 #endif
diff --git a/main.c b/main.c
index dc01dd8..0a6b231 100644
--- a/main.c
+++ b/main.c
@@ -10,10 +10,10 @@
 //  - Added depth flag (-r means recursive, -l2 means 2 levels deep).
 
 #include <assert.h>
+#include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <pthread.h>
 
 #include <tree_sitter/api.h>
 
@@ -23,201 +23,212 @@
 #define DEBUG 1
 
 typedef struct {
-	const char *fname;
-	const char *ftype;
-	const char *fparams;
-	size_t lineno;
+  const char* fname;
+  const char* ftype;
+  const char* fparams;
+  size_t lineno;
 } Function;
 
-const char *extract_value(TSNode captured_node, const char *source_code) {
-	size_t start = ts_node_start_byte(captured_node);
-	size_t end = ts_node_end_byte(captured_node);
-	size_t length = end - start;
-	char *buffer = malloc(length + 1);  // +1 for the null terminator
+const char* extract_value(TSNode captured_node, const char* source_code) {
+  size_t start = ts_node_start_byte(captured_node);
+  size_t end = ts_node_end_byte(captured_node);
+  size_t length = end - start;
+  char* buffer = malloc(length + 1);  // +1 for the null terminator
 
-	if (buffer != NULL) {
-		snprintf(buffer, length + 1, "%.*s", (int)length, &source_code[start]);
-		return buffer;
-	}
+  if (buffer != NULL) {
+    snprintf(buffer, length + 1, "%.*s", (int)length, &source_code[start]);
+    return buffer;
+  }
 
-	return NULL;
+  return NULL;
 }
 
 char* remove_newlines(const char* str) {
-	size_t length = strlen(str);
-	char* result = (char*)malloc(length + 1);  // +1 for the null terminator
-	if (result == NULL) {
-		fprintf(stderr, "Memory allocation failed\n");
-		exit(1);
-	}
-
-	size_t j = 0;
-	for (size_t i = 0; i < length; i++) {
-		if (str[i] != '\n') {
-			result[j++] = str[i];
-		}
-	}
-
-	result[j] = '\0';
-	return result;
+  size_t length = strlen(str);
+  char* result = (char*)malloc(length + 1);  // +1 for the null terminator
+  if (result == NULL) {
+    fprintf(stderr, "Memory allocation failed\n");
+    exit(1);
+  }
+
+  size_t j = 0;
+  for (size_t i = 0; i < length; i++) {
+    if (str[i] != '\n') {
+      result[j++] = str[i];
+    }
+  }
+
+  result[j] = '\0';
+  return result;
 }
 
 struct ThreadArgs {
-	const char* file_path;
-	const char* source_code;
-	TSLanguage* language;
-	const char* cfname;
+  const char* file_path;
+  const char* source_code;
+  TSLanguage* language;
+  const char* cfname;
 };
 
-// void parse_source_file(const char *file_path, const char *source_code, TSLanguage *language, const char *cfname) {
-void *parse_source_file(void *arg) {
-	struct ThreadArgs* args = (struct ThreadArgs*)arg;
-
-	const char *file_path = args->file_path;
-	const char *source_code = args->source_code;
-	TSLanguage *language = args->language;
-	const char *cfname = args->cfname;
-
-	TSParser *parser = ts_parser_new();
-	ts_parser_set_language(parser, language);
-
-	TSTree *tree = ts_parser_parse_string(parser, NULL, source_code, strlen(source_code));
-	TSNode root_node = ts_tree_root_node(tree);
-
-	const char *query_string = "(function_definition type: (primitive_type) @ftype declarator: (function_declarator declarator: (identifier) @fname parameters: (parameter_list) @fparams))";
-
-	uint32_t error_offset;
-	TSQueryError error_type;
-	TSQuery *query = ts_query_new(language, query_string, strlen(query_string), &error_offset, &error_type);
-
-	TSQueryCursor *query_cursor = ts_query_cursor_new();
-	ts_query_cursor_exec(query_cursor, query, root_node);
-
-	if (query != NULL) {
-		TSQueryMatch match;
-		while (ts_query_cursor_next_match(query_cursor, &match)) {
-			Function fn = {0};
-
-			for (unsigned i = 0; i < match.capture_count; i++) {
-				TSQueryCapture capture = match.captures[i];
-				TSNode captured_node = capture.node;
-
-				uint32_t capture_name_length;
-				const char *capture_name = ts_query_capture_name_for_id(query, capture.index, &capture_name_length);
-
-				if (strcmp(capture_name, "fname") == 0) {
-					fn.fname = extract_value(captured_node, source_code);
-
-					TSPoint start_point = ts_node_start_point(captured_node);
-					fn.lineno = start_point.row;
-				}
-
-				if (strcmp(capture_name, "ftype") == 0) {
-					fn.ftype = extract_value(captured_node, source_code);
-				}
-
-				if (strcmp(capture_name, "fparams") == 0) {
-					fn.fparams = extract_value(captured_node, source_code);
-				}
-			}
-
-			// Substring matching.
-			// FIXME: Add Levenshtein distance.
-			char *result = strstr(fn.fname, cfname);
-			if (result != NULL) {
-				char *fparams_formatted = remove_newlines(fn.fparams);
-				printf("%s:%zu:\t%s %s %s\n", file_path, fn.lineno, fn.ftype, fn.fname, fparams_formatted);
-			}
-		}
-	} else {
-		if (DEBUG) {
-			printf("Query creation failed at offset %u with error type %d\n", error_offset, error_type);
-		}
-	}
-
-	ts_query_cursor_delete(query_cursor);
-	ts_query_delete(query);
-	ts_tree_delete(tree);
-	ts_parser_delete(parser);
-
-	return NULL;
+// void parse_source_file(const char *file_path, const char *source_code,
+// TSLanguage *language, const char *cfname) {
+void* parse_source_file(void* arg) {
+  struct ThreadArgs* args = (struct ThreadArgs*)arg;
+
+  const char* file_path = args->file_path;
+  const char* source_code = args->source_code;
+  TSLanguage* language = args->language;
+  const char* cfname = args->cfname;
+
+  TSParser* parser = ts_parser_new();
+  ts_parser_set_language(parser, language);
+
+  TSTree* tree =
+      ts_parser_parse_string(parser, NULL, source_code, strlen(source_code));
+  TSNode root_node = ts_tree_root_node(tree);
+
+  const char* query_string =
+      "(function_definition type: (primitive_type) @ftype declarator: "
+      "(function_declarator declarator: (identifier) @fname parameters: "
+      "(parameter_list) @fparams))";
+
+  uint32_t error_offset;
+  TSQueryError error_type;
+  TSQuery* query = ts_query_new(language, query_string, strlen(query_string),
+                                &error_offset, &error_type);
+
+  TSQueryCursor* query_cursor = ts_query_cursor_new();
+  ts_query_cursor_exec(query_cursor, query, root_node);
+
+  if (query != NULL) {
+    TSQueryMatch match;
+    while (ts_query_cursor_next_match(query_cursor, &match)) {
+      Function fn = {0};
+
+      for (unsigned i = 0; i < match.capture_count; i++) {
+        TSQueryCapture capture = match.captures[i];
+        TSNode captured_node = capture.node;
+
+        uint32_t capture_name_length;
+        const char* capture_name = ts_query_capture_name_for_id(
+            query, capture.index, &capture_name_length);
+
+        if (strcmp(capture_name, "fname") == 0) {
+          fn.fname = extract_value(captured_node, source_code);
+
+          TSPoint start_point = ts_node_start_point(captured_node);
+          fn.lineno = start_point.row;
+        }
+
+        if (strcmp(capture_name, "ftype") == 0) {
+          fn.ftype = extract_value(captured_node, source_code);
+        }
+
+        if (strcmp(capture_name, "fparams") == 0) {
+          fn.fparams = extract_value(captured_node, source_code);
+        }
+      }
+
+      // Substring matching.
+      // FIXME: Add Levenshtein distance.
+      char* result = strstr(fn.fname, cfname);
+      if (result != NULL) {
+        char* fparams_formatted = remove_newlines(fn.fparams);
+        printf("%s:%zu:\t%s %s %s\n", file_path, fn.lineno, fn.ftype, fn.fname,
+               fparams_formatted);
+      }
+    }
+  } else {
+    if (DEBUG) {
+      printf("Query creation failed at offset %u with error type %d\n",
+             error_offset, error_type);
+    }
+  }
+
+  ts_query_cursor_delete(query_cursor);
+  ts_query_delete(query);
+  ts_tree_delete(tree);
+  ts_parser_delete(parser);
+
+  return NULL;
 }
 
-const char *get_file_extension(const char *file_path) {
-	const char *extension = strrchr(file_path, '.');
-	if (extension != NULL) {
-		return extension + 1;
-	}
-	return NULL;
+const char* get_file_extension(const char* file_path) {
+  const char* extension = strrchr(file_path, '.');
+  if (extension != NULL) {
+    return extension + 1;
+  }
+  return NULL;
 }
 
-int main(int argc, char *argv[]) {
-	if (argc < 3) {
-		printf("Usage: %s <search term> <directory>\n", argv[0]);
-		return 1;
-	}
-
-	char *cfname = argv[1];
-	char *directory = argv[2];
-
-	TSLanguage *tree_sitter_c(void);
-	TSLanguage *tree_sitter_python(void);
-
-	Node *head = NULL;
-	list_files_recursively(directory, &head);
-	int list_size = size_of_file_list(head);
-	/* pthread_t threads[list_size]; */
-
-	if (DEBUG) {
-		printf("Scanning %d files\n", list_size);
-	}
-
-	Node *current = head;
-	//   int thread_index = 0;
-	while (current != NULL) {
-		const char *file_path = current->file_path;
-		const char *extension = get_file_extension(file_path);
-		struct FileContent source_file = read_entire_file(file_path);
-
-		if (source_file.content != NULL) {
-			if (extension != NULL) {
-				if (strcmp(extension, "c") == 0 || strcmp(extension, "h") == 0) {
-					/* parse_source_file(file_path, source_file.content, tree_sitter_c(), cfname); */
-
-					struct ThreadArgs thread_args;
-					thread_args.file_path = file_path;
-					thread_args.source_code = source_file.content;
-					thread_args.language = tree_sitter_c();
-					thread_args.cfname = cfname;
-
-					parse_source_file(&thread_args);
-
-					/* printf("> creating thread #%d\n", thread_index); */
-					/* if (pthread_create(&threads[thread_index], NULL, parse_source_file, &thread_args) != 0) { */
-					/*   fprintf(stderr, "Error creating thread %d\n", thread_index); */
-					/*   return 1; */
-					/* } */
-				}
-			}
-			free((void *)source_file.content);
-		} else {
-			if (DEBUG) {
-				fprintf(stderr, "Failed to read file.\n");
-			}
-		}
-		current = current->next;
-		//     thread_index++;
-	}
-
-	// Collecting threads.
-	/* for (int i = 0; i < list_size; i++) { */
-	/*   printf("> collecting thread #%d\n", thread_index); */
-	/*   if (pthread_join(threads[i], NULL) != 0) { */
-	/*     fprintf(stderr, "Error joining thread %d\n", i); */
-	/*     return 1; */
-	/*   } */
-	/* } */
-
-	free_file_list(head);
-	return 0;
+int main(int argc, char* argv[]) {
+  if (argc < 3) {
+    printf("Usage: %s <search term> <directory>\n", argv[0]);
+    return 1;
+  }
+
+  char* cfname = argv[1];
+  char* directory = argv[2];
+
+  TSLanguage* tree_sitter_c(void);
+  TSLanguage* tree_sitter_python(void);
+
+  Node* head = NULL;
+  list_files_recursively(directory, &head);
+  int list_size = size_of_file_list(head);
+  /* pthread_t threads[list_size]; */
+
+  if (DEBUG) {
+    printf("Scanning %d files\n", list_size);
+  }
+
+  Node* current = head;
+  //   int thread_index = 0;
+  while (current != NULL) {
+    const char* file_path = current->file_path;
+    const char* extension = get_file_extension(file_path);
+    struct FileContent source_file = read_entire_file(file_path);
+
+    if (source_file.content != NULL) {
+      if (extension != NULL) {
+        if (strcmp(extension, "c") == 0 || strcmp(extension, "h") == 0) {
+          /* parse_source_file(file_path, source_file.content, tree_sitter_c(),
+           * cfname); */
+
+          struct ThreadArgs thread_args;
+          thread_args.file_path = file_path;
+          thread_args.source_code = source_file.content;
+          thread_args.language = tree_sitter_c();
+          thread_args.cfname = cfname;
+
+          parse_source_file(&thread_args);
+
+          /* printf("> creating thread #%d\n", thread_index); */
+          /* if (pthread_create(&threads[thread_index], NULL, parse_source_file,
+           * &thread_args) != 0) { */
+          /*   fprintf(stderr, "Error creating thread %d\n", thread_index); */
+          /*   return 1; */
+          /* } */
+        }
+      }
+      free((void*)source_file.content);
+    } else {
+      if (DEBUG) {
+        fprintf(stderr, "Failed to read file.\n");
+      }
+    }
+    current = current->next;
+    //     thread_index++;
+  }
+
+  // Collecting threads.
+  /* for (int i = 0; i < list_size; i++) { */
+  /*   printf("> collecting thread #%d\n", thread_index); */
+  /*   if (pthread_join(threads[i], NULL) != 0) { */
+  /*     fprintf(stderr, "Error joining thread %d\n", i); */
+  /*     return 1; */
+  /*   } */
+  /* } */
+
+  free_file_list(head);
+  return 0;
 }