Merge pull request #124 from Brainrotlang/feat/func_type_modifier

Feat(func): enable type modifer in user defined function

Author: SIGMazer

ast.c

@@ -12,7 +12,6 @@
 JumpBuffer *jump_buffer = {0};
 
 Function *function_table = NULL;
-jmp_buf return_jump_buf;
 ReturnValue current_return_value;
 Arena arena;
 
@@ -27,6 +26,7 @@ bool set_variable(const char *name, void *value, VarType type, TypeModifiers mod
     Variable *var = get_variable(name);
     if (var != NULL)
     {
+
         var->modifiers = mods;
         var->var_type = type;
         switch (type)
@@ -160,6 +160,7 @@ TypeModifiers get_current_modifiers(void)
 
 /* Include the symbol table functions */
 extern void yyerror(const char *s);
+extern void cleanup(void);
 extern void ragequit(int exit_code);
 extern void chill(unsigned int seconds);
 extern void yapping(const char *format, ...);
@@ -1893,6 +1894,8 @@ void check_const_assignment(const char *name)
     {
         yylineno = yylineno - 2;
         yyerror("Cannot modify const variable");
+        // TODO: make proper cleanup when error occurs
+        cleanup();
         exit(EXIT_FAILURE);
     }
 }
@@ -3476,7 +3479,7 @@ void handle_return_statement(ASTNode *expr)
     }
 }
 
-Parameter *create_parameter(char *name, VarType type, Parameter *next)
+Parameter *create_parameter(char *name, VarType type, Parameter *next, TypeModifiers mods)
 {
     Parameter *param = ARENA_ALLOC(Parameter);
     if (!param)
@@ -3488,6 +3491,7 @@ Parameter *create_parameter(char *name, VarType type, Parameter *next)
     param->name = ARENA_STRDUP(name);
     param->type = type;
     param->next = next;
+    param->modifiers = mods;
 
     return param;
 }
