Created unique stack types for types and values

Author: shaerthomas

.vscode/tasks.json

@@ -11,7 +11,7 @@
                 "-g",
                 "main.cpp",
                 "-o",
-                "${fileDirname}/${fileBasenameNoExtension}"
+                "${fileDirname}/main"
             ],
             "options": {
                 "cwd": "${fileDirname}"

linkedlist

@@ -15,8 +15,8 @@ Registering new identifiers (and values)
 
 
 
-
-
+// represents none value
+struct NoneValue {};
 
 
 

linkedlist.h

@@ -8,15 +8,13 @@
 #include "string"
 
 
-
 int main(int argc, char* argv[])
 {
 
-    runStackTests();
+    runValueStackTests();
     runLinkedListTests();
     /*
     TODO.
-    Replace LinkedList with something faster
     Make it so that you don't have to explicitly pass in a linkedlist item to Execute.
     Add scoping.
 

main

@@ -1,5 +1,4 @@
-#include "linkedlist.h"
-#include "stack.h"
+#include "symboltable.h"
 
 
 

main.cpp

@@ -0,0 +1,32 @@
+#include "linkedlist.h"
+#include "valuestack.h"
+#include "typestack.h"
+
+/*
+
+Symbol table is a stack of linked lists.
+The top node of the stack is the current scope.
+
+Enter scope.
+When entering a scope, we push new stack node containing a linkedlist onto the stack.
+
+Leave scope.
+When leaving a scope, we pop the stack.
+
+
+Referencing a variable.
+Starting from top of stack, we search each linkedlist for the id
+
+Assigning a variable.
+Starting from top of stack, we search each linkedlist for a id and update it if we find it.
+If we can't find the id, then go back to top of stack and declare variable on that (current scope basically)
+
+*/
+
+
+void runSymbolTableTests() {
+    // using storage0 = StackEmptyNode;
+    //using storage1 = StackNode<LinkedListEmptyNode>;
+    //using storageN = StackNode<3, StackNode<4, StackNode<9>>>;
+
+}

node

@@ -0,0 +1,92 @@
+#include <iostream>
+
+
+// push
+
+// pop
+
+// walk through
+
+// similar to linked list but without id + pop support
+
+
+
+//Linked list empty node type (used for matching end of linkedlist) 
+struct TypeStackEmptyNode {};
+
+//TypeStack node
+template<typename Value, typename T = TypeStackEmptyNode>
+struct TypeStackNode {};
+
+
+
+/*
+Pushing to TypeStack
+*/
+
+template<typename T, typename NewValue>
+struct TypeStackPushNode {
+    using newList = T;
+};
+
+//edge case for when trying to add to a empty
+template<typename NewValue>
+struct TypeStackPushNode<TypeStackEmptyNode, NewValue> {
+    using newList  = TypeStackNode<NewValue>;
+};
+
+
+template<template <typename, typename> typename A, typename OldValue, typename T, typename NewValue>
+struct TypeStackPushNode<A<OldValue, T>, NewValue> {
+    using newList  = TypeStackNode<NewValue, A<OldValue, T>>;
+};
+
+/*
+Pop node
+*/
+
+template<typename T>
+struct TypeStackPopNode {
+    using newList = T;
+};
+
+// //edge case for when trying to add to a empty
+template<>
+struct TypeStackPopNode<TypeStackEmptyNode> {
+    using newList  = TypeStackEmptyNode;
+};
+
+
+template<template <typename, typename> typename A, typename OldValue, typename T>
+struct TypeStackPopNode<A<OldValue, T>> {
+    using newList  = T;
+};
+
+
+void runTypeStackTests() {
+    using storage0 = TypeStackEmptyNode;
+    using storage1 = TypeStackNode<int>;
+    using storageN = TypeStackNode<int, TypeStackNode<float, TypeStackNode<double>>>;
+
+    // push tests
+
+    //0 cases
+    static_assert(std::is_same_v<TypeStackNode<int>, TypeStackPushNode<storage0, int>::newList>);
+
+    // //1 cases
+    static_assert(std::is_same_v<TypeStackNode<float, TypeStackNode<int>>, TypeStackPushNode<storage1, float>::newList>); 
+
+    // //n cases
+    static_assert(std::is_same_v<TypeStackNode<std::string, TypeStackNode<int, TypeStackNode<float, TypeStackNode<double>>>>, TypeStackPushNode<storageN, std::string>::newList>); 
+
+    // // pop tests
+
+    // //0 cases
+    static_assert(std::is_same_v<TypeStackEmptyNode, TypeStackPopNode<storage0>::newList>);
+
+    //  //1 cases
+    static_assert(std::is_same_v<TypeStackEmptyNode, TypeStackPopNode<storage1>::newList>); 
+
+    // //n cases
+    static_assert(std::is_same_v<TypeStackNode<float, TypeStackNode<double>>, TypeStackPopNode<storageN>::newList>); 
+}

node.h

@@ -0,0 +1,89 @@
+// push
+
+// pop
+
+// walk through
+
+// similar to linked list but without id + pop support
+
+
+
+//Linked list empty node type (used for matching end of linkedlist) 
+struct ValueStackEmptyNode {};
+
+//ValueStack node
+template<auto Value, typename T = ValueStackEmptyNode>
+struct ValueStackNode {};
+
+
+
+/*
+Pushing to ValueStack
+*/
+
+template<typename T, auto NewValue>
+struct ValueStackPushNode {
+    using newList = T;
+};
+
+//edge case for when trying to add to a empty
+template<auto NewValue>
+struct ValueStackPushNode<ValueStackEmptyNode, NewValue> {
+    using newList  = ValueStackNode<NewValue>;
+};
+
+
+template<template <auto, typename> typename A, auto OldValue, typename T, auto NewValue>
+struct ValueStackPushNode<A<OldValue, T>, NewValue> {
+    using newList  = ValueStackNode<NewValue, A<OldValue, T>>;
+};
+
+/*
+Pop node
+*/
+
+template<typename T>
+struct ValueStackPopNode {
+    using newList = T;
+};
+
+//edge case for when trying to add to a empty
+template<>
+struct ValueStackPopNode<ValueStackEmptyNode> {
+    using newList  = ValueStackEmptyNode;
+};
+
+
+template<template <auto, typename> typename A, auto OldValue, typename T>
+struct ValueStackPopNode<A<OldValue, T>> {
+    using newList  = T;
+};
+
+
+void runValueStackTests() {
+    using storage0 = ValueStackEmptyNode;
+    using storage1 = ValueStackNode<3>;
+    using storageN = ValueStackNode<3, ValueStackNode<4, ValueStackNode<9>>>;
+
+    // push tests
+
+    //0 cases
+     static_assert(std::is_same_v<ValueStackNode<40>, ValueStackPushNode<storage0, 40>::newList>);
+
+    // //1 cases
+     static_assert(std::is_same_v<ValueStackNode<4, ValueStackNode<3>>, ValueStackPushNode<storage1, 4>::newList>); 
+
+    // //n cases
+    static_assert(std::is_same_v<ValueStackNode<12, ValueStackNode<3, ValueStackNode<4, ValueStackNode<9>>>>, ValueStackPushNode<storageN, 12>::newList>); 
+
+    // // pop tests
+
+    // //0 cases
+     static_assert(std::is_same_v<ValueStackEmptyNode, ValueStackPopNode<storage0>::newList>);
+
+    //  //1 cases
+    static_assert(std::is_same_v<ValueStackEmptyNode, ValueStackPopNode<storage1>::newList>); 
+
+    // //n cases
+    static_assert(std::is_same_v<ValueStackNode<4, ValueStackNode<9>>, ValueStackPopNode<storageN>::newList>); 
+}