add list type and list

Author: robertDurst

examples/test2.fish

@@ -1,12 +1,14 @@
 import foo : "foo.fish"
 import bar : "bar.fish"
 
-(fun some_function(int i)(void){
+(fun some_function([int] i)(void){
    i = i + 1
    return i
 })
 
 start {
+   dec str s = "Throw youresel"
+   dec [int] i = [1,2,3]
    f.f = f...foo() + (5 * 11 ** (4  and 6))
    z = 7
 

src/lexar/Lexar2.cpp

@@ -156,10 +156,8 @@ Lexar2::getNextToken()
                 case '|':
                     return makeToken(TokenKind::PIPE, buffer);
                 case ';':
-                case '[':
-                case ']':
                     return makeToken(TokenKind::ERROR,
-                                     "No semi-colons or brackets in Sailfish.");
+                                     "No semi-colons in Sailfish.");
 
                 // multiple states for completion
                 case '+':
@@ -195,6 +193,9 @@ Lexar2::getNextToken()
                 case '.':
                     state = State::DOUBLE_DOT;
                     break;
+                case '[':
+                    state = State::LIST;
+                    break;
                 default:
                     return makeToken(TokenKind::ERROR,
                                      "Unrecognized character.");
@@ -290,6 +291,18 @@ Lexar2::getNextToken()
             return c == '.' ? makeToken(TokenKind::TRIPLE_DOT, buffer)
                             : makeToken(TokenKind::ERROR, "Expected a dot.");
 
+        case State::LIST:
+            if (c == ']')
+            {
+                if (buffer == "[int]" || buffer == "[bool]" ||
+                    buffer == "[str]" || buffer == "[flt]")
+                    return makeToken(TokenKind::LISTTYPE, buffer);
+
+                else
+                    return makeToken(TokenKind::LIST, buffer);
+            }
+            break;
+
         default:
             return makeToken(TokenKind::ERROR, "Unexpected state.");
         }

src/lexar/Lexar2.h

@@ -39,6 +39,7 @@ class Lexar2
         DOUBLE_DOT,
         TRIPLE_DOT,
         COMMENT,
+        LIST,
         ERROR
     };
 

src/lexar/Token2.cpp

@@ -35,6 +35,8 @@ displayKind(const TokenKind& k)
         return "BOOL";
     case TokenKind::STRING:
         return "STRING";
+    case TokenKind::LIST:
+        return "LIST";
     case TokenKind::MODULO:
         return "MODULO";
     case TokenKind::ADDITION:
@@ -101,6 +103,8 @@ displayKind(const TokenKind& k)
         return "PIPE";
     case TokenKind::COLON:
         return "COLON";
+    case TokenKind::LISTTYPE:
+        return "LISTTYPE";
     case TokenKind::ERROR:
         return "ERROR";
     case TokenKind::EOF_:

src/lexar/Token2.h

@@ -27,6 +27,7 @@ enum class TokenKind
     FLOAT,
     BOOL,
     STRING,
+    LIST,
 
     // Compairsons, Arithmetic, etc.
     MODULO,
@@ -70,6 +71,7 @@ enum class TokenKind
     COLON,
 
     // Else
+    LISTTYPE,
     ERROR,
     EOF_,
 };

src/parser/Lexeme.cpp

@@ -143,6 +143,10 @@ disp(LIT o)
         return "Integer";
     case LIT::FLOAT:
         return "Float";
+    case LIT::LIST:
+        return "List";
+    case LIT::LISTTYPE:
+        return "List type";
     default:
         return "Unknown";
     }

src/parser/Lexeme.h

@@ -76,6 +76,8 @@ enum class LIT
     BOOLEAN,
     INTEGER,
     FLOAT,
+    LIST,
+    LISTTYPE,
 };
 std::string disp(LIT l);
 

src/parser/Parser2.cpp

@@ -827,11 +827,13 @@ Parser2::parsePrimary()
         return parseString();
     case TokenKind::IDENTIFIER:
         return parseIdentifier();
+    case TokenKind::LIST:
+        return parseList();
     default:
         errorhandler->handle(
             new Error2(currentToken->col, currentToken->line,
                        "Expected a valid primary token such as a boolean, "
-                       "integer, float, string, or identifier.",
+                       "integer, float, string, identifier, or list.",
                        "Received: ", currentToken->value,
                        " of type " + displayKind(currentToken->kind) + "."));
         return parseIdentifier(); //  unreachable
@@ -844,6 +846,8 @@ Parser2::parsePrimary()
 std::shared_ptr<LeafLexeme>
 Parser2::parseType()
 {
+    if (currentToken->kind == TokenKind::LISTTYPE)
+        return parseListType();
     return parseIdentifier();
 }
 
@@ -914,3 +918,25 @@ Parser2::parseString()
     advanceAndCheckToken(TokenKind::STRING); // eat string
     return makeLeaf(LIT::STRING, v);
 }
+
+/**
+ * List := lexvalue
+ */
+std::shared_ptr<LeafLexeme>
+Parser2::parseList()
+{
+    auto v = currentToken->value;
+    advanceAndCheckToken(TokenKind::LIST); // eat list
+    return makeLeaf(LIT::LIST, v);
+}
+
+/**
+ * ListType := lexvalue
+ */
+std::shared_ptr<LeafLexeme>
+Parser2::parseListType()
+{
+    auto v = currentToken->value;
+    advanceAndCheckToken(TokenKind::LISTTYPE); // eat list type
+    return makeLeaf(LIT::LISTTYPE, v);
+}

src/parser/Parser2.h

@@ -110,6 +110,8 @@ class Parser2
     std::shared_ptr<LeafLexeme> parseFloat();
     std::shared_ptr<LeafLexeme> parseString();
     std::shared_ptr<LeafLexeme> parseIdentifier();
+    std::shared_ptr<LeafLexeme> parseList();
+    std::shared_ptr<LeafLexeme> parseListType();
 
   public:
     Parser2(const std::string& filename);