@@ -3605,26 +3609,27 @@ void enter_function_scope(Function *func, ArgumentList *args)
     {
         Variable *var = variable_new(curr_param->name);
         var->var_type = curr_param->type;
+        TypeModifiers mods = curr_param->modifiers;
         add_variable_to_scope(curr_param->name, var);
         SAFE_FREE(var);
 
         switch (curr_param->type)
         {
         case VAR_INT:
         case VAR_CHAR:
-            set_int_variable(curr_param->name, arg_values[i].ivalue, get_current_modifiers());
+            set_int_variable(curr_param->name, arg_values[i].ivalue, mods);
             break;
         case VAR_FLOAT:
-            set_float_variable(curr_param->name, arg_values[i].fvalue, get_current_modifiers());
+            set_float_variable(curr_param->name, arg_values[i].fvalue, mods);
             break;
         case VAR_DOUBLE:
-            set_double_variable(curr_param->name, arg_values[i].dvalue, get_current_modifiers());
+            set_double_variable(curr_param->name, arg_values[i].dvalue, mods);
             break;
         case VAR_BOOL:
-            set_bool_variable(curr_param->name, arg_values[i].bvalue, get_current_modifiers());
+            set_bool_variable(curr_param->name, arg_values[i].bvalue, mods);
             break;
         case VAR_SHORT:
-            set_short_variable(curr_param->name, arg_values[i].svalue, get_current_modifiers());
+            set_short_variable(curr_param->name, arg_values[i].svalue, mods);
             break;
         case NONE:
             break;

ast.h

@@ -59,6 +59,7 @@ typedef struct Parameter
 {
     char *name;
     VarType type;
+    TypeModifiers modifiers;
     struct Parameter *next;
 } Parameter;
 
@@ -286,7 +287,7 @@ extern TypeModifiers current_modifiers;
 extern Scope *current_scope;
 extern Function *function_table;
 extern ReturnValue current_return_value;
-extern jmp_buf return_jump_buf;
+extern JumpBuffer *jump_buffer;
 /* Function prototypes */
 bool set_int_variable(const char *name, int value, TypeModifiers mods);
 bool set_array_variable(char *name, int length, TypeModifiers mods, VarType type);
@@ -380,7 +381,7 @@ void *handle_function_call(ASTNode *node);
 
 /* User-defined functions */
 Function *create_function(char *name, VarType return_type, Parameter *params, ASTNode *body);
-Parameter *create_parameter(char *name, VarType type, Parameter *next);
+Parameter *create_parameter(char *name, VarType type, Parameter *next, TypeModifiers mods);
 void execute_function_call(const char *name, ArgumentList *args);
 ASTNode *create_function_def_node(char *name, VarType return_type, Parameter *params, ASTNode *body);
 void handle_return_statement(ASTNode *expr);
@@ -473,4 +474,13 @@ extern Arena arena;
 
 #define CURRENT_JUMP_BUFFER() (jump_buffer->data)
 
+#define CLEAN_JUMP_BUFFER() \
+    do                      \
+    {                       \
+        while (jump_buffer) \
+        {                    \
+            POP_JUMP_BUFFER(); \
+        }                    \
+    } while (0)
+
 #endif /* AST_H */

lang.y

@@ -136,10 +136,10 @@ params
     ;
 
 param_list
-    : type IDENTIFIER
-        { $$ = create_parameter($2, $1, NULL); SAFE_FREE($2); }
-    | param_list COMMA type IDENTIFIER 
-        { $$ = create_parameter($4, $3, $1); SAFE_FREE($4); }
+    : optional_modifiers type IDENTIFIER
+        { $$ = create_parameter($3, $2, NULL, get_current_modifiers()); SAFE_FREE($3); }
+    | param_list COMMA optional_modifiers type IDENTIFIER 
+        { $$ = create_parameter($5, $4, $1, get_current_modifiers()); SAFE_FREE($5); }
     ;
 
 
@@ -705,6 +705,10 @@ void cleanup() {
 
     // Free the scope
     free_scope(current_scope);
+
+    free_function_table();
+
+    CLEAN_JUMP_BUFFER();
 
     // Clean up flex's internal state
     yylex_destroy();

run_valgrind_tests.sh

@@ -3,24 +3,30 @@
 for f in test_cases/*.brainrot; do
     echo "Running Valgrind on $f..."
     base=$(basename "$f" .brainrot)
-    if [[ "$base" == slorp_int ]]; then
-        echo 42 | valgrind --leak-check=full --error-exitcode=1 ./brainrot "$f"
-    elif [[ "$base" == slorp_short ]]; then
-        echo 69 | valgrind --leak-check=full --error-exitcode=1 ./brainrot "$f"
-    elif [[ "$base" == slorp_float ]]; then
-        echo "3.14" | valgrind --leak-check=full --error-exitcode=1 ./brainrot "$f"
-    elif [[ "$base" == slorp_double ]]; then
-        echo "3.141592" | valgrind --leak-check=full --error-exitcode=1 ./brainrot "$f"
-    elif [[ "$base" == slorp_char ]]; then
-        echo "c" | valgrind --leak-check=full --error-exitcode=1 ./brainrot "$f"
-    elif [[ "$base" == slorp_string ]]; then
-        echo "skibidi bop bop yes yes" | valgrind --leak-check=full --error-exitcode=1 ./brainrot "$f"
+
+    case "$base" in
+        slorp_int)    input="42" ;;
+        slorp_short)  input="69" ;;
+        slorp_float)  input="3.14" ;;
+        slorp_double) input="3.141592" ;;
+        slorp_char)   input="c" ;;
+        slorp_string) input="skibidi bop bop yes yes" ;;
+        *)            input="" ;;
+    esac
+
+    if [[ -n "$input" ]]; then
+        echo "$input" | valgrind --leak-check=full --error-exitcode=100 ./brainrot "$f"
     else
-        valgrind --leak-check=full --error-exitcode=1 ./brainrot "$f"
+        valgrind --leak-check=full --error-exitcode=100 ./brainrot "$f"
     fi
-    if [[ $? -ne 0 ]]; then
-        echo "Valgrind failed on $f"
+
+    valgrind_exit_code=$?  # Capture only valgrind’s exit code
+
+    if [[ $valgrind_exit_code -eq 100 ]]; then
+        echo "Valgrind detected memory issues in $f"
         exit 1
     fi
+
     echo
 done
+

test_cases/func-modifier.brainrot

@@ -0,0 +1,9 @@
+rizz modifier_test(deadass rizz a) {
+    a = 3;
+    bussin a;
+}
+
+skibidi main {
+    modifier_test(6);
+    bussin 0;
+}

tests/expected_results.json

@@ -50,5 +50,6 @@
     "slorp_char": "You typed: c",
     "slorp_string": "You typed: skibidi bop bop yes yes",
     "fib": "55",
-    "func_scope": "from inner 10\nfrom outer 4\n"
+    "func_scope": "from inner 10\nfrom outer 4\n",
+    "func-modifier": "Error: Cannot modify const variable at line 7\n"
 }