Merge branch 'release/2.0'

Author: Multimodcrafter

LALWE.pro

@@ -36,7 +36,7 @@ CONFIG  += c++11
 
 RC_ICONS = Lalwe_icon.ico
 
-VERSION = 1.2
+VERSION = 2.0
 
 DEFINES += APP_VERSION=\\\"$$VERSION\\\"
 

assembler.cpp

@@ -16,6 +16,7 @@ Assembler::Assembler() {
 void Assembler::assemble(std::string code, RAM* mem) {
     Logger::loggerInst->info("Assembly process started...");
     std::vector<std::string> lines = splitString(code,'\n');
+    std::map<sint,sint> datablock;
     varbel_names.clear();
     subroutines.clear();
 
@@ -78,6 +79,7 @@ void Assembler::assemble(std::string code, RAM* mem) {
     int state = 0; //where in the code are we? 0 = main code, 1 = subroutine
     subroutine* curr_s = nullptr; //stores the current subroutine information
     std::string curr_s_name = "";
+    bool curr_s_ret = false;
     int globalvarcount = 0; //how many global vars have been defined so far
     // how many local vars have been defined so far (in case of state == 1)
     // start value of 2 is necessary because 0=return-address, 1=previous frame pointer and 2=previous stack pointer
@@ -94,6 +96,13 @@ void Assembler::assemble(std::string code, RAM* mem) {
                 if(state == 0) {
                     if(words.size() > 1 && checkIdentifier(words.at(1))) {
                         varbel_names.insert(std::make_pair(words.at(1),globalvarcount));
+                        if(words.size() > 2) {
+                            for(int i = 2; i < words.size(); ++i) {
+                                datablock.insert(std::make_pair(globalvarcount,isNumeric(words.at(i))));
+                                ++globalvarcount;
+                            }
+                            --globalvarcount;
+                        }
                         ++globalvarcount; //global vars are zero basedly indexed since the data pointer points to the first available ram slot
                     } else if(words.size() == 1) {
                         Logger::loggerInst->error("Missing identifier after keyword 'define' on line ", i + 1);
@@ -122,6 +131,7 @@ void Assembler::assemble(std::string code, RAM* mem) {
                 }
             } else if(words.at(0) == "endfunction") {
                 //reset everything to state 0
+                if(!curr_s_ret) Logger::loggerInst->warning("Function '" + curr_s_name + "' has no return statement! This will most likely cause dangling pointers!");
                 localvarcount = 2;
                 curr_s = nullptr;
                 curr_s_name = "";
@@ -131,6 +141,7 @@ void Assembler::assemble(std::string code, RAM* mem) {
                 state = 1;
                 curr_s = &subroutines.at(words.at(1));
                 curr_s_name = words.at(1);
+                curr_s_ret = false;
             } else if(words.at(0) == "entrypoint") {
                 //set the entrypoint address
                 mem->setValueAt(0,address + 1);
@@ -176,6 +187,7 @@ void Assembler::assemble(std::string code, RAM* mem) {
                         return;
                     }
                 } else if(words.size() == 1) {
+                    if(words.at(0) == "ret") curr_s_ret = true;
                     //if mnemonic has no arguments, store the apropriate op-code and a null argument
                     if(Constants::OP_CODES.find(words.at(0)) != Constants::OP_CODES.end()) {
                         mem->setValueAt(address + 1, Constants::OP_CODES.at(words.at(0)));
@@ -193,6 +205,7 @@ void Assembler::assemble(std::string code, RAM* mem) {
                         if(adcp.valid) {
                             mem->setValueAt(address + 1, Constants::OP_CODES.at(words.at(0)) + adcp.op_add);
                             mem->setValueAt(address + 2, adcp.address);
+                            if(words.at(0) == "ldi" && adcp.op_add == Constants::ADR_REG) Logger::loggerInst->warning("Using register-address as argument for indirect load 'LDI', which most likely won't have the expected result, on line ", i + 1);
                         } else {
                             Logger::loggerInst->info("Assembly process aborted!");
                             emit assemblyDone();
@@ -219,6 +232,23 @@ void Assembler::assemble(std::string code, RAM* mem) {
                             emit assemblyDone();
                             return;
                         }
+                    } else if(words.at(0) == "ld" || words.at(0) == "ldi") {
+                        addressCompound adcp = getAddress(words.at(1), state, curr_s_name);
+                        addressCompound target_reg = getAddress(words.at(2),state,curr_s_name);
+                        if(adcp.valid && target_reg.valid && target_reg.op_add == Constants::ADR_REG) {
+                            sint reg_number = 0;
+                            while(target_reg.address > 0) {
+                                ++reg_number;
+                                target_reg.address >>= 1;
+                            }
+                            mem->setValueAt(address + 1, Constants::OP_CODES.at(words.at(0)) + adcp.op_add + (reg_number << 24));
+                            mem->setValueAt(address + 2, adcp.address);
+                            if(words.at(0) == "ldi" && adcp.op_add == Constants::ADR_REG) Logger::loggerInst->warning("Using register-address as argument for indirect load 'LDI', which most likely won't have the expected result, on line ", i + 1);
+                        } else {
+                            Logger::loggerInst->info("Assembly process aborted!");
+                            emit assemblyDone();
+                            return;
+                        }
                     } else {
                         Logger::loggerInst->error("Too many arguments for mnemonic '" + words.at(0) + "' on line ", i + 1);
                         Logger::loggerInst->info("Assembly process aborted!");
@@ -242,6 +272,9 @@ void Assembler::assemble(std::string code, RAM* mem) {
                 && Constants::OP_CODES.find(words.at(0)) != Constants::OP_CODES.end()) address += 2; //normal op code requires two memory slots (OP-Code + Argument)
     }
     mem->setValueAt(1,address + 1); //set the value the datapointer should be set to
+    for(std::pair<sint,sint> datavalue : datablock) {
+        mem->setValueAt(address + 1 + datavalue.first,datavalue.second);
+    }
     Logger::loggerInst->info("Assembly process done!");
     emit assemblyDone();
 }
@@ -275,11 +308,13 @@ void Assembler::verify(std::string code) {
             if(w == "function") isFunctionDef = true; //curent line is a function def
             else if(isFunctionDef) {
                 if(i == 1) { //first word after "function" is equal to the name of the subroutine
-                    if(checkIdentifier(w)) name = w;
+                    checkIdentifier(w);
+                    name = w;
                     paramcount = 0;
                 } else if(i > 1) {
                     ++paramcount;
-                    if(checkIdentifier(w)) s.param_names.insert(std::make_pair(w,paramcount)); //map param_name to position of parameter
+                    checkIdentifier(w);
+                    s.param_names.insert(std::make_pair(w,paramcount)); //map param_name to position of parameter
                 }
             } else if(w.at(0) == ':') {
                 varbel_names.insert(std::make_pair(w.substr(1),address + 2));
@@ -296,6 +331,7 @@ void Assembler::verify(std::string code) {
     int state = 0; //where in the code are we? 0 = main code, 1 = subroutine
     subroutine* curr_s = nullptr; //stores the current subroutine information
     std::string curr_s_name = "";
+    bool curr_s_ret = false;
     int globalvarcount = 0; //how many global vars have been defined so far
     // how many local vars have been defined so far (in case of state == 1)
     // start value of 2 is necessary because 0=return-address, 1=previous frame pointer and 2=previous stack pointer
@@ -324,15 +360,22 @@ void Assembler::verify(std::string code) {
                 }
             } else if(words.at(0) == "endfunction") {
                 //reset everything to state 0
+                if(!curr_s_ret) Logger::loggerInst->warning("Function '" + curr_s_name + "' has no return statement! This will most likely cause dangling pointers!");
                 localvarcount = 2;
                 curr_s = nullptr;
                 curr_s_name = "";
                 state = 0;
             } else if(words.at(0) == "function") {
                 //init everything necessary for state 1
-                state = 1;
-                curr_s = &subroutines.at(words.at(1));
-                curr_s_name = words.at(1);
+                if(words.size() > 1) {
+                    if(state == 1) Logger::loggerInst->error("Function '" + curr_s_name + "'' is missing terminator ('endfunction')");
+                    state = 1;
+                    curr_s_ret = false;
+                    curr_s = &subroutines.at(words.at(1));
+                    curr_s_name = words.at(1);
+                } else {
+                    Logger::loggerInst->error("Function definition is missing identifier on line ", i + 1);
+                }
             } else if(words.at(0) == "entrypoint") {
             } else {
                 if(words.at(0).at(0) == '#' || words.at(0).at(0) == ':') {
@@ -357,6 +400,7 @@ void Assembler::verify(std::string code) {
                         Logger::loggerInst->error("Missing function-identifier after mnemonic 'call' on line ", i + 1);
                     }
                 } else if(words.size() == 1) {
+                    if(words.at(0) == "ret") curr_s_ret = true;
                     //if mnemonic has no arguments, store the apropriate op-code and a null argument
                     if(Constants::OP_CODES.find(words.at(0)) == Constants::OP_CODES.end()) {
                         Logger::loggerInst->error("Unrecognized mnemonic on line ", i + 1);
@@ -392,6 +436,7 @@ void Assembler::verify(std::string code) {
                 && Constants::ASSEMBLY_INST.find(words.at(0)) == Constants::ASSEMBLY_INST.end()
                 && Constants::OP_CODES.find(words.at(0)) != Constants::OP_CODES.end()) address += 2; //normal op code requires two memory slots (OP-Code + Argument)
     }
+    if(state == 1) Logger::loggerInst->error("Function '" + curr_s_name + "'' is missing terminator ('endfunction')");
     Logger::loggerInst->info("Code verification done! If no error messages showed up, your code(-syntax) should be fine.");
 }
 
@@ -437,8 +482,16 @@ Assembler::addressCompound Assembler::getAddress(std::string idf, int state, std
     if(std::regex_match(idf,std::regex("^-?[0-9]+")) || std::regex_match(idf,std::regex("^-?0x[a-f0-9]+"))) {
         //if identifier is a number, it serves as the effective address/value
         Logger::loggerInst->debug("Identifier is numeric, absolute");
-        sint effective_address = std::stoi(idf,0,0);
-        result.address = effective_address;
+        try {
+            sint effective_address = std::stoi(idf,0,0);
+            result.address = effective_address;
+        } catch (const std::out_of_range& e) {
+            Logger::loggerInst->debug(e.what());
+            Logger::loggerInst->error("Number is too big to fit in a 32-Bit Integer. " + idf);
+            result.address = 0;
+            return result;
+        }
+
         result.op_add = isValue ? Constants::ADR_ABSOLUTE : Constants::VAL_ABSOLUTE;
         result.valid = true;
     } else if(idf.find('[') != std::string::npos) {
@@ -505,8 +558,14 @@ Assembler::addressCompound Assembler::getAddress(std::string idf, int state, std
 
 sint Assembler::isNumeric(std::string idf) {
     if(std::regex_match(idf,std::regex("^-?[0-9]+")) || std::regex_match(idf,std::regex("^-?0x[a-f0-9]+"))) {
-        sint effective_address = std::stoi(idf,0,0);;
-        return effective_address;
+        try {
+            sint effective_address = std::stoi(idf,0,0);
+            return effective_address;
+        } catch (const std::out_of_range& e) {
+            Logger::loggerInst->debug(e.what());
+            Logger::loggerInst->error("Number is too big to fit in a 32-Bit Integer. " + idf);
+            return -1;
+        }
     }
     return -1;
 }

constants.h

@@ -76,14 +76,14 @@ class Constants
     static const std::set<std::string> ASSEMBLY_INST;
 
     /** constants used to determine if a numeric value is a variable, register or parameter*/
-    static const int ADR_ABSOLUTE = 5;
-    static const int ADR_GLOBAL = 1;
-    static const int ADR_LOCAL = 2;
-    static const int ADR_REG = 3;
-    static const int ADR_PARAMETER = 4;
-    static const int VAL_ABSOLUTE = 0;
-    static const int VAL_GLOBAL = 6;
-    static const int VAL_LOCAL = 7;
+    static const int ADR_ABSOLUTE = 6;
+    static const int ADR_GLOBAL = 2;
+    static const int ADR_LOCAL = 3;
+    static const int ADR_REG = 4;
+    static const int ADR_PARAMETER = 5;
+    static const int VAL_ABSOLUTE = 1;
+    static const int VAL_GLOBAL = 7;
+    static const int VAL_LOCAL = 8;
     static const int VAL_REG = 9;
     static const int VAL_PARAMETER = 10;
 

controller.cpp

@@ -28,16 +28,16 @@ Controller::Controller(QObject &appMgr)
 }
 
 sint Controller::getRegisterVal(sint reg) {
-    for(int i = 0; i <= 10; ++i) {
-        if((reg & (1 << i)) != 0) return registers.at(i)->getValue();
+    for(int i = 0; i <= 10 && reg != 0; ++i) {
+        if((reg & (1 << i)) == reg) return registers.at(i)->getValue();
     }
     Logger::loggerInst->error("Inexistent register dereferenced!");
     return 0;
 }
 
 void Controller::setRegisterVal(sint reg, sint val) {
-    for(int i = 0; i <= 10; ++i) {
-        if((reg & (1 << i)) != 0) {
+    for(int i = 0; i <= 10 && reg != 0; ++i) {
+        if((reg & (1 << i)) == reg) {
             registers.at(i)->setValue(val);
             return;
         }
@@ -46,8 +46,8 @@ void Controller::setRegisterVal(sint reg, sint val) {
 }
 
 void Controller::decRegister(sint reg) {
-    for(int i = 0; i <= 10; ++i) {
-        if((reg & (1 << i)) != 0) {
+    for(int i = 0; i <= 10 && reg != 0; ++i) {
+        if((reg & (1 << i)) == reg) {
             sint val = registers.at(i)->getValue();
             registers.at(i)->setValue(val - 1);
             return;
@@ -57,8 +57,8 @@ void Controller::decRegister(sint reg) {
 }
 
 void Controller::incRegister(sint reg) {
-    for(int i = 0; i <= 10; ++i) {
-        if((reg & (1 << i)) != 0) {
+    for(int i = 0; i <= 10 && reg != 0; ++i) {
+        if((reg & (1 << i)) == reg) {
             sint val = registers.at(i)->getValue();
             registers.at(i)->setValue(val + 1);
             return;
@@ -68,8 +68,8 @@ void Controller::incRegister(sint reg) {
 }
 
 void Controller::negRegister(sint reg) {
-    for(int i = 0; i <= 10; ++i) {
-        if((reg & (1 << i)) != 0) {
+    for(int i = 0; i <= 10 && reg != 0; ++i) {
+        if((reg & (1 << i)) == reg) {
             sint val = registers.at(i)->getValue();
             registers.at(i)->setValue(-val);
             return;
@@ -79,8 +79,8 @@ void Controller::negRegister(sint reg) {
 }
 
 void Controller::notRegister(sint reg) {
-    for(int i = 0; i <= 10; ++i) {
-        if((reg & (1 << i)) != 0) {
+    for(int i = 0; i <= 10 && reg != 0; ++i) {
+        if((reg & (1 << i)) == reg) {
             sint val = registers.at(i)->getValue();
             registers.at(i)->setValue(~val);
             return;
@@ -161,7 +161,13 @@ sint Controller::calcActualValue(sint addr, sint mode, bool indirect) {
             }
             return ram->getValueAt(addr);
         case Constants::VAL_ABSOLUTE:
-            setAddressMode("Absolute value");
+            if(indirect) {
+                setAddressMode("Indirect absolute value");
+                this->setRegisterVal(Constants::REG_IND2, addr);
+                return ram->getValueAt(this->getRegisterVal(Constants::REG_IND2));
+            } else {
+                setAddressMode("Absolute value");
+            }
             return addr;
         case Constants::VAL_GLOBAL:
             if(indirect) {

lalwe_appmanager.cpp

@@ -20,6 +20,10 @@ LALWE_AppManager::LALWE_AppManager(QQmlContext* ctxt, QObject* obj) {
     setGuiProperty("addressRam2",Constants::ARRAYSIZE - Constants::RAM_VIEW_CELL_AMOUNT);
 }
 
+bool LALWE_AppManager::getSimulationRunning() {
+    return programRunning && programHandle.isRunning() && animationTicker.isActive();
+}
+
 void LALWE_AppManager::assembleSlot(const QString &code) {
     if((!assemblyRunning || assembleHandle.isFinished()) && (!programRunning || programHandle.isFinished())) {
         setGuiProperty("status","Assembling...");
@@ -60,6 +64,7 @@ void LALWE_AppManager::openProgramSlot(const QString &path) {
 
 void LALWE_AppManager::playProgramSlot() {
     if((!programRunning || programHandle.isFinished())&&(!assemblyRunning || assembleHandle.isFinished())) {
+        processor.at(0)->cancelTermination();
         setGuiProperty("status","Simulation running...");
         Logger::loggerInst->info("Simulation started...");
         programRunning = true;
@@ -69,10 +74,25 @@ void LALWE_AppManager::playProgramSlot() {
         if(animationTicker.isActive()) {
             animationTicker.stop();
             setGuiProperty("status","Simulation paused");
+            emit toggleAnimPlaying(false);
         } else {
             animationTicker.start(Constants::ANIM_DELAY_MILIS);
             setGuiProperty("status","Simulation running...");
+            emit toggleAnimPlaying(true);
+        }
+    }
+}
+
+void LALWE_AppManager::abortProgramSlot() {
+    if((programRunning && programHandle.isRunning()) || (assemblyRunning && assembleHandle.isRunning())) {
+        processor.at(0)->toggleAnimations(false);
+        emit stepAnimation();
+        processor.at(0)->requestTermination();
+        if(animationTicker.isActive()) {
+            processor.at(0)->toggleAnimations(true);
+            animationTicker.stop();
         }
+        setGuiProperty("status","Ready");
     }
 }
 

lalwe_appmanager.h

@@ -14,6 +14,7 @@ class LALWE_AppManager : public QObject
     Q_OBJECT
 signals:
     void stepAnimation();
+    void toggleAnimPlaying(bool newstate);
 
 private:
     QQmlContext* ctxt;
@@ -34,6 +35,7 @@ public slots:
     void saveProgramSlot(const QString &code, const QString & path, const int &mode);
     void openProgramSlot(const QString &path);
     void playProgramSlot();
+    void abortProgramSlot();
     void toggleAnimationsSlot(const bool &newState);
     void toggleRamHex(const bool &newState);
     void verifySlot(const QString &code);
@@ -50,5 +52,6 @@ public slots:
 
 public:
     LALWE_AppManager(QQmlContext* ctxt, QObject* obj);
+    bool getSimulationRunning();
 };
 #endif // LALWE_APPMANAGER_H

main.cpp

@@ -32,6 +32,9 @@ int main(int argc, char *argv[])
     QObject::connect(root ,SIGNAL(playProgram()),
                      appMngr, SLOT(playProgramSlot()));
 
+    QObject::connect(root, SIGNAL(abortProgram()),
+                     appMngr, SLOT(abortProgramSlot()));
+
     QObject::connect(root ,SIGNAL(toggleAnimations(bool)),
                      appMngr, SLOT(toggleAnimationsSlot(bool)));