Add a kludge for unitialised variables

JohnDTill · Aug 11, 2023 · 5d0b702 · 5d0b702
1 parent 3192b19
commit 5d0b702
Show file tree

Hide file tree

Showing 5 changed files with 24 additions and 18 deletions.
diff --git a/app/mainwindow.cpp b/app/mainwindow.cpp
@@ -430,7 +430,7 @@ void MainWindow::pollInterpreterThread(){
                 break;
             default:
                 auto model = editor->getModel();
-                Typeset::Selection c = model->parser.parse_tree.getSelection(interpreter.error_node);
+                Typeset::Selection c = Program::instance()->parse_tree.getSelection(interpreter.error_node);
                 Program::instance()->error_stream.fail(c, interpreter.error_code);
                 Code::Error::writeErrors(model->errors, output, editor);
                 output->calculateSizes();

diff --git a/src/forscape_interpreter.cpp b/src/forscape_interpreter.cpp
@@ -748,17 +748,31 @@ Value& Interpreter::read(ParseNode pn) noexcept {
     }
 }
 
+static Value error_kludge;
+
 Value& Interpreter::readLocal(ParseNode pn) noexcept {
     assert(parse_tree.getOp(pn) == OP_IDENTIFIER);
     size_t stack_offset = parse_tree.getStackOffset(pn);
 
+    //This is a shameless kludge to support use-before-define before rewriting the backend
+    if(stack_offset >= stack.size()){
+        error_kludge = error(USE_BEFORE_DEFINE, pn);
+        return error_kludge;
+    }
+
     return stack.read(stack.size()-1-stack_offset   DEBUG_STACK_ARG(parse_tree.str(pn)));
 }
 
 Value& Interpreter::readGlobal(ParseNode pn) noexcept {
     assert(parse_tree.getOp(pn) == OP_READ_GLOBAL);
     size_t stack_offset = parse_tree.getGlobalIndex(pn);
 
+    //This is a shameless kludge to support use-before-define before rewriting the backend
+    if(stack_offset >= stack.size()){
+        error_kludge = error(USE_BEFORE_DEFINE, pn);
+        return error_kludge;
+    }
+
     return stack.read(stack_offset   DEBUG_STACK_ARG(parse_tree.str(pn)));
 }
 

diff --git a/src/forscape_interpreter.h b/src/forscape_interpreter.h
@@ -59,6 +59,7 @@ class Interpreter{
         const StringSwitchMap& string_switch);
     void execute();
     void stop();
+    Value error(ErrorCode code, ParseNode pn) noexcept;
 
 private:
     std::vector<size_t> frames;
@@ -70,7 +71,6 @@ class Interpreter{
     Stack stack;
 
     void reset() noexcept;
-    Value error(ErrorCode code, ParseNode pn) noexcept;
     void interpretStmt(ParseNode pn);
     void interpretStmtIfNotNone(ParseNode pn);
     void printStmt(ParseNode pn);

diff --git a/src/forscape_symbol_link_pass.cpp b/src/forscape_symbol_link_pass.cpp
@@ -23,6 +23,9 @@ void SymbolTableLinker::resolveStmt(ParseNode pn) noexcept {
     switch (parse_tree.getOp(pn)) {
         case OP_ALGORITHM:
             resolveDeclaration(parse_tree.algName(pn));
+            //Non-capturing algorithms were moved to the top of their lexical scope,
+            //despite possibly being defined later. Resolve them last so their dependencies
+            //will definitely be marked with a stack slot.
             if(parse_tree.valCapList(pn) != NONE || parse_tree.getNumArgs(parse_tree.refCapList(pn)) != 0)
                 resolveAlgorithm(pn);
             break;
@@ -97,9 +100,11 @@ void SymbolTableLinker::resolveBlock(ParseNode pn) noexcept {
     for(size_t i = 0; i < parse_tree.getNumArgs(pn); i++)
         resolveStmt(parse_tree.arg(pn, i));
 
+    //Non-capturing algorithms were moved to the top of their lexical scope,
+    //despite possibly being defined later. Resolve them last so their dependencies
+    //will definitely be marked with a stack slot.
     for(size_t i = 0; i < parse_tree.getNumArgs(pn); i++){
         ParseNode child = parse_tree.arg(pn, i);
-        //if(parse_tree.getOp(child) != OP_ALGORITHM) break; //DO THIS: why is this not working?
         if(parse_tree.getOp(child) != OP_ALGORITHM
             || parse_tree.valCapList(child) != NONE
             || parse_tree.getNumArgs(parse_tree.refCapList(child)) != 0) continue;
@@ -268,19 +273,9 @@ void SymbolTableLinker::resolveReference(ParseNode pn) noexcept {
         parse_tree.setOp(pn, OP_READ_UPVALUE);
         parse_tree.setClosureIndex(pn, sym->flag);
     }else if(sym->declaration_closure_depth == 0){
-        if(sym->flag >= stack_size){
-            //DO THIS: error
-            assert(false);
-        }
-
         parse_tree.setOp(pn, OP_READ_GLOBAL);
         parse_tree.setGlobalIndex(pn, sym->flag);
     }else{
-        if(sym->flag >= stack_size){
-            //DO THIS: error
-            assert(false);
-        }
-
         parse_tree.setStackOffset(pn, stack_size - 1 - sym->flag);
     }
 }

diff --git a/test/interpreter_scripts/errors/call_with_uninitialised_dependency.π b/test/interpreter_scripts/errors/call_with_uninitialised_dependency.π
@@ -1,8 +1,5 @@
 callWithUninitialisedDependency()
 x = 2
 alg callWithUninitialisedDependency(){
-    //return x //DO THIS
-    //assert(false) //DO THIS: why does this crash?
-    return 1
-}
-assert(false)
+    return x
+}