Indexing support

source/parsing/tokenizer/make_tokens.d

@@ -8,7 +8,6 @@ import tern.typecons.common : Nullable, nullable;
 
 import parsing.tokenizer.tokens;
 
-import std.stdio;
 
 dchar[] handleMultilineCommentsAtIndex(dchar[] input, ref size_t index)
 {

source/parsing/tokenizer/tokens.d

@@ -57,7 +57,6 @@ dchar[] makeUnicodeString(in string input)
 
 const(dchar[]) testMultiLineStyle(dchar first, dchar secound)
 {
-    // validMultiLineCommentStyles.writeln;
     foreach (const(dchar[][]) style; validMultiLineCommentStyles)
     {
         if (style[0][0] == first && style[0][1] == secound)
@@ -153,13 +152,8 @@ Nullable!Token nextToken(Token[] tokens, ref size_t index)
 {
     Nullable!Token found = null;
     if (tokens.length <= index + 1)
-    {
-        import std.stdio;
-
-        "boinc".writeln;
-        found.ptr.writeln;
         return found;
-    }
+
 
     found = tokens[++index];
     return found;

source/parsing/treegen/astTypes.d

@@ -14,6 +14,7 @@ enum AstAction
     DefineFunction,
     DefineVariable, // Ex: int x;
     AssignVariable, // Ex: x = 5;
+    IndexInto, // X[...]
 
     SingleArgumentOperation, // Ex: x++, ++x, |x|, ||x||, -8
     DoubleArgumentOperation, // Ex: 9+10 
@@ -27,6 +28,12 @@ enum AstAction
     TokenHolder // A temporary Node that is yet to be parsed 
 }
 
+bool isExpressionLike(AstAction action)
+{
+    return action == AstAction.Expression
+        || action == AstAction.IndexInto;
+}
+
 struct KeywordNodeData
 {
     dchar[] keywordName;
@@ -60,8 +67,8 @@ enum OperationVariety
     PostIncrement,
     PreDecrement,
     PostDecrement,
-    AbsuluteValue,
-    Magnitude,
+    // AbsuluteValue,
+    // Magnitude,
 
     Add,
     Substract,
@@ -93,6 +100,11 @@ enum OperationVariety
     BitshiftLeftUnSigned,
     BitshiftRightUnSigned,
 
+    BitshiftLeftSignedEq,
+    BitshiftRightSignedEq,
+    BitshiftLeftUnSignedEq,
+    BitshiftRightUnSignedEq,
+
     LogicalOr,
     LogicalAnd,
     LogicalNot,
@@ -198,8 +210,12 @@ class AstNode
         import std.stdio;
         import std.conv;
 
-        foreach (i; 0 .. tabCount)
-            write("|  ");
+        if (tabCount != -1)
+        {
+            foreach (i; 0 .. tabCount)
+                write("|  ");
+            write("┼ ");
+        }
 
         switch (action)
         {
@@ -212,6 +228,17 @@ class AstNode
             doubleArgumentOperationNodeData.left.tree(tabCount + 1);
             doubleArgumentOperationNodeData.right.tree(tabCount + 1);
             break;
+        case AstAction.SingleArgumentOperation:
+            writeln(singleArgumentOperationNodeData.operationVariety.to!string ~ ":");
+            singleArgumentOperationNodeData.value.tree(tabCount + 1);
+            break;
+        case AstAction.IndexInto:
+            writeln("Indexing into with result of:");
+            foreach (subnode; expressionNodeData.components)
+            {
+                subnode.tree(tabCount + 1);
+            }
+            break;
         case AstAction.Expression:
             writeln(
                 "Result of expression with " ~ expressionNodeData.components.length.to!string ~ " components:");

source/parsing/treegen/expressionParser.d

@@ -10,7 +10,7 @@ import std.stdio;
 import std.container.array;
 
 // Group letters.letters.letters into NamedUnit s
-// Group Parenthesis into AstNode.Expression s to be parsed speratly
+// Group Parenthesis and indexing into AstNode.Expression s to be parsed speratly
 public AstNode[] phaseOne(Token[] tokens)
 {
     AstNode[] ret;
@@ -22,7 +22,10 @@ public AstNode[] phaseOne(Token[] tokens)
         if (token.tokenVariety == TokenType.OpenBraces)
         {
             AstNode newExpression = new AstNode();
-            newExpression.action = AstAction.Expression;
+            if (token.value == "(" || token.value == "{")
+                newExpression.action = AstAction.Expression;
+            else if (token.value == "[")
+                newExpression.action = AstAction.IndexInto;
             newExpression.expressionNodeData = ExpressionNodeData(
                 token.value[0],
                 braceOpenToBraceClose[token.value[0]],
@@ -35,12 +38,12 @@ public AstNode[] phaseOne(Token[] tokens)
         {
 
             if (parenthesisStack.length == 0)
-                throw new SyntaxError("Parenthesis closed but never opened");
+                throw new SyntaxError("Group token("~cast(char)token.value[0]~") closed but never opened");
 
             AstNode node = parenthesisStack[$ - 1];
 
             if (node.expressionNodeData.closer != token.value[0])
-                throw new SyntaxError("Parenthesis not closed with correct token");
+                throw new SyntaxError("Group token("~cast(char)token.value[0]~") not closed with correct token");
 
             parenthesisStack.length--;
 
@@ -89,8 +92,7 @@ public void phaseTwo(Array!AstNode nodes)
     for (size_t index = 0; index < nodes.length; index++)
     {
         AstNode node = nodes[index];
-        if (node.action == AstAction.NamedUnit && index + 1 < nodes.length && nodes[index + 1].action == AstAction
-            .Expression)
+        if (node.action == AstAction.NamedUnit && index + 1 < nodes.length && nodes[index + 1].action.isExpressionLike)
         {
             AstNode functionCall = new AstNode();
             AstNode args = nodes[index + 1];
@@ -110,7 +112,7 @@ public void phaseTwo(Array!AstNode nodes)
             nodes[index] = functionCall;
             nodes.linearRemove(nodes[index + 1 .. index + 2]);
         }
-        else if (node.action == AstAction.Expression)
+        else if (node.action.isExpressionLike)
         {
             Array!AstNode components;
             components ~= node.expressionNodeData.components;