return err in translator

app.py

@@ -0,0 +1 @@
+return "hello world"

src/err.c

@@ -140,7 +140,12 @@ void output_err(ArErr err) {
         fprintf(stderr, " ");
       }
       fprintf(stderr, "|\n");
-
+      for (size_t i = 0;i<len;i++) {
+        if (buffer[i] == '\n') {
+          buffer[i] = '\0';
+          break;
+        }
+      }
       char *line_starts = buffer;
       size_t skipped_chars = 0;
       while (*line_starts && isspace((unsigned char)*line_starts) &&
@@ -159,7 +164,7 @@ void output_err(ArErr err) {
         dyefg(stderr, DYE_RESET);
         fprintf(stderr, "%.*s",
                 (int)len - (int)skipped_chars - (int)err.column -
-                    (int)err.length,
+                    (int)err.length+1,
                 line_starts + (int)err.column + err.length - 1);
         for (int64_t i = 0; i < err.column - 1; i++) {
           fprintf(stderr, " ");

src/main.c

@@ -192,7 +192,7 @@ int load_cache(Translated *translated_dest, char *joined_paths, uint64_t hash) {
   }
   sourceLocationSize = le64toh(sourceLocationSize);
 
-  *translated_dest = init_translator();
+  *translated_dest = init_translator("");
   translated_inited = true;
 
   arena_resize(&translated_dest->constants, constantsSize);
@@ -284,7 +284,7 @@ Execution execute(char *path, Stack *stack) {
   Translated translated;
 
   if (load_cache(&translated, cache_file_path, hash) != 0) {
-    translated = init_translator();
+    translated = init_translator(path);
 
     DArray tokens;
     darray_init(&tokens, sizeof(Token));
@@ -322,7 +322,12 @@ Execution execute(char *path, Stack *stack) {
     darray_free(&tokens, free_token);
 
     start = clock();
-    translate(&translated, &ast);
+    err = translate(&translated, &ast);
+    if (err.exists) {
+      free_translator(&translated);
+      darray_free(&ast, free_parsed);
+      return (Execution){err, (Stack){NULL, NULL}};
+    }
     end = clock();
     time_spent = (double)(end - start) / CLOCKS_PER_SEC;
     total_time_spent += time_spent;

src/parser/return/return.c

@@ -10,15 +10,19 @@
 #include "../literals/literals.h"
 
 ParsedValueReturn parse_return(char *file, DArray *tokens, size_t *index) {
+  Token *token = darray_get(tokens, *index);
   (*index)++;
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   ParsedReturn *parsedReturn = checked_malloc(sizeof(ParsedReturn));
   parsedValue->type = AST_RETURN;
   parsedValue->data = parsedReturn;
+  parsedReturn->line = token->line;
+  parsedReturn->column = token->column;
+  parsedReturn->length = token->length;
   parsedReturn->value = parse_null();
   if (*index >= tokens->size)
     return (ParsedValueReturn){no_err, parsedValue};
-  Token *token = darray_get(tokens, *index);
+  token = darray_get(tokens, *index);
   if (token->type == TOKEN_NEW_LINE)
     return (ParsedValueReturn){no_err, parsedValue};
   ParsedValueReturn value = parse_token(file, tokens, index, true);

src/parser/return/return.h

@@ -11,6 +11,9 @@
 
 typedef struct {
   ParsedValue * value;
+  int64_t line;
+  int64_t column;
+  int64_t length;
 } ParsedReturn;
 
 ParsedValueReturn parse_return(char *file, DArray *tokens, size_t *index);

src/translator/declaration/declaration.c

@@ -11,15 +11,17 @@
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
+
 size_t translate_parsed_declaration(Translated *translated,
-                                    DArray delcarations) {
+                                    DArray delcarations, ArErr *err) {
   set_registers(translated, 1);
   size_t first = 0;
   for (size_t i = 0; i < delcarations.size; i++) {
     DArray* old_return_jumps = translated->return_jumps;
     translated->return_jumps = NULL;
     ParsedSingleDeclaration *singleDeclaration = darray_get(&delcarations, i);
-    size_t temp = translate_parsed(translated, singleDeclaration->from);
+    size_t temp = translate_parsed(translated, singleDeclaration->from, err);
+    if (err->exists) return first;
     if (i == 0)
       first = temp;
     size_t length = strlen(singleDeclaration->name);

src/translator/declaration/declaration.h

@@ -8,6 +8,7 @@
 #define BYTECODE_DECLARATION_H
 #include "../translator.h"
 
-size_t translate_parsed_declaration(Translated *translated, DArray delcarations);
+size_t translate_parsed_declaration(Translated *translated,
+                                    DArray delcarations, ArErr *err);
 
 #endif

src/translator/dowrap/dowrap.c

@@ -8,7 +8,7 @@
 #include "dowrap.h"
 #include <stddef.h>
 
-size_t translate_parsed_dowrap(Translated *translated, DArray *parsedDowrap) {
+size_t translate_parsed_dowrap(Translated *translated, DArray *parsedDowrap, ArErr *err) {
   set_registers(translated, 1);
 
   size_t first = translated->bytecode.size;
@@ -19,10 +19,8 @@ size_t translate_parsed_dowrap(Translated *translated, DArray *parsedDowrap) {
     darray_init(&return_jumps, sizeof(size_t));
     DArray *old_return_jumps = translated->return_jumps;
     translated->return_jumps = &return_jumps;
-    for (size_t i = 0; i < parsedDowrap->size; i++) {
+    *err = translate(translated, parsedDowrap);
-      ParsedValue *parsedValue = darray_get(parsedDowrap, i);
+    if (err->exists) return first;
-      translate_parsed(translated, parsedValue);
-    }
     push_instruction_byte(translated, OP_LOAD_NULL);
     push_instruction_byte(translated, 0);
     if (!old_return_jumps) {

src/translator/dowrap/dowrap.h

@@ -9,6 +9,6 @@
 #include "../translator.h"
 
 
-size_t translate_parsed_dowrap(Translated *translated, DArray *parsedDowrap);
+size_t translate_parsed_dowrap(Translated *translated, DArray *parsedDowrap, ArErr *err);
 
 #endif // TRANSLATE_DO_WRAP_H

src/translator/function/function.c

@@ -12,13 +12,13 @@
 #include <stdlib.h>
 #include <string.h>
 size_t translate_parsed_function(Translated *translated,
-                                 ParsedFunction *parsedFunction) {
+                                 ParsedFunction *parsedFunction, ArErr *err) {
   DArray main_bytecode = translated->bytecode;
   DArray _temp_bytecode;
   darray_init(&_temp_bytecode, sizeof(uint8_t));
   set_registers(translated, 1);
   translated->bytecode = _temp_bytecode;
-  translate_parsed(translated, parsedFunction->body);
+  translate_parsed(translated, parsedFunction->body, err);
   size_t function_bytecode_offset =
       arena_push(&translated->constants, translated->bytecode.data,
                  translated->bytecode.size*translated->bytecode.element_size);

src/translator/function/function.h

@@ -10,6 +10,6 @@
 #include "../translator.h"
 
 size_t translate_parsed_function(Translated *translated,
-                                 ParsedFunction *parsedFunction);
+                                 ParsedFunction *parsedFunction, ArErr *err);
 
 #endif

src/translator/if/if.c

@@ -5,12 +5,12 @@
  */
 
 #include "../../parser/if/if.h"
-#include "../translator.h"
+#include "if.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 
-size_t translate_parsed_if(Translated *translated, DArray *parsedIf) {
+size_t translate_parsed_if(Translated *translated, DArray *parsedIf, ArErr * err) {
   size_t *jump_after_body_positions =
       checked_malloc(parsedIf->size * sizeof(size_t));
 
@@ -22,13 +22,13 @@ size_t translate_parsed_if(Translated *translated, DArray *parsedIf) {
     ParsedConditional *condition = darray_get(parsedIf, i);
     push_instruction_byte(translated, OP_NEW_SCOPE);
     if (condition->condition) {
-      translate_parsed(translated, condition->condition);
+      translate_parsed(translated, condition->condition, err);
       push_instruction_byte(translated, OP_BOOL);
       push_instruction_byte(translated, 0);
       push_instruction_byte(translated, OP_JUMP_IF_FALSE);
       push_instruction_byte(translated, 0);
       uint64_t last_jump_index = push_instruction_code(translated, 0);
-      translate_parsed(translated, condition->content);
+      translate_parsed(translated, condition->content, err);
       push_instruction_byte(translated, OP_POP_SCOPE);
       push_instruction_byte(translated, OP_JUMP);
       jump_after_body_positions[i] = push_instruction_code(translated, 0);
@@ -36,7 +36,7 @@ size_t translate_parsed_if(Translated *translated, DArray *parsedIf) {
                            translated->bytecode.size);
       push_instruction_byte(translated, OP_POP_SCOPE);
     } else {
-      translate_parsed(translated, condition->content);
+      translate_parsed(translated, condition->content, err);
       push_instruction_byte(translated, OP_POP_SCOPE);
       push_instruction_byte(translated, OP_JUMP);
       jump_after_body_positions[i] = push_instruction_code(translated, 0);

src/translator/if/if.h

@@ -8,6 +8,6 @@
 #define TRANSLATE_iF_H
 #include "../translator.h"
 
-size_t translate_parsed_if(Translated *translated, DArray *parsedIf);
+size_t translate_parsed_if(Translated *translated, DArray *parsedIf, ArErr * err);
 
 #endif // TRANSLATE_iF_H

src/translator/return/return.c

@@ -7,9 +7,12 @@
 #include "return.h"
 
 size_t translate_parsed_return(Translated *translated,
-                               ParsedReturn *parsedReturn) {
+                               ParsedReturn *parsedReturn, ArErr * err) {
-
+  if (!translated->return_jumps) {
-  size_t first = translate_parsed(translated, parsedReturn->value);
+    *err = create_err(parsedReturn->line, parsedReturn->column, parsedReturn->length, translated->path, "Syntax Error", "nowhere to return to");
+    return 0;
+  }
+  size_t first = translate_parsed(translated, parsedReturn->value, err);
   push_instruction_byte(translated, OP_JUMP);
   size_t return_up = push_instruction_code(translated, 0);
   darray_push(translated->return_jumps, &return_up);

src/translator/return/return.h

@@ -10,6 +10,7 @@
 #include "../../parser/return/return.h"
 
 
-size_t translate_parsed_return(Translated *translated, ParsedReturn *parsedReturn);
+size_t translate_parsed_return(Translated *translated,
+                               ParsedReturn *parsedReturn, ArErr * err);
 
 #endif // TRANSLATE_RETURN_H

src/translator/translator.c

@@ -85,8 +85,9 @@ size_t arena_push(ConstantArena *arena, const void *data, size_t length) {
   return offset;
 }
 
-Translated init_translator() {
+Translated init_translator(char* path) {
   Translated translated;
+  translated.path = path;
   translated.registerCount = 1;
   translated.return_jumps=NULL;
   darray_init(&translated.bytecode, sizeof(uint8_t));
@@ -124,14 +125,14 @@ void set_registers(Translated *translator, uint8_t count) {
     translator->registerCount = count;
 }
 
-size_t translate_parsed(Translated *translated, ParsedValue *parsedValue) {
+size_t translate_parsed(Translated *translated, ParsedValue *parsedValue, ArErr*err) {
   switch (parsedValue->type) {
   case AST_STRING:
     return translate_parsed_string(translated,
                                    *((ParsedString *)parsedValue->data));
   case AST_DECLARATION:
     return translate_parsed_declaration(translated,
-                                        *((DArray *)parsedValue->data));
+                                        *((DArray *)parsedValue->data), err);
   case AST_NUMBER:
     return translate_parsed_number(translated, (char *)parsedValue->data, 0);
   case AST_NULL:
@@ -141,25 +142,30 @@ size_t translate_parsed(Translated *translated, ParsedValue *parsedValue) {
     return output;
   case AST_FUNCTION:
     return translate_parsed_function(translated,
-                                     (ParsedFunction *)parsedValue->data);
+                                     (ParsedFunction *)parsedValue->data, err);
   case AST_IDENTIFIER:
     return translate_parsed_identifier(translated,
                                        (ParsedIdentifier *)parsedValue->data);
   case AST_IF:
-    return translate_parsed_if(translated, (DArray *)parsedValue->data);
+    return translate_parsed_if(translated, (DArray *)parsedValue->data, err);
   case AST_DOWRAP:
-    return translate_parsed_dowrap(translated, (DArray *)parsedValue->data);
+    return translate_parsed_dowrap(translated, (DArray *)parsedValue->data, err);
   case AST_RETURN:
-    return translate_parsed_return(translated, (ParsedReturn *)parsedValue->data);
+    return translate_parsed_return(translated, (ParsedReturn *)parsedValue->data, err);
   }
   return 0;
 }
 
-void translate(Translated *translated, DArray *ast) {
+ArErr translate(Translated *translated, DArray *ast) {
+  ArErr err = no_err;
   for (size_t i = 0; i < ast->size; i++) {
     ParsedValue *parsedValue = darray_get(ast, i);
-    translate_parsed(translated, parsedValue);
+    translate_parsed(translated, parsedValue, &err);
+    if (err.exists) {
+      break;
+    }
   }
+  return err;
 }
 
 void free_translator(Translated *translated) {

src/translator/translator.h

@@ -30,6 +30,7 @@ typedef struct {
   DArray bytecode;
   DArray source_locations;
   ConstantArena constants;
+  char* path;
 } Translated;
 
 typedef struct {
@@ -54,11 +55,11 @@ void set_instruction_code(Translated *translator, size_t index, uint64_t code);
 
 void set_registers(Translated *translator, uint8_t count);
 
-Translated init_translator();
+Translated init_translator(char* path);
 
-size_t translate_parsed(Translated *translated, ParsedValue *parsedValue);
+size_t translate_parsed(Translated *translated, ParsedValue *parsedValue, ArErr*err);
 
-void translate(Translated *translated, DArray *ast);
+ArErr translate(Translated *translated, DArray *ast);
 
 void free_translator(Translated *translated);
 

testing.ar

@@ -1,10 +1,11 @@
 # SPDX-FileCopyrightText: 2025 William Bell
 
 # SPDX-License-Identifier: GPL-3.0-or-later
+
 let y = 1
 
 let x = do
     do
         return y
     x
-return y
+let z = x