Core functionality

Author: easycoder

ecr/command.h

@@ -7,5 +7,6 @@ enum domains {
 enum valueTypes {
     TEXT_VALUE,
     INT_VALUE,
-    BOOL_VALUE
+    BOOL_VALUE,
+    CAT_VALUE
 };

ecr/definitions.h

@@ -1,5 +1,5 @@
 int core_add(Runtime* runtime) {
-    print("add handler\n");
+    runtime->notImplemented("add");
     return 0;
 };
 

ecr/domain/core/add.h

@@ -1,5 +1,5 @@
 int core_append(Runtime* runtime) {
-    print("append handler\n");
+    runtime->notImplemented("append");
     return 0;
 };
 

ecr/domain/core/append.h

@@ -1,4 +1,4 @@
 int core_array(Runtime* runtime) {
-    print("array handler\n");
+    runtime->notImplemented("array");
     return 0;
 };

ecr/domain/core/array.h

@@ -1,4 +1,4 @@
 int core_begin(Runtime* runtime) {
-    print("begin handler\n");
+    runtime->notImplemented("abegindd");
     return 0;
 };

ecr/domain/core/begin.h

@@ -0,0 +1,4 @@
+RuntimeValue* core_cat(Functions* functions) {
+    functions->notImplemented("cat");
+    return nullptr;
+};

ecr/domain/core/cat.h

@@ -1,4 +1,4 @@
 int core_clear(Runtime* runtime) {
-    print("clear handler\n");
+    runtime->notImplemented("clear");
     return 0;
 };

ecr/domain/core/clear.h

@@ -1,4 +1,4 @@
 int core_close(Runtime* runtime) {
-    print("close handler\n");
+    runtime->notImplemented("close");
     return 0;
 };

ecr/domain/core/close.h

@@ -95,14 +95,30 @@ class CoreKeywords {
             WRITE
         };
 
+        int index = 0;
+        int* map;
+        TextArray* keyArray;
         KeywordArray* keywords;
         Text* domain = new Text("core");
 
+        ///////////////////////////////////////////////////////////////////////
+        // Add a keyword. Only add keywords that are found in the key array.
+        // The map contains the index of the variable (and thus its handler)
+        // against the index of its name in the key array.
         void add(const char* name) {
-            Keyword* keyword = new Keyword();
-            keyword->setName(new Text(name));
-            keyword->setDomain(domain);
-            keywords->add(keyword);
+            int size = keyArray->getSize();
+            for (int n = 0; n < size; n++) {
+                if (keyArray->get(n)->is(name)) {
+                    Keyword* keyword = new Keyword();
+                    keyword->setName(new Text(name));
+                    keyword->setDomain(domain);
+                    keyword->setIndex(n);
+                    map[n] = index;
+                    keywords->add(keyword);
+                    break;
+                }
+            }
+            index++;
         }
 
     public:
@@ -124,7 +140,8 @@ class CoreKeywords {
 
         ///////////////////////////////////////////////////////////////////////
         // Run a command. All the information needed is in 'runtime'
-        int run(Runtime* runtime, int index) {
+        int run(Runtime* runtime, int code) {
+            int index = map[code];
             switch (index)
             {
                 case ADD:
@@ -222,7 +239,9 @@ class CoreKeywords {
 
         ///////////////////////////////////////////////////////////////////////
         // Constructor
-        CoreKeywords() {
+        CoreKeywords(TextArray* array) {
+            keyArray = array;
+            map = new int[array->getSize()];
             keywords = new KeywordArray();
             add("add");
             add("append");
@@ -274,6 +293,7 @@ class CoreKeywords {
         ///////////////////////////////////////////////////////////////////////
         // Destructor
         ~CoreKeywords() {
+            delete[] map;
             print("CoreKeywords: Destructor executed\n");
          }
 };

ecr/domain/core/core-keywords.h

@@ -1,49 +1,87 @@
-#include "../../debug.h"
+#include "symbol.h"
+#include "cat.h"
 
 // Values for the 'core' domain
 class CoreValues {
 
     private:
 
-        ValueArray* values;
-        Text* domain = new Text("core", "domain");
-        TextArray* choices;
+        enum coreIndices {
+            SYMBOL,
+            CAT
+        };
 
-        void add(Text* name, int code)  {
-            values->add(new Value(name, domain, code));
-        }
+        int index = 0;
+        int* map;
+        TextArray* keyArray;
+        KeywordArray* keywords;
+        Text* domain = new Text("core");
 
-        void add(const char* name, int code) {
-            add(new Text(name), code);
+        ///////////////////////////////////////////////////////////////////////
+        // Add a keyword. Only add keywords that are found in the key array.
+        // The map contains the index of the variable (and thus its handler)
+        // against the index of its name in the key array.
+        void add(const char* name) {
+            int size = keyArray->getSize();
+            for (int n = 0; n < size; n++) {
+                if (keyArray->get(n)->is(name)) {
+                    printf("Adding %s at position %d pointing to %d\n", name, n, index);
+                    Keyword* keyword = new Keyword();
+                    keyword->setName(new Text(name));
+                    keyword->setDomain(domain);
+                    keyword->setIndex(n);
+                    map[n] = index;
+                    keywords->add(keyword);
+                }
+            }
+            index++;
         }
 
     public:
 
-        void dump() {
-            print("This is the list of value keywords defined for the 'core' package\n");
-            for (int n = 0; n < values->getSize(); n++) {
-                Value* v = values->get(n);
-                print("%s\n", v->getName()->getText());
+        void info() {
+            print("This is the list of keywords defined for the 'core' package\n");
+            for (int n = 0; n < keywords->getSize(); n++) {
+                Keyword* k = (Keyword*)keywords->get(n);
+                print("%s\n", k->getName()->getText());
             }
             print("-----------------\n");
         };
 
         ///////////////////////////////////////////////////////////////////////
-        // Get the value choices
-        TextArray* getChoices() {
-            return choices;
+        // Get the keyword array
+        KeywordArray* getKeywords() {
+            return keywords;
         }
 
-        void init(ValueArray* values) {
-            this->values = values;
-            add("text", TEXT_VALUE);
-            add("int", INT_VALUE);
-            add("bool", BOOL_VALUE);
-        };
+        ///////////////////////////////////////////////////////////////////////
+        // Run a command. All necessary information is passed in
+        RuntimeValue* run(int code, ElementArray* value, SymbolArray* symbols, Functions* functions) {
+            // functions->showSymbolValues();
+            int index = map[code];
+            switch (index)
+            {
+                case SYMBOL:
+                    return core_symbol(functions);
+                case CAT:
+                    return core_cat(functions);
+                default:
+                    print("Unknown keyword code %d in CoreValues\n", index);
+                    exit(1);
+            }
+            return nullptr;
+        }
 
         ///////////////////////////////////////////////////////////////////////
         // Constructor
-        CoreValues() {}
+        CoreValues(TextArray* array) {
+            keyArray = array;
+            map = new int[array->getSize()];
+            keywords = new KeywordArray();
+            add("symbol");
+            add("cat");
+            keywords->flatten();
+        }
 
         ///////////////////////////////////////////////////////////////////////
         // Destructor

ecr/domain/core/core-values.h

@@ -1,4 +1,4 @@
 int core_decrement(Runtime* runtime) {
-    print("decrement handler\n");
+    runtime->notImplemented("decrement");
     return 0;
 };

ecr/domain/core/decrement.h

@@ -1,4 +1,4 @@
 int core_delete(Runtime* runtime) {
-    print("delete handler\n");
+    runtime->notImplemented("delete");
     return 0;
 };

ecr/domain/core/delete.h

@@ -1,4 +1,4 @@
 int core_divide(Runtime* runtime) {
-    print("divide handler\n");
+    runtime->notImplemented("divide");
     return 0;
 };

ecr/domain/core/divide.h

@@ -1,4 +1,4 @@
 int core_dummy(Runtime* runtime) {
-    print("dummy handler\n");
+    runtime->notImplemented("dummy");
     return 0;
 };

ecr/domain/core/dummy.h

@@ -1,4 +1,4 @@
 int core_end(Runtime* runtime) {
-    print("end handler\n");
+    runtime->notImplemented("end");
     return 0;
 };

ecr/domain/core/end.h

@@ -1,6 +1,6 @@
 int core_exit(Runtime* runtime) {
     #if KEYWORDS
-    printf("Line %s: exit\n", runtime->getCommand()->get(0)->getText());
+    printf("Line %s\n", runtime->getLineNumber());
     #endif
 
     return -1;

ecr/domain/core/exit.h

@@ -1,4 +1,4 @@
 int core_file(Runtime* runtime) {
-    print("file handler\n");
+    runtime->notImplemented("file");
     return 0;
 };

ecr/domain/core/file.h

@@ -1,9 +1,4 @@
-#ifndef CORE_FORK
-#define CORE_FORK
-
 int core_fork(Runtime* runtime) {
-    print("fork handler\n");
+    runtime->notImplemented("fork");
     return 0;
 };
-
-#endif

ecr/domain/core/fork.h

@@ -1,4 +1,4 @@
 int core_get(Runtime* runtime) {
-    print("get handler\n");
+    runtime->notImplemented("get");
     return 0;
 };

ecr/domain/core/get.h

@@ -1,5 +1,4 @@
-
 int core_gosub(Runtime* runtime) {
-    print("gosub handler\n");
+    runtime->notImplemented("gosub");
     return 0;
 };

ecr/domain/core/gosub.h

@@ -1,4 +1,4 @@
 int core_goto(Runtime* runtime) {
-    print("goto handler\n");
+    runtime->notImplemented("goto");
     return 0;
 };

ecr/domain/core/goto.h

@@ -1,4 +1,4 @@
 int core_gotoPC(Runtime* runtime) {
-    print("gotoPC handler\n");
+    runtime->notImplemented("gotoPC");
     return 0;
 };

ecr/domain/core/gotopc.h

@@ -1,9 +1,4 @@
-#ifndef CORE_IF
-#define CORE_IF
-
 int core_if(Runtime* runtime) {
-    print("if handler\n");
+    runtime->notImplemented("if");
     return 0;
 };
-
-#endif

ecr/domain/core/if.h

@@ -1,4 +1,4 @@
 int core_increment(Runtime* runtime) {
-    print("increment handler\n");
+    runtime->notImplemented("incrment");
     return 0;
 };

ecr/domain/core/increment.h

@@ -1,4 +1,4 @@
 int core_index(Runtime* runtime) {
-    print("index handler\n");
+    runtime->notImplemented("index");
     return 0;
 };

ecr/domain/core/index.h

@@ -1,4 +1,4 @@
 int core_init(Runtime* runtime) {
-    print("init handler\n");
+    runtime->notImplemented("init");
     return 0;
 };

ecr/domain/core/init.h

@@ -1,4 +1,4 @@
 int core_multiply(Runtime* runtime) {
-    print("multiply handler\n");
+    runtime->notImplemented("multiply");
     return 0;
 };

ecr/domain/core/multiply.h

@@ -1,4 +1,4 @@
 int core_object(Runtime* runtime) {
-    print("object handler\n");
+    runtime->notImplemented("object");
     return 0;
 };

ecr/domain/core/object.h

@@ -1,4 +1,4 @@
 int core_open(Runtime* runtime) {
-    print("open handler\n");
+    runtime->notImplemented("open");
     return 0;
 };

ecr/domain/core/open.h

@@ -1,4 +1,4 @@
 int core_pop(Runtime* runtime) {
-    print("pop handler\n");
+    runtime->notImplemented("pop");
     return 0;
 };

ecr/domain/core/pop.h

@@ -1,4 +1,4 @@
 int core_post(Runtime* runtime) {
-    print("post handler\n");
+    runtime->notImplemented("post");
     return 0;
 };

ecr/domain/core/post.h

@@ -1,11 +1,15 @@
 int core_print(Runtime* runtime) {
     #if KEYWORDS
-    printf("Line %s: print\n", runtime->getCommand()->get(0)->getText());
+    printf("Line %s ", runtime->getLineNumber());
     #endif
 
     const char* buf = runtime->getTextValue("value");
+    if (buf == nullptr) {
+        print("No value at line %s\n", runtime->getLineNumber());
+        exit(1);
+    }
     printf("->%s\n", buf);
-    delete buf;
+    delete[] buf;
 
     return runtime->getPC() + 1;
 };

ecr/domain/core/print.h

@@ -1,4 +1,4 @@
 int core_push(Runtime* runtime) {
-    print("push handler\n");
+    runtime->notImplemented("push");
     return 0;
 };