Update .c and .h files and add bin/format and bin/lint

Author: marcoroth

bin/format

@@ -1,9 +1,7 @@
 #!/bin/bash
 
-# Format all C/C++ files in the repository
-find . \( -name '*.c' -o -name '*.h' -o -name '*.cpp' -o -name '*.hpp' \) \
-  -not -path "./build/*" \
-  -not -path "./vendor/*" \
-  -exec clang-format -i {} +
+set -e  # Exit on error
+
+clang-format -i src/*.c src/**/*.c src/*.h src/**/*.h ext/**/*.c ext/**/*.h
 
 echo "Formatting complete!"

bin/lint

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -e  # Exit on error
+
+clang-format --dry-run --Werror src/*.c src/**/*.c src/*.h src/**/*.h ext/**/*.c ext/**/*.h
+
+echo "Linting complete!"

ext/erbx/extension.c

@@ -4,23 +4,22 @@
 
 #include "../../src/include/erbx.h"
 
-static const char *check_string(VALUE value) {
-  if (NIL_P(value)) {
+static const char* check_string(VALUE value) {
+  if(NIL_P(value)) {
     return NULL;
   }
 
-  if (!RB_TYPE_P(value, T_STRING)) {
-    rb_raise(rb_eTypeError, "wrong argument type %" PRIsVALUE " (expected String)",
-             rb_obj_class(value));
+  if(!RB_TYPE_P(value, T_STRING)) {
+    rb_raise(rb_eTypeError, "wrong argument type %" PRIsVALUE " (expected String)", rb_obj_class(value));
   }
 
   return RSTRING_PTR(value);
 }
 
 VALUE rb_erbx_lex(VALUE self, VALUE source) {
-  const char *string = check_string(source);
+  const char* string = check_string(source);
 
-  erbx_lex((char *)string);
+  erbx_lex((char*) string);
 
   return Qnil;
 }

src/array.c

@@ -1,60 +1,66 @@
 #include "include/array.h"
 
-size_t array_sizeof(void) { return sizeof(array_T); }
+size_t array_sizeof(void) {
+  return sizeof(array_T);
+}
 
-array_T *array_init(int capacity) {
-  array_T *array = (array_T *)malloc(sizeof(array_T));
+array_T* array_init(int capacity) {
+  array_T* array = (array_T*) malloc(sizeof(array_T));
 
   array->size = 0;
   array->capacity = capacity;
-  array->items = (void **)malloc(sizeof(void *) * capacity);
+  array->items = (void**) malloc(sizeof(void*) * capacity);
 
   return array;
 }
 
-void array_append(array_T *array, void *item) {
-  if (array->size >= array->capacity) {
+void array_append(array_T* array, void* item) {
+  if(array->size >= array->capacity) {
     array->capacity *= 2;
-    array->items = (void **)realloc(array->items, sizeof(void *) * array->capacity);
+    array->items = (void**) realloc(array->items, sizeof(void*) * array->capacity);
   }
 
   array->items[array->size] = item;
   array->size++;
 }
 
-void *array_get(array_T *array, int index) {
-  if (index >= array->size || index < 0) {
+void* array_get(array_T* array, int index) {
+  if(index >= array->size || index < 0) {
     return NULL;
   }
 
   return array->items[index];
 }
 
-void array_set(array_T *array, int index, void *item) {
-  if (index >= array->size || index < 0) {
+void array_set(array_T* array, int index, void* item) {
+  if(index >= array->size || index < 0) {
     return;
   }
 
   array->items[index] = item;
 }
 
-void array_remove(array_T *array, int index) {
-  if (index >= array->size || index < 0) {
+void array_remove(array_T* array, int index) {
+  if(index >= array->size || index < 0) {
     return;
   }
 
-  for (int i = index; i < array->size - 1; i++) {
+  for(int i = index; i < array->size - 1; i++) {
     array->items[i] = array->items[i + 1];
   }
 
   array->size--;
 }
 
-size_t array_size(array_T *array) { return array->size; }
+size_t array_size(array_T* array) {
+  return array->size;
+}
 
-size_t array_capacity(array_T *array) { return array->capacity; }
+size_t array_capacity(array_T* array) {
+  return array->capacity;
+}
 
-void array_free(array_T *array) {
+void array_free(array_T* array) {
   free(array->items);
   free(array);
 }

src/ast.c

@@ -2,10 +2,12 @@
 
 #include <stdlib.h>
 
-size_t ast_sizeof(void) { return sizeof(struct AST_STRUCT); }
+size_t ast_sizeof(void) {
+  return sizeof(struct AST_STRUCT);
+}
 
-AST_T *ast_init(int type) {
-  AST_T *ast = calloc(1, ast_sizeof());
+AST_T* ast_init(int type) {
+  AST_T* ast = calloc(1, ast_sizeof());
   ast->type = type;
   ast->children = array_init(ast_sizeof());
 

src/buffer.c

@@ -4,34 +4,42 @@
 
 #include "include/buffer.h"
 
-bool buffer_init(buffer_T *buffer) {
+bool buffer_init(buffer_T* buffer) {
   buffer->capacity = 1024;
   buffer->length = 0;
   buffer->value = malloc(buffer->capacity * sizeof(char));
 
-  if (buffer->value) {
+  if(buffer->value) {
     buffer->value[0] = '\0';
   }
 
   return buffer != NULL;
 }
 
-char *buffer_value(buffer_T *buffer) { return buffer->value; }
+char* buffer_value(buffer_T* buffer) {
+  return buffer->value;
+}
 
-size_t buffer_length(buffer_T *buffer) { return buffer->length; }
+size_t buffer_length(buffer_T* buffer) {
+  return buffer->length;
+}
 
-size_t buffer_capacity(buffer_T *buffer) { return buffer->capacity; }
+size_t buffer_capacity(buffer_T* buffer) {
+  return buffer->capacity;
+}
 
-size_t buffer_sizeof(void) { return sizeof(buffer_T); }
+size_t buffer_sizeof(void) {
+  return sizeof(buffer_T);
+}
 
-void buffer_append(buffer_T *buffer, const char *text) {
+void buffer_append(buffer_T* buffer, const char* text) {
   size_t text_length = strlen(text);
 
-  if (buffer->length + text_length >= buffer->capacity) {
+  if(buffer->length + text_length >= buffer->capacity) {
     size_t new_capacity = (buffer->length + text_length) * 2;
-    char *new_buffer = realloc(buffer->value, new_capacity);
+    char* new_buffer = realloc(buffer->value, new_capacity);
 
-    if (new_buffer) {
+    if(new_buffer) {
       buffer->value = new_buffer;
       buffer->capacity = new_capacity;
     } else {
@@ -44,14 +52,13 @@ void buffer_append(buffer_T *buffer, const char *text) {
   buffer->length += text_length;
 }
 
-void buffer_prepend(buffer_T *buffer, const char *text) {
-  if (text == NULL || text[0] == '\0')
-    return;
+void buffer_prepend(buffer_T* buffer, const char* text) {
+  if(text == NULL || text[0] == '\0') return;
 
   size_t text_length = strlen(text);
   size_t new_length = buffer->length + text_length;
 
-  if (new_length >= buffer->capacity) {
+  if(new_length >= buffer->capacity) {
     size_t new_capacity = new_length * 2;
     buffer->value = realloc(buffer->value, new_capacity);
     buffer->capacity = new_capacity;
@@ -64,13 +71,12 @@ void buffer_prepend(buffer_T *buffer, const char *text) {
   buffer->value[buffer->length] = '\0';
 }
 
-void buffer_concat(buffer_T *destination, buffer_T *source) {
-  if (source->length == 0)
-    return;
+void buffer_concat(buffer_T* destination, buffer_T* source) {
+  if(source->length == 0) return;
 
   size_t new_length = destination->length + source->length;
 
-  if (new_length >= destination->capacity) {
+  if(new_length >= destination->capacity) {
     size_t new_capacity = new_length * 2;
     destination->value = realloc(destination->value, new_capacity);
     destination->capacity = new_capacity;
@@ -81,7 +87,7 @@ void buffer_concat(buffer_T *destination, buffer_T *source) {
   destination->length = new_length;
 }
 
-void buffer_free(buffer_T *buffer) {
+void buffer_free(buffer_T* buffer) {
   free(buffer->value);
   buffer->value = NULL;
   buffer->length = buffer->capacity = 0;

src/erbx.c

@@ -9,13 +9,13 @@
 
 #include <stdlib.h>
 
-array_T *erbx_lex(char *source) {
-  lexer_T *lexer = lexer_init(source);
-  token_T *token = 0;
+array_T* erbx_lex(char* source) {
+  lexer_T* lexer = lexer_init(source);
+  token_T* token = 0;
 
-  array_T *tokens = array_init(1);
+  array_T* tokens = array_init(1);
 
-  while ((token = lexer_next_token(lexer))->type != TOKEN_EOF) {
+  while((token = lexer_next_token(lexer))->type != TOKEN_EOF) {
     array_append(tokens, token);
   }
 
@@ -24,20 +24,20 @@ array_T *erbx_lex(char *source) {
   return tokens;
 }
 
-array_T *erbx_lex_file(const char *path) {
-  char *source = erbx_read_file(path);
-  array_T *tokens = erbx_lex(source);
+array_T* erbx_lex_file(const char* path) {
+  char* source = erbx_read_file(path);
+  array_T* tokens = erbx_lex(source);
 
   free(source);
 
   return tokens;
 }
 
-void erbx_lex_to_buffer(char *source, buffer_T *output) {
-  array_T *tokens = erbx_lex(source);
+void erbx_lex_to_buffer(char* source, buffer_T* output) {
+  array_T* tokens = erbx_lex(source);
 
-  for (int i = 0; i < array_size(tokens); i++) {
-    token_T *token = array_get(tokens, i);
+  for(int i = 0; i < array_size(tokens); i++) {
+    token_T* token = array_get(tokens, i);
     buffer_append(output, token_to_string(token));
     buffer_append(output, "\n");
   }
@@ -47,4 +47,6 @@ void erbx_lex_to_buffer(char *source, buffer_T *output) {
   // printf("%zu\n", root->children->size);
 }
 
-const char *erbx_version(void) { return ERBX_VERSION; }
+const char* erbx_version(void) {
+  return ERBX_VERSION;
+}

src/include/array.h

@@ -4,22 +4,22 @@
 #include <stdlib.h>
 
 typedef struct ARRAY_STRUCT {
-  void **items;
+  void** items;
   size_t size;
   size_t capacity;
 } array_T;
 
-array_T *array_init(int capacity);
+array_T* array_init(int capacity);
 
-void *array_get(array_T *array, int index);
+void* array_get(array_T* array, int index);
 
-void array_append(array_T *array, void *item);
-void array_set(array_T *array, int index, void *item);
-void array_free(array_T *array);
-void array_remove(array_T *array, int index);
+void array_append(array_T* array, void* item);
+void array_set(array_T* array, int index, void* item);
+void array_free(array_T* array);
+void array_remove(array_T* array, int index);
 
-size_t array_capacity(array_T *array);
-size_t array_size(array_T *array);
+size_t array_capacity(array_T* array);
+size_t array_size(array_T* array);
 size_t array_sizeof(void);
 
 #endif

src/include/ast.h

@@ -19,14 +19,14 @@ typedef struct AST_STRUCT {
     AST_NOOP,
   } type;
 
-  array_T *children;
-  char *name;
-  struct AST_STRUCT *value;
+  array_T* children;
+  char* name;
+  struct AST_STRUCT* value;
   int data_type;
   int int_value;
 } AST_T;
 
-AST_T *ast_init(int type);
+AST_T* ast_init(int type);
 
 size_t ast_sizeof(void);
 

src/include/buffer.h

@@ -5,22 +5,22 @@
 #include <stdlib.h>
 
 typedef struct BUFFER_STRUCT {
-  char *value;
+  char* value;
   size_t length;
   size_t capacity;
 } buffer_T;
 
-bool buffer_init(buffer_T *buffer);
+bool buffer_init(buffer_T* buffer);
 
-void buffer_append(buffer_T *buffer, const char *text);
-void buffer_prepend(buffer_T *buffer, const char *text);
-void buffer_concat(buffer_T *destination, buffer_T *source);
-void buffer_free(buffer_T *buffer);
+void buffer_append(buffer_T* buffer, const char* text);
+void buffer_prepend(buffer_T* buffer, const char* text);
+void buffer_concat(buffer_T* destination, buffer_T* source);
+void buffer_free(buffer_T* buffer);
 
-char *buffer_value(buffer_T *buffer);
+char* buffer_value(buffer_T* buffer);
 
-size_t buffer_length(buffer_T *buffer);
-size_t buffer_capacity(buffer_T *buffer);
+size_t buffer_length(buffer_T* buffer);
+size_t buffer_capacity(buffer_T* buffer);
 size_t buffer_sizeof(void);
 
 #endif