rewritten tokenizer, unit tests for tokenizer

src/me/hammerle/snuviscript/SnuviScript.java

@@ -6,7 +6,6 @@ public class SnuviScript
 {
     public static void main(String[] args)
     {
-        //Test.test();
+        Test.test();
-        Test.testNew();
     }  
 }

src/me/hammerle/snuviscript/code/Compiler.java

@@ -118,6 +118,7 @@ public class Compiler
                     {
                         comment = false;
                         sb.delete(old, pos + 2);
+                        pos = old - 1;
                     }
                     pos++;
                     continue;

src/me/hammerle/snuviscript/compiler/Compiler.java

@@ -47,17 +47,21 @@ public class Compiler
         return tokens[index];
     }
     
-    private void consumeTokenAndCheck(TokenType type)
+    private void consumeTokenAndCheck(TokenType... type)
     {
         Token t = consumeToken();
         if(t == null)
         {
-            throw new PreScriptException("missing token at end of file", -1);
+            throw new PreScriptException("missing token at end of file " + type, -1);
         }
-        if(t.getType() != type)
+        for(TokenType ty : type)
         {
-            throw new PreScriptException("unexpected token " + t, t.getLine());
+            if(ty == t.getType())
+            {
+                return;
+            }
         }
+        throw new PreScriptException("unexpected token " + t, t.getLine());
     }
     
     private void checkFunctionArguments()
@@ -166,21 +170,23 @@ public class Compiler
                     checkLine();
                     consumeTokenAndCheck(TokenType.CLOSE_CURVED_BRACKET);
                     break;
-                case DOLLAR:
+                /*case DOLLAR:
                     checkVariable();
                     checkVariableOperation(true);
                     consumeTokenAndCheck(TokenType.SEMICOLON);
-                    break;
+                    break;*/
                 case LABEL:
-                    consumeTokenAndCheck(TokenType.LITERAL);
+                    consumeTokenAndCheck(TokenType.LITERAL, TokenType.NUMBER);
                     break;
                 case SEMICOLON:
                     break;
                 case INC:
-                    checkVariable();
-                    consumeTokenAndCheck(TokenType.SEMICOLON);
-                    break;
                 case DEC:
+                    Token token = peekToken();
+                    //if(token.getType() == TokenType.DOLLAR)
+                    {
+                        consumeToken();
+                    }
                     checkVariable();
                     consumeTokenAndCheck(TokenType.SEMICOLON);
                     break;
@@ -275,6 +281,10 @@ public class Compiler
                 {
                     throw new PreScriptException("unexpected token " + t, t.getLine());
                 }
+                else
+                {
+                    checkCalc();
+                }
         }
     }
     
@@ -351,15 +361,20 @@ public class Compiler
                 consumeTokenAndCheck(TokenType.CLOSE_BRACKET);
                 checkCalc();
                 break;
-            case DOLLAR:
+            /*case DOLLAR:
                 checkVariable();
                 checkVariableOperation(false);
-                break;
+                break;*/
             case LABEL:
                 consumeTokenAndCheck(TokenType.LITERAL);
                 break;
             case INC:
             case DEC:
+                Token token = peekToken();
+                //if(token.getType() == TokenType.DOLLAR)
+                {
+                    consumeToken();
+                }
                 checkVariable();
                 checkCalc();
                 break;

src/me/hammerle/snuviscript/test/Test.java

@@ -3,10 +3,10 @@ package me.hammerle.snuviscript.test;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
+import java.util.function.BiConsumer;
 import me.hammerle.snuviscript.code.SnuviParser;
 import me.hammerle.snuviscript.token.Tokenizer;
-import me.hammerle.snuviscript.compiler.Compiler;
+import me.hammerle.snuviscript.token.Token;
-import me.hammerle.snuviscript.exceptions.PreScriptException;
 
 public class Test
 {
@@ -14,99 +14,89 @@ public class Test
     private static final TestLogger LOGGER = new TestLogger();
     private static final SnuviParser PARSER = new SnuviParser(LOGGER, SCHEDULER);
     private static int done = 0;
-    private static int tests = 0;    
+    private static int tests = 0;  
     
     public static void test()
     {
-        //genTests(5, 15, "functions");
+        testTokenizer();
-        findTestFiles(new File("./test"));
+        testOutput();
-        System.out.println(String.format("%d / %d tests succeeded", done, tests));
     }
     
-    public static void testNew()
+    private static void testOutput()
     {
-        findTestFilesNew(new File("./test"));
+        done = 0;
-    }
+        tests = 0;  
-    
+        forEachFile(new File("./test"), ".out", (inFile, checkFile) -> 
-    private static void genTests(int from, int to, String name)
-    {
-        for(int i = from; i < to; i++)
         {
-            try
+            tests++;
-            {
-                File f = new File(String.format("./test/%s/%s%d", name, name, i));
-                f.createNewFile();
                 
-                f = new File(String.format("./test/%s/%s%d.out", name, name, i));
+            LOGGER.reset();
-                f.createNewFile();
+            PARSER.startScript(true, "", inFile.getPath());
-            }
+
-            catch(Exception ex)
+            if(LOGGER.check(checkFile))
             {
+                done++;
             }
-        }
+        });
+        System.out.println(String.format("%d / %d output tests succeeded", done, tests));
     }
     
-    private static void findTestFiles(File f)
+    private static void testTokenizer()
     {
-        if(f.isFile())
+        done = 0;
+        tests = 0; 
+        forEachFile(new File("./test"), ".tout", (inFile, checkFile) -> 
         {
-            if(!f.getName().endsWith(".out"))
+            try
             {
-                tests++;
+                try(FileInputStream in = new FileInputStream(inFile))
-                
-                LOGGER.reset();
-                PARSER.startScript(true, "", f.getPath());
-                
-                if(LOGGER.check(new File(f.getPath() + ".out")))
                 {
-                    done++;
+                    tests++; 
+                    Tokenizer tokenizer = new Tokenizer();
+                    LOGGER.reset();
+                    for(Token t : tokenizer.tokenize(in))
+                    {
+                        LOGGER.print(t.toString(), null, null, null, null, -1);
+                    }
+                    if(LOGGER.check(checkFile))
+                    {
+                        done++;
+                    }
                 }
             }
-        }
+            catch(Exception ex)
-        else if(f.isDirectory())
-        {
-            for(File fi : f.listFiles())
             {
-                findTestFiles(fi);
+                ex.printStackTrace();
             }
-        }
+        });
+        System.out.println(String.format("%d / %d tokenizer tests succeeded", done, tests));
     }
     
-    private static void findTestFilesNew(File f)
+    private static void forEachFile(File f, String ending, BiConsumer<File, File> bc)
     {
         if(f.isFile())
         {
-            if(!f.getName().endsWith(".out"))
+            if(!f.getName().contains("."))
             {
-                System.out.println("_________________________________________________");
+                File checkFile = new File(f.getPath() + ending);
-                System.out.println(String.format("Tokenize \"%s\"", f.getPath()));
+                if(!checkFile.exists())
-                try
                 {
-                    try(FileInputStream in = new FileInputStream(f))
+                    try
+                    {
+                        checkFile.createNewFile();
+                    }
+                    catch(IOException ex)
                     {
-                        Tokenizer tokenizer = new Tokenizer();
-                        Compiler c = new Compiler();
-                        c.checkSyntax(tokenizer.tokenize(in));
                     }
                 }
-                catch(IOException ex)
+                bc.accept(f, checkFile);
-                {
-                    ex.printStackTrace();
-                }
-                catch(PreScriptException ex)
-                {
-                    //ex.printStackTrace();
-                    System.out.println(ex.getMessage());
-                    System.out.println(ex.getStartLine());
-                    System.out.println(ex.getEndLine());
-                }
             }
         }
         else if(f.isDirectory())
         {
             for(File fi : f.listFiles())
             {
-                findTestFilesNew(fi);
+                forEachFile(fi, ending, bc);
             }
         }
     }

src/me/hammerle/snuviscript/token/DataToken.java

@@ -15,10 +15,4 @@ public class DataToken extends Token
     {
         return value;
     }
-
-    @Override
-    public String toString()
-    {
-        return String.valueOf(value);
-    }
 }

src/me/hammerle/snuviscript/token/StreamCharReader.java

@@ -0,0 +1,68 @@
+package me.hammerle.snuviscript.token;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+public class StreamCharReader
+{
+    private final InputStream in;
+    private int buffer = -1;
+    
+    public StreamCharReader(InputStream in)
+    {
+        this.in = in;
+    }
+    
+    public int peekChar()
+    {
+        if(buffer == -1)
+        {
+            buffer = readChar();
+            return buffer;
+        }
+        return buffer;
+    }
+    
+    public int readChar()
+    {
+        if(buffer != -1)
+        {
+            int r = buffer;
+            buffer = -1;
+            return r;
+        }
+        try
+        {
+            if(in.available() <= 0)
+            {
+                return -1;
+            }
+            int data = in.read();
+            if((data & 0x80) != 0) // special char
+            {
+                if((data & 0x40) != 0) // this should always be true
+                {
+                    if((data & 0x20) != 0) // 3 byte unicode
+                    {
+                        int a = in.read();
+                        int b = in.read();
+                        data = ((data & 0xF) << 12) | ((a & 0x3F) << 6) | (b & 0x3F);
+                    }
+                    else // 2 byte unicode
+                    {
+                        data = ((data & 0x1F) << 6) | (in.read() & 0x3F);
+                    }
+                }
+                else
+                {
+                    // should not happen as unicode starts with 11
+                }
+            }
+            return data;
+        }
+        catch(IOException ex)
+        {
+            return -1;
+        }
+    }
+}

src/me/hammerle/snuviscript/token/Token.java

@@ -29,6 +29,28 @@ public class Token
     @Override
     public String toString()
     {
-        return type.getName();
+        StringBuilder sb = new StringBuilder();
+        
+        sb.append("(");
+        sb.append(line);
+        sb.append(", ");
+        sb.append(type);
+        if(getData() != null)
+        {
+            sb.append(", ");
+            if(getData() instanceof String)
+            {
+                sb.append('"');
+                sb.append(getData());
+                sb.append('"');
+            }
+            else
+            {
+                sb.append(getData());
+            }
+        }
+        sb.append(")");
+        
+        return sb.toString();
     }
 }

src/me/hammerle/snuviscript/token/TokenType.java

@@ -2,124 +2,27 @@ package me.hammerle.snuviscript.token;
 
 public enum TokenType
 {
-    UNKNOWN(""),
+    NUMBER, STRING, LITERAL, LABEL, TRUE, FALSE, NULL,
-    NUMBER("number"),
-    STRING("string"),
-    LITERAL("literal"),
     
-    OPEN_BRACKET("("),
+    OPEN_BRACKET, CLOSE_BRACKET, 
-    CLOSE_BRACKET(")"),
+    OPEN_SQUARE_BRACKET, CLOSE_SQUARE_BRACKET, 
-    OPEN_SQUARE_BRACKET("["),
+    OPEN_CURVED_BRACKET, CLOSE_CURVED_BRACKET, 
-    CLOSE_SQUARE_BRACKET("]"),
-    OPEN_CURVED_BRACKET("{"),
-    CLOSE_CURVED_BRACKET("}"),
     
-    DOLLAR("$"),
+    SEMICOLON, COMMA, 
-    LABEL("@"),
     
-    ONE_LINE_COMMENT("//"),
+    INC, DEC, 
-    COMMENT("/*"),
     
-    SEMICOLON(";"),
+    INVERT, BIT_INVERT, 
-    COMMA(","),
+    
-    INC("++"),
+    MUL, DIV, MOD, ADD, SUB, 
-    DEC("--"),
+    ADD_SET, SUB_SET, MUL_SET, DIV_SET, MOD_SET, 
-    INVERT("!"),
+    
-    BIT_INVERT("~"),
+    LEFT_SHIFT, RIGHT_SHIFT, 
-    MUL("*"),
+    LEFT_SHIFT_SET, RIGHT_SHIFT_SET, BIT_AND_SET, BIT_XOR_SET, BIT_OR_SET,
-    DIV("/"),
-    MOD("%"),
-    ADD("+"),
-    SUB("-"),
-    LEFT_SHIFT("<<"),
-    RIGHT_SHIFT(">>"),
-    LESS("<"),
-    LESS_EQUAL("<="),
-    GREATER(">"),
-    GREATER_EQUAL(">="),
-    EQUAL("=="),
-    NOT_EQUAL("!="),
-    BIT_AND("&"),
-    BIT_XOR("^"),
-    BIT_OR("|"),
-    AND("&&"),
-    OR("||"),
-    SET("="),
-    ADD_SET("+="),
-    SUB_SET("-="),
-    MUL_SET("*="),
-    DIV_SET("/="),
-    MOD_SET("%="),
-    LEFT_SHIFT_SET("<<="),
-    RIGHT_SHIFT_SET(">>="),
-    BIT_AND_SET("&="),
-    BIT_XOR_SET("^="),
-    BIT_OR_SET("|=");
-        
-    private final String name;
-
-    private TokenType(String name)
-    {
-        this.name = name;
-    }   
-
-    public String getName() 
-    {
-        return name;
-    }
     
-    public int getLength()
+    LESS, LESS_EQUAL, GREATER, GREATER_EQUAL, EQUAL, NOT_EQUAL, 
-    {
+    BIT_AND, BIT_XOR, BIT_OR, 
-        return name.length();
+    AND, OR, SET,
-    }
     
-    public static TokenType getMatching(char c1, char c2, char c3)
+    IF, ELSE, ELSEIF, WHILE, TRY, CATCH, FOR, FUNCTION, BREAK, CONTINUE, RETURN
-    {
+}
-        switch(c1)
-        {
-            case '(': return OPEN_BRACKET;
-            case ')': return CLOSE_BRACKET;
-            case '[': return OPEN_SQUARE_BRACKET;
-            case ']': return CLOSE_SQUARE_BRACKET;
-            case '{': return OPEN_CURVED_BRACKET;
-            case '}': return CLOSE_CURVED_BRACKET;
-            case '$': return DOLLAR;
-            case '@': return LABEL;
-            case ';': return SEMICOLON;
-            case ',': return COMMA;
-            case '~': return BIT_INVERT;
-            case '+': return c2 == '=' ? ADD_SET : (c2 == '+' ? INC : ADD);
-            case '-': return c2 == '=' ? SUB_SET : (c2 == '-' ? DEC : SUB);
-            case '!': return c2 == '=' ? NOT_EQUAL : INVERT;
-            case '=': return c2 == '=' ? EQUAL : SET;
-            case '*': return c2 == '=' ? MUL_SET : MUL;
-            case '/': 
-                switch(c2)
-                {
-                    case '/': return ONE_LINE_COMMENT;
-                    case '*': return COMMENT;
-                    case '=': return DIV_SET;
-                }
-                return DIV;
-            case '%': return c2 == '=' ? MOD_SET : MOD;
-            case '&': return c2 == '=' ? BIT_AND_SET : (c2 == '&' ? AND : BIT_AND);
-            case '|': return c2 == '=' ? BIT_OR_SET : (c2 == '|' ? OR : BIT_OR);
-            case '^': return c2 == '=' ? BIT_XOR_SET : BIT_XOR;
-            case '<': 
-                switch(c2)
-                {
-                    case '<': return c3 == '=' ? LEFT_SHIFT_SET : LEFT_SHIFT;
-                    case '=': return LESS_EQUAL;
-                }
-                return LESS;
-            case '>': 
-                switch(c2)
-                {
-                    case '>': return c3 == '=' ? RIGHT_SHIFT_SET : RIGHT_SHIFT;
-                    case '=': return GREATER_EQUAL;
-                }
-                return GREATER;    
-        }
-        return UNKNOWN;
-    }
-}

src/me/hammerle/snuviscript/token/Tokenizer.java

@@ -1,182 +1,264 @@
 package me.hammerle.snuviscript.token;
 
-import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import me.hammerle.snuviscript.exceptions.PreScriptException;
+import static me.hammerle.snuviscript.token.TokenType.*;
 
 public class Tokenizer
 {
+    private StreamCharReader stream = null;
     private final ArrayList<Token> tokens = new ArrayList<>();
-    private String code = "";
-    private int index = 0;
-    private int old = 0;
     private int line = 1;
     
-    private boolean isLiteralCharacter(char c)
+    private int next()
     {
-        return Character.isLetterOrDigit(c) || c == '_' || c == '.';
+        return stream.readChar();
     }
     
-    private char charAt(int index)
+    private int peek()
     {
-        if(index < 0 || index >= code.length())
+        return stream.peekChar();
+    }
+    
+    private boolean next(char c)
+    {
+        if(peek() == c)
         {
-            return ' ';
+            next();
+            return true;
         }
-        return code.charAt(index);
+        return false;
+    }
+    
+    private void add(TokenType type)
+    {
+        tokens.add(new Token(type, line));
+    }
+    
+    private void add(TokenType type, Object data)
+    {
+        tokens.add(new DataToken(type, line, data));
     }
     
-    private void add(int from, int to)
+    private void add(char c, TokenType t1, TokenType t2, TokenType t3, TokenType t4)
     {
-        String part = code.substring(from, to);
+        int peek = peek();
-        try
+        if(peek == c)
+        {
+            next();
+            if(peek() == '=')
+            {
+                next();
+                add(t1);
+            }
+            else
+            {
+                add(t2);
+            }
+        }
+        else if(peek == '=')
         {
-            double d = Double.parseDouble(part);
+            next();
-            tokens.add(new DataToken(TokenType.NUMBER, line, d));
+            add(t3);
         }
-        catch(NumberFormatException ex)
+        else
         {
-            tokens.add(new DataToken(TokenType.LITERAL, line, part));
+            add(t4);
         }
     }
     
-    private void addIfNotEmpty(int from, int to)
+    public Token[] tokenize(InputStream in)
     {
-        if(to - from <= 0)
+        stream = new StreamCharReader(in);
+        tokens.clear();
+        line = 1;
+        int c;
+        while((c = Tokenizer.this.next()) != -1)
         {
-            return;
+            handleChar(c);
         }
-        add(from, to);
+        return tokens.toArray(new Token[tokens.size()]);
     }
     
-    private void skipOneLineComment()
+    private void handleChar(int c)
     {
-        while(index < code.length() && code.charAt(index) != '\n')
+        if(Character.isLetter(c) || c == '_')
+        {
+            handleLiteral(c, TokenType.LITERAL);
+        }
+        else if(Character.isDigit(c))
         {
-            index++;
+            handleNumber(c);
+        }
+        else
+        {
+            handleSpecial(c);
         }
-        line++;
-        old = index + 1;
     }
     
-    private void skipComment()
+    private void handleLiteral(int c, TokenType type)
     {
-        while(index < code.length())
+        StringBuilder sb = new StringBuilder();
+        sb.append((char) c);
+        
+        while(true)
         {
-            if(code.charAt(index) == '\n')
+            int data = peek();
-            {
+            if(!Character.isLetterOrDigit(data) && data != '_')
-                line++;
-            }
-            else if(code.charAt(index) == '*' && charAt(index + 1) == '/')
             {
                 break;
             }
-            index++;
+            sb.append((char) data);
+            next();
         }
-        old = index + 2;
+        
-        index++;
+        String s = sb.toString();
+        switch(s)
+        {
+            case "if": add(IF); break;
+            case "else": add(ELSE); break;
+            case "elseif": add(ELSEIF); break;
+            case "while": add(WHILE); break;
+            case "try": add(TRY); break;
+            case "catch": add(CATCH); break;
+            case "for": add(FOR); break;
+            case "function": add(FUNCTION); break;
+            case "break": add(BREAK); break;
+            case "continue": add(CONTINUE); break;
+            case "return": add(RETURN); break;
+            case "true": add(TRUE); break;
+            case "false": add(FALSE); break;
+            case "null": add(NULL); break;
+            default: add(type, s);
+        }
+        
     }
     
-    private void handleString()
+    private void handleNumber(int c)
     {
-        addIfNotEmpty(old, index);
+        StringBuilder sb = new StringBuilder();
-        old = index + 1;
+        sb.append((char) c);
-        index++;
+        
-        while(index < code.length() && code.charAt(index) != '"')
+        while(true)
         {
-            if(code.charAt(index) == '\n')
+            int data = peek();
+            if(!Character.isLetterOrDigit(data) && data != '.')
             {
-                line++;
+                break;
             }
-            index++;
+            next();
+            sb.append((char) data);
         }
-        add(old, index);
+        
-        old = index + 1;
+        add(NUMBER, Double.parseDouble(sb.toString()));
     }
     
-    private void handleNewLine()
+    private void handleSpecial(int c)
     {
-        addIfNotEmpty(old, index);
+        switch(c)
-        old = index + 1;
+        {
-        line++;
+            case ' ':
+            case '\t':
+            case '\r': break;
+            case '\n': line++; break;
+            case '"': handleString(); break;
+            case '(': add(OPEN_BRACKET); break;
+            case ')': add(CLOSE_BRACKET); break;
+            case '[': add(OPEN_SQUARE_BRACKET); break;
+            case ']': add(CLOSE_SQUARE_BRACKET); break;
+            case '{': add(OPEN_CURVED_BRACKET); break;
+            case '}': add(CLOSE_CURVED_BRACKET); break;
+            case '$': handleLiteral(c, LITERAL); break;
+            case '@': handleLiteral(c, LABEL); break;
+            case ';': add(SEMICOLON); break;
+            case ',': add(COMMA); break;
+            case '~': add(BIT_INVERT); break;
+            case '+': add(next('=') ? ADD_SET : (next('+') ? INC : ADD)); break;
+            case '-': add(next('=') ? SUB_SET : (next('-') ? DEC : SUB)); break;
+            case '!': add(next('=') ? NOT_EQUAL : INVERT); break;
+            case '=': add(next('=') ? EQUAL : SET); break;
+            case '*': add(next('=') ? MUL_SET : MUL); break;
+            case '/': handleSlash(); break;
+            case '%': add(next('=') ? MOD_SET : MOD); break;
+            case '&': add(next('=') ? BIT_AND_SET : (next('&') ? AND : BIT_AND)); break; 
+            case '|': add(next('=') ? BIT_OR_SET : (next('|') ? OR : BIT_OR)); break;
+            case '^': add(next('=') ? BIT_XOR_SET : BIT_XOR); break;
+            case '<': add('<', LEFT_SHIFT_SET, LEFT_SHIFT, LESS_EQUAL, LESS); break;
+            case '>': add('>', RIGHT_SHIFT_SET, RIGHT_SHIFT, GREATER_EQUAL, GREATER); break;
+            default: throw new PreScriptException("unknown token " + c, line);
+        }
     }
     
-    private void handleSpace()
+    private void handleString()
     {
-        addIfNotEmpty(old, index);
+        StringBuilder sb = new StringBuilder();
-        old = index + 1;
+        while(true)
+        {
+            int data = next();
+            if(data == '"')
+            {
+                add(STRING, sb.toString());
+                break;
+            }
+            if(data == '\n')
+            {
+                line++;
+            }
+            sb.append((char) data);
+        }
     }
     
-    private void handleSpecialCharacter()
+    private void handleSlash()
     {
-        addIfNotEmpty(old, index);
+        switch(peek())
-
-        TokenType type = TokenType.getMatching(code.charAt(index), charAt(index + 1), charAt(index + 2));
-        switch(type)
         {
-            case UNKNOWN: throw new PreScriptException("unknown token", line);
+            case '/': 
-            case ONE_LINE_COMMENT: 
+                next();
-                skipOneLineComment(); 
+                handleOneLineComment();
                 break;
-            case COMMENT: 
+            case '*': 
-                skipComment(); 
+                next();
+                handleMultiLineComment();
+                break;
+            case '=': 
+                next();
+                add(DIV_SET);
                 break;
             default:
-                tokens.add(new Token(type, line));
+                add(DIV);
-                old = index + type.getLength();
-                index = old - 1;
         }
     }
     
-    public Token[] tokenize(InputStream in)
+    private void handleOneLineComment()
     {
-        code = readStream(in);
+        while(true)
-        index = 0;
-        old = 0;
-        tokens.clear();
-        
-        for(; index < code.length(); index++)
         {
-            char c = code.charAt(index);
+            int data = next();
-            if(isLiteralCharacter(c))
+            if(data == -1 || data == '\n')
             {
-                continue;
+                line++;
-            }
+                break;
-            switch(c)
-            {
-                case '\n': handleNewLine(); break;
-                case '"': handleString(); break;
-                case '\t':
-                case ' ': handleSpace(); break;
-                default: handleSpecialCharacter();
             }
         }
-        return tokens.toArray(new Token[tokens.size()]);
     }
     
-    private String readStream(InputStream in)
+    private void handleMultiLineComment()
     {
-        try
+        int first;
+        int sec = -1;
+        while(true)
         {
-            int bufferSize = in.available();
+            first = sec;
-            StringBuilder sb = new StringBuilder(bufferSize);
+            sec = next();
-            
+            if(sec == -1 || (first == '*' && sec == '/'))
-            while(in.available() > 0)
             {
-                int data = in.read();
+                break;
-                if((data & 0x80) != 0)
+            }
-                {
+            if(sec == '\n')
-                    data = ((data & 0x1F) << 6) | (in.read() & 0x3F);
+            {
-                }
+                line++;
-                sb.append((char) data);
             }
-            
-            return sb.toString();
-        }
-        catch(IOException ex)
-        {
-            throw new PreScriptException("cannot read stream - " + ex.getMessage(), -1);
         }
     }
 }

test/calc/base.tout

@@ -0,0 +1,94 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, NUMBER, 1.0)
+(1, ADD)
+(1, NUMBER, 1.0)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, NUMBER, 1.0)
+(2, ADD)
+(2, SUB)
+(2, NUMBER, 3.0)
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, NUMBER, 1.0)
+(4, SUB)
+(4, NUMBER, 3.0)
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, NUMBER, 1.0)
+(5, SUB)
+(5, SUB)
+(5, NUMBER, 3.0)
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, NUMBER, 4.0)
+(7, MUL)
+(7, NUMBER, 3.0)
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, LITERAL, "print")
+(8, OPEN_BRACKET)
+(8, NUMBER, 6.0)
+(8, MUL)
+(8, SUB)
+(8, NUMBER, 3.0)
+(8, CLOSE_BRACKET)
+(8, SEMICOLON)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, SUB)
+(9, NUMBER, 6.0)
+(9, MUL)
+(9, NUMBER, 4.0)
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(10, LITERAL, "print")
+(10, OPEN_BRACKET)
+(10, SUB)
+(10, NUMBER, 6.0)
+(10, MUL)
+(10, SUB)
+(10, NUMBER, 4.0)
+(10, CLOSE_BRACKET)
+(10, SEMICOLON)
+(12, LITERAL, "print")
+(12, OPEN_BRACKET)
+(12, NUMBER, 4.0)
+(12, DIV)
+(12, NUMBER, 2.0)
+(12, CLOSE_BRACKET)
+(12, SEMICOLON)
+(13, LITERAL, "print")
+(13, OPEN_BRACKET)
+(13, NUMBER, 6.0)
+(13, DIV)
+(13, SUB)
+(13, NUMBER, 2.0)
+(13, CLOSE_BRACKET)
+(13, SEMICOLON)
+(14, LITERAL, "print")
+(14, OPEN_BRACKET)
+(14, SUB)
+(14, NUMBER, 6.0)
+(14, DIV)
+(14, NUMBER, 3.0)
+(14, CLOSE_BRACKET)
+(14, SEMICOLON)
+(15, LITERAL, "print")
+(15, OPEN_BRACKET)
+(15, SUB)
+(15, NUMBER, 6.0)
+(15, DIV)
+(15, SUB)
+(15, NUMBER, 2.0)
+(15, CLOSE_BRACKET)
+(15, SEMICOLON)

test/calc/mixed.tout

@@ -0,0 +1,96 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, NUMBER, 2.0)
+(1, ADD)
+(1, NUMBER, 3.0)
+(1, MUL)
+(1, NUMBER, 4.0)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, OPEN_BRACKET)
+(2, NUMBER, 2.0)
+(2, ADD)
+(2, NUMBER, 3.0)
+(2, CLOSE_BRACKET)
+(2, MUL)
+(2, NUMBER, 4.0)
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, NUMBER, 2.0)
+(3, ADD)
+(3, NUMBER, 3.0)
+(3, MUL)
+(3, NUMBER, 4.0)
+(3, ADD)
+(3, NUMBER, 2.0)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, NUMBER, 2.0)
+(4, ADD)
+(4, NUMBER, 3.0)
+(4, MUL)
+(4, OPEN_BRACKET)
+(4, NUMBER, 4.0)
+(4, ADD)
+(4, NUMBER, 2.0)
+(4, CLOSE_BRACKET)
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, NUMBER, 2.0)
+(5, ADD)
+(5, NUMBER, 3.0)
+(5, MUL)
+(5, OPEN_BRACKET)
+(5, NUMBER, 4.0)
+(5, ADD)
+(5, NUMBER, 2.0)
+(5, CLOSE_BRACKET)
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, LITERAL, "print")
+(6, OPEN_BRACKET)
+(6, NUMBER, 2.0)
+(6, ADD)
+(6, SUB)
+(6, NUMBER, 3.0)
+(6, MUL)
+(6, OPEN_BRACKET)
+(6, NUMBER, 4.0)
+(6, ADD)
+(6, NUMBER, 2.0)
+(6, CLOSE_BRACKET)
+(6, CLOSE_BRACKET)
+(6, SEMICOLON)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, NUMBER, 2.0)
+(7, ADD)
+(7, NUMBER, 3.0)
+(7, MUL)
+(7, OPEN_BRACKET)
+(7, SUB)
+(7, NUMBER, 4.0)
+(7, ADD)
+(7, NUMBER, 2.0)
+(7, CLOSE_BRACKET)
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, LITERAL, "print")
+(8, OPEN_BRACKET)
+(8, OPEN_BRACKET)
+(8, NUMBER, 2.0)
+(8, SUB)
+(8, NUMBER, 3.0)
+(8, CLOSE_BRACKET)
+(8, MUL)
+(8, NUMBER, 4.0)
+(8, CLOSE_BRACKET)
+(8, SEMICOLON)

test/comments/comment0

@@ -0,0 +1,4 @@
+print("a");
+//print("b");
+print("c");
+print("d");

test/comments/comment0.out

@@ -0,0 +1,3 @@
+a
+c
+d

test/comments/comment0.tout

@@ -0,0 +1,15 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, STRING, "c")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, STRING, "d")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)

test/comments/comment1

@@ -0,0 +1,4 @@
+print("a");
+/*print("b");
+print("c");*/
+print("d");

test/comments/comment1.out

@@ -0,0 +1,2 @@
+a
+d

test/comments/comment1.tout

@@ -0,0 +1,10 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, STRING, "d")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)

test/comments/comment2

@@ -0,0 +1,4 @@
+print("a");
+//print("b");
+print("c"); //print("d");
+print("e");

test/comments/comment2.out

@@ -0,0 +1,3 @@
+a
+c
+e

test/comments/comment2.tout

@@ -0,0 +1,15 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, STRING, "c")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, STRING, "e")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)

test/comments/comment3

@@ -0,0 +1,4 @@
+print("a");
+/*print("b");
+print("c"); */print("d");
+print("e");

test/comments/comment3.out

@@ -0,0 +1,3 @@
+a
+d
+e

test/comments/comment3.tout

@@ -0,0 +1,15 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, STRING, "d")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, STRING, "e")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)

test/conditions/conditions0.tout

@@ -0,0 +1,10 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, TRUE)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, FALSE)
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)

test/conditions/conditions1.tout

@@ -0,0 +1,28 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, TRUE)
+(1, AND)
+(1, TRUE)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, FALSE)
+(2, AND)
+(2, TRUE)
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, TRUE)
+(3, AND)
+(3, FALSE)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, FALSE)
+(4, AND)
+(4, FALSE)
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)

test/conditions/conditions2.tout

@@ -0,0 +1,28 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, TRUE)
+(1, OR)
+(1, TRUE)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, FALSE)
+(2, OR)
+(2, TRUE)
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, TRUE)
+(3, OR)
+(3, FALSE)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, FALSE)
+(4, OR)
+(4, FALSE)
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)

test/conditions/conditions3.tout

@@ -0,0 +1,33 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, TRUE)
+(1, OR)
+(1, OPEN_BRACKET)
+(1, TRUE)
+(1, AND)
+(1, FALSE)
+(1, CLOSE_BRACKET)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, OPEN_BRACKET)
+(2, TRUE)
+(2, OR)
+(2, TRUE)
+(2, CLOSE_BRACKET)
+(2, AND)
+(2, FALSE)
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, OPEN_BRACKET)
+(3, TRUE)
+(3, OR)
+(3, FALSE)
+(3, CLOSE_BRACKET)
+(3, AND)
+(3, FALSE)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)

test/conditions/conditions4.tout

@@ -0,0 +1,34 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 3.0)
+(1, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, FALSE)
+(3, AND)
+(3, LITERAL, "a")
+(3, INC)
+(3, EQUAL)
+(3, NUMBER, 3.0)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, LITERAL, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(6, LITERAL, "print")
+(6, OPEN_BRACKET)
+(6, TRUE)
+(6, AND)
+(6, LITERAL, "a")
+(6, INC)
+(6, EQUAL)
+(6, NUMBER, 4.0)
+(6, CLOSE_BRACKET)
+(6, SEMICOLON)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, LITERAL, "a")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)

test/conditions/conditions5.tout

@@ -0,0 +1,34 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 3.0)
+(1, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, FALSE)
+(3, OR)
+(3, LITERAL, "a")
+(3, INC)
+(3, EQUAL)
+(3, NUMBER, 3.0)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, LITERAL, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(6, LITERAL, "print")
+(6, OPEN_BRACKET)
+(6, TRUE)
+(6, OR)
+(6, LITERAL, "a")
+(6, INC)
+(6, EQUAL)
+(6, NUMBER, 4.0)
+(6, CLOSE_BRACKET)
+(6, SEMICOLON)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, LITERAL, "a")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)

test/conditions/conditions6.tout

@@ -0,0 +1,105 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, NUMBER, 4.0)
+(1, LESS)
+(1, NUMBER, 5.0)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, NUMBER, 4.0)
+(2, GREATER)
+(2, NUMBER, 5.0)
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, NUMBER, 4.0)
+(3, GREATER_EQUAL)
+(3, NUMBER, 5.0)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, NUMBER, 4.0)
+(4, LESS_EQUAL)
+(4, NUMBER, 5.0)
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, NUMBER, 4.0)
+(5, EQUAL)
+(5, NUMBER, 5.0)
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, NUMBER, 5.0)
+(7, LESS)
+(7, NUMBER, 5.0)
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, LITERAL, "print")
+(8, OPEN_BRACKET)
+(8, NUMBER, 5.0)
+(8, GREATER)
+(8, NUMBER, 5.0)
+(8, CLOSE_BRACKET)
+(8, SEMICOLON)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, NUMBER, 5.0)
+(9, GREATER_EQUAL)
+(9, NUMBER, 5.0)
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(10, LITERAL, "print")
+(10, OPEN_BRACKET)
+(10, NUMBER, 5.0)
+(10, LESS_EQUAL)
+(10, NUMBER, 5.0)
+(10, CLOSE_BRACKET)
+(10, SEMICOLON)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, NUMBER, 5.0)
+(11, EQUAL)
+(11, NUMBER, 5.0)
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(13, LITERAL, "print")
+(13, OPEN_BRACKET)
+(13, NUMBER, 6.0)
+(13, LESS)
+(13, NUMBER, 5.0)
+(13, CLOSE_BRACKET)
+(13, SEMICOLON)
+(14, LITERAL, "print")
+(14, OPEN_BRACKET)
+(14, NUMBER, 6.0)
+(14, GREATER)
+(14, NUMBER, 5.0)
+(14, CLOSE_BRACKET)
+(14, SEMICOLON)
+(15, LITERAL, "print")
+(15, OPEN_BRACKET)
+(15, NUMBER, 6.0)
+(15, GREATER_EQUAL)
+(15, NUMBER, 5.0)
+(15, CLOSE_BRACKET)
+(15, SEMICOLON)
+(16, LITERAL, "print")
+(16, OPEN_BRACKET)
+(16, NUMBER, 6.0)
+(16, LESS_EQUAL)
+(16, NUMBER, 5.0)
+(16, CLOSE_BRACKET)
+(16, SEMICOLON)
+(17, LITERAL, "print")
+(17, OPEN_BRACKET)
+(17, NUMBER, 6.0)
+(17, EQUAL)
+(17, NUMBER, 5.0)
+(17, CLOSE_BRACKET)
+(17, SEMICOLON)

test/conditions/conditions7.tout

@@ -0,0 +1,22 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, NUMBER, 5.0)
+(1, LESS_EQUAL)
+(1, NUMBER, 4.0)
+(1, OR)
+(1, NUMBER, 5.0)
+(1, GREATER_EQUAL)
+(1, NUMBER, 4.0)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, NUMBER, 5.0)
+(2, LESS_EQUAL)
+(2, NUMBER, 4.0)
+(2, AND)
+(2, NUMBER, 5.0)
+(2, GREATER_EQUAL)
+(2, NUMBER, 4.0)
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)

test/conditions/conditions8.tout

@@ -0,0 +1,58 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, NUMBER, 1.0)
+(1, ADD)
+(1, NUMBER, 1.0)
+(1, EQUAL)
+(1, NUMBER, 3.0)
+(1, SUB)
+(1, NUMBER, 1.0)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, NUMBER, 1.0)
+(2, ADD)
+(2, NUMBER, 1.0)
+(2, EQUAL)
+(2, NUMBER, 3.0)
+(2, SUB)
+(2, NUMBER, 1.0)
+(2, AND)
+(2, FALSE)
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, NUMBER, 1.0)
+(3, ADD)
+(3, NUMBER, 1.0)
+(3, EQUAL)
+(3, NUMBER, 3.0)
+(3, SUB)
+(3, NUMBER, 1.0)
+(3, AND)
+(3, NUMBER, 5.0)
+(3, DIV)
+(3, NUMBER, 3.0)
+(3, EQUAL)
+(3, NUMBER, 2.0)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, NUMBER, 1.0)
+(4, ADD)
+(4, NUMBER, 1.0)
+(4, EQUAL)
+(4, NUMBER, 3.0)
+(4, SUB)
+(4, NUMBER, 1.0)
+(4, OR)
+(4, NUMBER, 5.0)
+(4, DIV)
+(4, NUMBER, 3.0)
+(4, EQUAL)
+(4, NUMBER, 2.0)
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)

test/for_break_continue/for_break_continue0.tout

@@ -0,0 +1,15 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "i")
+(1, COMMA)
+(1, NUMBER, 6.0)
+(1, COMMA)
+(1, NUMBER, 9.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "i")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, CLOSE_CURVED_BRACKET)

test/for_break_continue/for_break_continue1.tout

@@ -0,0 +1,17 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "i")
+(1, COMMA)
+(1, NUMBER, 6.0)
+(1, COMMA)
+(1, NUMBER, 9.0)
+(1, COMMA)
+(1, NUMBER, 2.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "i")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, CLOSE_CURVED_BRACKET)

test/for_break_continue/for_break_continue2.tout

@@ -0,0 +1,17 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "i")
+(1, COMMA)
+(1, NUMBER, 5.0)
+(1, COMMA)
+(1, NUMBER, 15.0)
+(1, COMMA)
+(1, NUMBER, 3.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "i")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, CLOSE_CURVED_BRACKET)

test/for_break_continue/for_break_continue3.tout

@@ -0,0 +1,19 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "i")
+(1, COMMA)
+(1, NUMBER, 5.0)
+(1, COMMA)
+(1, NUMBER, 15.0)
+(1, COMMA)
+(1, NUMBER, 3.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "i")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, BREAK)
+(4, SEMICOLON)
+(5, CLOSE_CURVED_BRACKET)

test/for_break_continue/for_break_continue4.tout

@@ -0,0 +1,27 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "i")
+(1, COMMA)
+(1, NUMBER, 5.0)
+(1, COMMA)
+(1, NUMBER, 15.0)
+(1, COMMA)
+(1, NUMBER, 3.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "i")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, IF)
+(4, OPEN_BRACKET)
+(4, LITERAL, "i")
+(4, EQUAL)
+(4, NUMBER, 9.0)
+(4, CLOSE_BRACKET)
+(5, OPEN_CURVED_BRACKET)
+(6, BREAK)
+(6, SEMICOLON)
+(7, CLOSE_CURVED_BRACKET)
+(8, CLOSE_CURVED_BRACKET)

test/for_break_continue/for_break_continue5.tout

@@ -0,0 +1,27 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "i")
+(1, COMMA)
+(1, NUMBER, 5.0)
+(1, COMMA)
+(1, NUMBER, 15.0)
+(1, COMMA)
+(1, NUMBER, 3.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "i")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, IF)
+(4, OPEN_BRACKET)
+(4, LITERAL, "i")
+(4, EQUAL)
+(4, NUMBER, 11.0)
+(4, CLOSE_BRACKET)
+(5, OPEN_CURVED_BRACKET)
+(6, BREAK)
+(6, SEMICOLON)
+(7, CLOSE_CURVED_BRACKET)
+(8, CLOSE_CURVED_BRACKET)

test/for_break_continue/for_break_continue6.tout

@@ -0,0 +1,30 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "i")
+(1, COMMA)
+(1, NUMBER, 5.0)
+(1, COMMA)
+(1, NUMBER, 7.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, FOR)
+(3, OPEN_BRACKET)
+(3, LITERAL, "j")
+(3, COMMA)
+(3, NUMBER, 0.0)
+(3, COMMA)
+(3, NUMBER, 5.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, LITERAL, "j")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, LITERAL, "i")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)

test/for_break_continue/for_break_continue7.tout

@@ -0,0 +1,32 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "i")
+(1, COMMA)
+(1, NUMBER, 5.0)
+(1, COMMA)
+(1, NUMBER, 7.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, FOR)
+(3, OPEN_BRACKET)
+(3, LITERAL, "j")
+(3, COMMA)
+(3, NUMBER, 0.0)
+(3, COMMA)
+(3, NUMBER, 5.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, BREAK)
+(5, SEMICOLON)
+(6, LITERAL, "print")
+(6, OPEN_BRACKET)
+(6, LITERAL, "j")
+(6, CLOSE_BRACKET)
+(6, SEMICOLON)
+(7, CLOSE_CURVED_BRACKET)
+(8, LITERAL, "print")
+(8, OPEN_BRACKET)
+(8, LITERAL, "i")
+(8, CLOSE_BRACKET)
+(8, SEMICOLON)
+(9, CLOSE_CURVED_BRACKET)

test/for_break_continue/for_break_continue8.tout

@@ -0,0 +1,40 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "i")
+(1, COMMA)
+(1, NUMBER, 5.0)
+(1, COMMA)
+(1, NUMBER, 7.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, FOR)
+(3, OPEN_BRACKET)
+(3, LITERAL, "j")
+(3, COMMA)
+(3, NUMBER, 0.0)
+(3, COMMA)
+(3, NUMBER, 5.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, IF)
+(5, OPEN_BRACKET)
+(5, LITERAL, "i")
+(5, EQUAL)
+(5, NUMBER, 6.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, CONTINUE)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, LITERAL, "j")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(10, CLOSE_CURVED_BRACKET)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, LITERAL, "i")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)

test/for_break_continue/for_break_continue9.tout

@@ -0,0 +1,43 @@
+(1, FOR)
+(1, OPEN_BRACKET)
+(1, LITERAL, "x")
+(1, COMMA)
+(1, NUMBER, 0.0)
+(1, COMMA)
+(1, NUMBER, 2.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, FOR)
+(3, OPEN_BRACKET)
+(3, LITERAL, "y")
+(3, COMMA)
+(3, NUMBER, 0.0)
+(3, COMMA)
+(3, NUMBER, 2.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, FOR)
+(5, OPEN_BRACKET)
+(5, LITERAL, "z")
+(5, COMMA)
+(5, NUMBER, 0.0)
+(5, COMMA)
+(5, NUMBER, 2.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, LITERAL, "x")
+(7, COMMA)
+(7, STRING, " ")
+(7, COMMA)
+(7, LITERAL, "y")
+(7, COMMA)
+(7, STRING, " ")
+(7, COMMA)
+(7, LITERAL, "z")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(9, CLOSE_CURVED_BRACKET)
+(10, CLOSE_CURVED_BRACKET)

test/functions/functions0.tout

@@ -0,0 +1,21 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, LITERAL, "b")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(8, LITERAL, "print")
+(8, OPEN_BRACKET)
+(8, STRING, "c")
+(8, CLOSE_BRACKET)
+(8, SEMICOLON)

test/functions/functions1.tout

@@ -0,0 +1,22 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, LITERAL, "b")
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, LITERAL, "b")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(8, LITERAL, "print")
+(8, OPEN_BRACKET)
+(8, STRING, "c")
+(8, CLOSE_BRACKET)
+(8, SEMICOLON)

test/functions/functions10.tout

@@ -0,0 +1,34 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, LITERAL, "b")
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "b")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, RETURN)
+(6, SEMICOLON)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, STRING, "c")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(9, LITERAL, "wusi")
+(9, OPEN_BRACKET)
+(9, STRING, "HI")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, STRING, "d")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)

test/functions/functions11.tout

@@ -0,0 +1,36 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "b")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, RETURN)
+(6, STRING, "c")
+(6, SEMICOLON)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, STRING, "d")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, LITERAL, "wusi")
+(9, OPEN_BRACKET)
+(9, CLOSE_BRACKET)
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, STRING, "e")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)

test/functions/functions12.tout

@@ -0,0 +1,44 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "b")
+(3, OPEN_BRACKET)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "b")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, LITERAL, "c")
+(6, OPEN_BRACKET)
+(6, CLOSE_BRACKET)
+(6, SEMICOLON)
+(7, CLOSE_CURVED_BRACKET)
+(9, FUNCTION)
+(9, LITERAL, "c")
+(9, OPEN_BRACKET)
+(9, CLOSE_BRACKET)
+(10, OPEN_CURVED_BRACKET)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, STRING, "c")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(14, LITERAL, "b")
+(14, OPEN_BRACKET)
+(14, CLOSE_BRACKET)
+(14, SEMICOLON)
+(15, LITERAL, "c")
+(15, OPEN_BRACKET)
+(15, CLOSE_BRACKET)
+(15, SEMICOLON)
+(17, LITERAL, "print")
+(17, OPEN_BRACKET)
+(17, STRING, "e")
+(17, CLOSE_BRACKET)
+(17, SEMICOLON)

test/functions/functions13.tout

@@ -0,0 +1,57 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "b")
+(3, OPEN_BRACKET)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "n")
+(5, SET)
+(5, NUMBER, 7.0)
+(5, SEMICOLON)
+(6, LITERAL, "print")
+(6, OPEN_BRACKET)
+(6, LITERAL, "n")
+(6, CLOSE_BRACKET)
+(6, SEMICOLON)
+(7, LITERAL, "c")
+(7, OPEN_BRACKET)
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, LITERAL, "print")
+(8, OPEN_BRACKET)
+(8, LITERAL, "n")
+(8, CLOSE_BRACKET)
+(8, SEMICOLON)
+(9, CLOSE_CURVED_BRACKET)
+(11, FUNCTION)
+(11, LITERAL, "c")
+(11, OPEN_BRACKET)
+(11, CLOSE_BRACKET)
+(12, OPEN_CURVED_BRACKET)
+(13, LITERAL, "n")
+(13, SET)
+(13, NUMBER, 9.0)
+(13, SEMICOLON)
+(14, LITERAL, "print")
+(14, OPEN_BRACKET)
+(14, LITERAL, "n")
+(14, CLOSE_BRACKET)
+(14, SEMICOLON)
+(15, CLOSE_CURVED_BRACKET)
+(17, LITERAL, "b")
+(17, OPEN_BRACKET)
+(17, CLOSE_BRACKET)
+(17, SEMICOLON)
+(18, LITERAL, "c")
+(18, OPEN_BRACKET)
+(18, CLOSE_BRACKET)
+(18, SEMICOLON)
+(20, LITERAL, "print")
+(20, OPEN_BRACKET)
+(20, STRING, "e")
+(20, CLOSE_BRACKET)
+(20, SEMICOLON)

test/functions/functions14.tout

@@ -0,0 +1,29 @@
+(1, LITERAL, "igoto")
+(1, OPEN_BRACKET)
+(1, STRING, "hi")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "goto")
+(2, OPEN_BRACKET)
+(2, STRING, "end")
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(4, FUNCTION)
+(4, LITERAL, "wusi")
+(4, OPEN_BRACKET)
+(4, CLOSE_BRACKET)
+(5, OPEN_CURVED_BRACKET)
+(6, LABEL, "@hi")
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, STRING, "HI")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, LABEL, "@end")
+(9, CLOSE_CURVED_BRACKET)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, STRING, "a")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(13, LABEL, "@end")

test/functions/functions2.tout

@@ -0,0 +1,27 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, LITERAL, "b")
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "b")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(7, LITERAL, "wusi")
+(7, OPEN_BRACKET)
+(7, STRING, "HI")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, STRING, "c")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)

test/functions/functions3.tout

@@ -0,0 +1,27 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, LITERAL, "b")
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, LITERAL, "b")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(7, LITERAL, "wusi")
+(7, OPEN_BRACKET)
+(7, STRING, "HI")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, STRING, "c")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)

test/functions/functions4.tout

@@ -0,0 +1,19 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 2.0)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "a")
+(5, SET)
+(5, NUMBER, 5.0)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(8, LITERAL, "print")
+(8, OPEN_BRACKET)
+(8, LITERAL, "a")
+(8, CLOSE_BRACKET)
+(8, SEMICOLON)

test/functions/functions5.tout

@@ -0,0 +1,23 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 2.0)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "a")
+(5, SET)
+(5, NUMBER, 5.0)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(7, LITERAL, "wusi")
+(7, OPEN_BRACKET)
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, LITERAL, "a")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)

test/functions/functions6.tout

@@ -0,0 +1,19 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 2.0)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "$a")
+(5, SET)
+(5, NUMBER, 5.0)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(8, LITERAL, "print")
+(8, OPEN_BRACKET)
+(8, LITERAL, "a")
+(8, CLOSE_BRACKET)
+(8, SEMICOLON)

test/functions/functions7.tout

@@ -0,0 +1,23 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 2.0)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "$a")
+(5, SET)
+(5, NUMBER, 5.0)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(7, LITERAL, "wusi")
+(7, OPEN_BRACKET)
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, LITERAL, "a")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)

test/functions/functions8.tout

@@ -0,0 +1,36 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, LITERAL, "fac")
+(1, OPEN_BRACKET)
+(1, NUMBER, 5.0)
+(1, CLOSE_BRACKET)
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "fac")
+(3, OPEN_BRACKET)
+(3, LITERAL, "n")
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, IF)
+(5, OPEN_BRACKET)
+(5, LITERAL, "n")
+(5, LESS_EQUAL)
+(5, NUMBER, 1.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, RETURN)
+(7, NUMBER, 1.0)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(9, RETURN)
+(9, LITERAL, "n")
+(9, MUL)
+(9, LITERAL, "fac")
+(9, OPEN_BRACKET)
+(9, LITERAL, "n")
+(9, SUB)
+(9, NUMBER, 1.0)
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(10, CLOSE_CURVED_BRACKET)

test/functions/functions9.tout

@@ -0,0 +1,29 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(3, FUNCTION)
+(3, LITERAL, "wusi")
+(3, OPEN_BRACKET)
+(3, LITERAL, "b")
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "b")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, RETURN)
+(6, SEMICOLON)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, STRING, "c")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(10, LITERAL, "print")
+(10, OPEN_BRACKET)
+(10, STRING, "d")
+(10, CLOSE_BRACKET)
+(10, SEMICOLON)

test/goto.tout

@@ -0,0 +1,65 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "a")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)
+(2, LITERAL, "invstring")
+(2, SET)
+(2, STRING, "")
+(2, SEMICOLON)
+(3, LITERAL, "goto")
+(3, OPEN_BRACKET)
+(3, LABEL, "@label4")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LABEL, "@label3")
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "e")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, LITERAL, "goto")
+(6, OPEN_BRACKET)
+(6, LABEL, "@label5")
+(6, CLOSE_BRACKET)
+(6, SEMICOLON)
+(7, LABEL, "@label4")
+(9, LITERAL, "goto")
+(9, OPEN_BRACKET)
+(9, LABEL, "@label1")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(10, LITERAL, "print")
+(10, OPEN_BRACKET)
+(10, STRING, "b")
+(10, CLOSE_BRACKET)
+(10, SEMICOLON)
+(11, LABEL, "@label1")
+(13, LITERAL, "goto")
+(13, OPEN_BRACKET)
+(13, STRING, "label2")
+(13, CLOSE_BRACKET)
+(13, SEMICOLON)
+(14, LITERAL, "print")
+(14, OPEN_BRACKET)
+(14, STRING, "c")
+(14, CLOSE_BRACKET)
+(14, SEMICOLON)
+(15, LABEL, "@label2")
+(15, SEMICOLON)
+(17, LITERAL, "goto")
+(17, OPEN_BRACKET)
+(17, LABEL, "@label3")
+(17, CLOSE_BRACKET)
+(17, SEMICOLON)
+(18, LABEL, "@label5")
+(19, LITERAL, "print")
+(19, OPEN_BRACKET)
+(19, STRING, "d")
+(19, CLOSE_BRACKET)
+(19, SEMICOLON)
+(21, LITERAL, "print")
+(21, OPEN_BRACKET)
+(21, STRING, "b")
+(21, CLOSE_BRACKET)
+(21, SEMICOLON)

test/if_elseif_else/if0.tout

@@ -0,0 +1,13 @@
+(1, IF)
+(1, OPEN_BRACKET)
+(1, NUMBER, 5.0)
+(1, LESS)
+(1, NUMBER, 3.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, STRING, "a")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if1.tout

@@ -0,0 +1,17 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 4.0)
+(1, SEMICOLON)
+(2, IF)
+(2, OPEN_BRACKET)
+(2, LITERAL, "a")
+(2, LESS)
+(2, NUMBER, 3.0)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, STRING, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if10.tout

@@ -0,0 +1,89 @@
+(1, IF)
+(1, OPEN_BRACKET)
+(1, NUMBER, 3.0)
+(1, LESS)
+(1, NUMBER, 2.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, IF)
+(3, OPEN_BRACKET)
+(3, NUMBER, 5.0)
+(3, LESS)
+(3, NUMBER, 3.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "a")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(7, ELSE)
+(8, OPEN_CURVED_BRACKET)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, STRING, "b")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(10, CLOSE_CURVED_BRACKET)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, STRING, "c")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(13, ELSEIF)
+(13, OPEN_BRACKET)
+(13, NUMBER, 1.0)
+(13, LESS)
+(13, NUMBER, 2.0)
+(13, CLOSE_BRACKET)
+(14, OPEN_CURVED_BRACKET)
+(15, LITERAL, "print")
+(15, OPEN_BRACKET)
+(15, STRING, "d")
+(15, CLOSE_BRACKET)
+(15, SEMICOLON)
+(16, CLOSE_CURVED_BRACKET)
+(17, ELSEIF)
+(17, OPEN_BRACKET)
+(17, NUMBER, 2.0)
+(17, LESS)
+(17, NUMBER, 2.0)
+(17, CLOSE_BRACKET)
+(18, OPEN_CURVED_BRACKET)
+(19, LITERAL, "print")
+(19, OPEN_BRACKET)
+(19, STRING, "e")
+(19, CLOSE_BRACKET)
+(19, SEMICOLON)
+(20, IF)
+(20, OPEN_BRACKET)
+(20, NUMBER, 3.0)
+(20, LESS)
+(20, NUMBER, 5.0)
+(20, CLOSE_BRACKET)
+(21, OPEN_CURVED_BRACKET)
+(22, LITERAL, "print")
+(22, OPEN_BRACKET)
+(22, STRING, "f")
+(22, CLOSE_BRACKET)
+(22, SEMICOLON)
+(23, CLOSE_CURVED_BRACKET)
+(24, ELSE)
+(25, OPEN_CURVED_BRACKET)
+(26, LITERAL, "print")
+(26, OPEN_BRACKET)
+(26, STRING, "g")
+(26, CLOSE_BRACKET)
+(26, SEMICOLON)
+(27, CLOSE_CURVED_BRACKET)
+(28, CLOSE_CURVED_BRACKET)
+(29, ELSE)
+(30, OPEN_CURVED_BRACKET)
+(31, LITERAL, "print")
+(31, OPEN_BRACKET)
+(31, STRING, "h")
+(31, CLOSE_BRACKET)
+(31, SEMICOLON)
+(32, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if11.tout

@@ -0,0 +1,89 @@
+(1, IF)
+(1, OPEN_BRACKET)
+(1, NUMBER, 3.0)
+(1, LESS)
+(1, NUMBER, 2.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, IF)
+(3, OPEN_BRACKET)
+(3, NUMBER, 5.0)
+(3, LESS)
+(3, NUMBER, 3.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "a")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(7, ELSE)
+(8, OPEN_CURVED_BRACKET)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, STRING, "b")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(10, CLOSE_CURVED_BRACKET)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, STRING, "c")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(13, ELSEIF)
+(13, OPEN_BRACKET)
+(13, NUMBER, 2.0)
+(13, LESS)
+(13, NUMBER, 2.0)
+(13, CLOSE_BRACKET)
+(14, OPEN_CURVED_BRACKET)
+(15, LITERAL, "print")
+(15, OPEN_BRACKET)
+(15, STRING, "d")
+(15, CLOSE_BRACKET)
+(15, SEMICOLON)
+(16, CLOSE_CURVED_BRACKET)
+(17, ELSEIF)
+(17, OPEN_BRACKET)
+(17, NUMBER, 1.0)
+(17, LESS)
+(17, NUMBER, 2.0)
+(17, CLOSE_BRACKET)
+(18, OPEN_CURVED_BRACKET)
+(19, LITERAL, "print")
+(19, OPEN_BRACKET)
+(19, STRING, "e")
+(19, CLOSE_BRACKET)
+(19, SEMICOLON)
+(20, IF)
+(20, OPEN_BRACKET)
+(20, NUMBER, 3.0)
+(20, LESS)
+(20, NUMBER, 5.0)
+(20, CLOSE_BRACKET)
+(21, OPEN_CURVED_BRACKET)
+(22, LITERAL, "print")
+(22, OPEN_BRACKET)
+(22, STRING, "f")
+(22, CLOSE_BRACKET)
+(22, SEMICOLON)
+(23, CLOSE_CURVED_BRACKET)
+(24, ELSE)
+(25, OPEN_CURVED_BRACKET)
+(26, LITERAL, "print")
+(26, OPEN_BRACKET)
+(26, STRING, "g")
+(26, CLOSE_BRACKET)
+(26, SEMICOLON)
+(27, CLOSE_CURVED_BRACKET)
+(28, CLOSE_CURVED_BRACKET)
+(29, ELSE)
+(30, OPEN_CURVED_BRACKET)
+(31, LITERAL, "print")
+(31, OPEN_BRACKET)
+(31, STRING, "h")
+(31, CLOSE_BRACKET)
+(31, SEMICOLON)
+(32, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if2.tout

@@ -0,0 +1,19 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 4.0)
+(1, SEMICOLON)
+(2, IF)
+(2, OPEN_BRACKET)
+(2, LITERAL, "a")
+(2, SUB)
+(2, NUMBER, 2.0)
+(2, LESS)
+(2, NUMBER, 3.0)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, STRING, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if3.tout

@@ -0,0 +1,65 @@
+(1, IF)
+(1, OPEN_BRACKET)
+(1, NUMBER, 1.0)
+(1, LESS)
+(1, NUMBER, 3.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, STRING, "a")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, CLOSE_CURVED_BRACKET)
+(5, IF)
+(5, OPEN_BRACKET)
+(5, NUMBER, 2.0)
+(5, LESS)
+(5, NUMBER, 3.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, STRING, "b")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(9, IF)
+(9, OPEN_BRACKET)
+(9, NUMBER, 3.0)
+(9, LESS)
+(9, NUMBER, 3.0)
+(9, CLOSE_BRACKET)
+(10, OPEN_CURVED_BRACKET)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, STRING, "c")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(13, IF)
+(13, OPEN_BRACKET)
+(13, NUMBER, 4.0)
+(13, LESS)
+(13, NUMBER, 3.0)
+(13, CLOSE_BRACKET)
+(14, OPEN_CURVED_BRACKET)
+(15, LITERAL, "print")
+(15, OPEN_BRACKET)
+(15, STRING, "d")
+(15, CLOSE_BRACKET)
+(15, SEMICOLON)
+(16, CLOSE_CURVED_BRACKET)
+(17, IF)
+(17, OPEN_BRACKET)
+(17, NUMBER, 5.0)
+(17, LESS)
+(17, NUMBER, 3.0)
+(17, CLOSE_BRACKET)
+(18, OPEN_CURVED_BRACKET)
+(19, LITERAL, "print")
+(19, OPEN_BRACKET)
+(19, STRING, "e")
+(19, CLOSE_BRACKET)
+(19, SEMICOLON)
+(20, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if4.tout

@@ -0,0 +1,59 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 5.0)
+(1, SEMICOLON)
+(3, IF)
+(3, OPEN_BRACKET)
+(3, LITERAL, "a")
+(3, GREATER)
+(3, NUMBER, 1.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, IF)
+(5, OPEN_BRACKET)
+(5, LITERAL, "a")
+(5, GREATER)
+(5, NUMBER, 3.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, STRING, "a")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(10, IF)
+(10, OPEN_BRACKET)
+(10, LITERAL, "a")
+(10, LESS)
+(10, NUMBER, 3.0)
+(10, CLOSE_BRACKET)
+(11, OPEN_CURVED_BRACKET)
+(12, LITERAL, "print")
+(12, OPEN_BRACKET)
+(12, STRING, "b")
+(12, CLOSE_BRACKET)
+(12, SEMICOLON)
+(13, CLOSE_CURVED_BRACKET)
+(14, CLOSE_CURVED_BRACKET)
+(16, IF)
+(16, OPEN_BRACKET)
+(16, LITERAL, "a")
+(16, LESS)
+(16, NUMBER, 3.0)
+(16, CLOSE_BRACKET)
+(17, OPEN_CURVED_BRACKET)
+(18, IF)
+(18, OPEN_BRACKET)
+(18, LITERAL, "a")
+(18, EQUAL)
+(18, NUMBER, 5.0)
+(18, CLOSE_BRACKET)
+(19, OPEN_CURVED_BRACKET)
+(20, LITERAL, "print")
+(20, OPEN_BRACKET)
+(20, STRING, "c")
+(20, CLOSE_BRACKET)
+(20, SEMICOLON)
+(21, CLOSE_CURVED_BRACKET)
+(22, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if5.tout

@@ -0,0 +1,59 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 5.0)
+(1, SEMICOLON)
+(3, IF)
+(3, OPEN_BRACKET)
+(3, LITERAL, "a")
+(3, GREATER)
+(3, NUMBER, 1.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, IF)
+(5, OPEN_BRACKET)
+(5, LITERAL, "a")
+(5, GREATER)
+(5, NUMBER, 3.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, STRING, "a")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(10, IF)
+(10, OPEN_BRACKET)
+(10, LITERAL, "a")
+(10, LESS)
+(10, NUMBER, 3.0)
+(10, CLOSE_BRACKET)
+(11, OPEN_CURVED_BRACKET)
+(12, LITERAL, "print")
+(12, OPEN_BRACKET)
+(12, STRING, "b")
+(12, CLOSE_BRACKET)
+(12, SEMICOLON)
+(13, CLOSE_CURVED_BRACKET)
+(14, CLOSE_CURVED_BRACKET)
+(16, IF)
+(16, OPEN_BRACKET)
+(16, LITERAL, "a")
+(16, GREATER)
+(16, NUMBER, 3.0)
+(16, CLOSE_BRACKET)
+(17, OPEN_CURVED_BRACKET)
+(18, IF)
+(18, OPEN_BRACKET)
+(18, LITERAL, "a")
+(18, EQUAL)
+(18, NUMBER, 5.0)
+(18, CLOSE_BRACKET)
+(19, OPEN_CURVED_BRACKET)
+(20, LITERAL, "print")
+(20, OPEN_BRACKET)
+(20, STRING, "c")
+(20, CLOSE_BRACKET)
+(20, SEMICOLON)
+(21, CLOSE_CURVED_BRACKET)
+(22, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if6.tout

@@ -0,0 +1,21 @@
+(1, IF)
+(1, OPEN_BRACKET)
+(1, NUMBER, 4.0)
+(1, GREATER)
+(1, NUMBER, 3.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, STRING, "a")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, CLOSE_CURVED_BRACKET)
+(5, ELSE)
+(6, OPEN_CURVED_BRACKET)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, STRING, "b")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if7.tout

@@ -0,0 +1,21 @@
+(1, IF)
+(1, OPEN_BRACKET)
+(1, NUMBER, 4.0)
+(1, LESS)
+(1, NUMBER, 3.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, STRING, "a")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, CLOSE_CURVED_BRACKET)
+(5, ELSE)
+(6, OPEN_CURVED_BRACKET)
+(7, LITERAL, "print")
+(7, OPEN_BRACKET)
+(7, STRING, "b")
+(7, CLOSE_BRACKET)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if8.tout

@@ -0,0 +1,42 @@
+(1, IF)
+(1, OPEN_BRACKET)
+(1, NUMBER, 3.0)
+(1, GREATER)
+(1, NUMBER, 2.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, IF)
+(3, OPEN_BRACKET)
+(3, NUMBER, 5.0)
+(3, LESS)
+(3, NUMBER, 3.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "a")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(7, ELSE)
+(8, OPEN_CURVED_BRACKET)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, STRING, "b")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(10, CLOSE_CURVED_BRACKET)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, STRING, "c")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(13, ELSE)
+(14, OPEN_CURVED_BRACKET)
+(15, LITERAL, "print")
+(15, OPEN_BRACKET)
+(15, STRING, "d")
+(15, CLOSE_BRACKET)
+(15, SEMICOLON)
+(16, CLOSE_CURVED_BRACKET)

test/if_elseif_else/if9.tout

@@ -0,0 +1,55 @@
+(1, IF)
+(1, OPEN_BRACKET)
+(1, NUMBER, 3.0)
+(1, LESS)
+(1, NUMBER, 2.0)
+(1, CLOSE_BRACKET)
+(2, OPEN_CURVED_BRACKET)
+(3, IF)
+(3, OPEN_BRACKET)
+(3, NUMBER, 5.0)
+(3, LESS)
+(3, NUMBER, 3.0)
+(3, CLOSE_BRACKET)
+(4, OPEN_CURVED_BRACKET)
+(5, LITERAL, "print")
+(5, OPEN_BRACKET)
+(5, STRING, "a")
+(5, CLOSE_BRACKET)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)
+(7, ELSE)
+(8, OPEN_CURVED_BRACKET)
+(9, LITERAL, "print")
+(9, OPEN_BRACKET)
+(9, STRING, "b")
+(9, CLOSE_BRACKET)
+(9, SEMICOLON)
+(10, CLOSE_CURVED_BRACKET)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, STRING, "c")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(13, ELSEIF)
+(13, OPEN_BRACKET)
+(13, NUMBER, 2.0)
+(13, LESS)
+(13, NUMBER, 2.0)
+(13, CLOSE_BRACKET)
+(14, OPEN_CURVED_BRACKET)
+(15, LITERAL, "print")
+(15, OPEN_BRACKET)
+(15, STRING, "d")
+(15, CLOSE_BRACKET)
+(15, SEMICOLON)
+(16, CLOSE_CURVED_BRACKET)
+(17, ELSE)
+(18, OPEN_CURVED_BRACKET)
+(19, LITERAL, "print")
+(19, OPEN_BRACKET)
+(19, STRING, "e")
+(19, CLOSE_BRACKET)
+(19, SEMICOLON)
+(20, CLOSE_CURVED_BRACKET)

test/print.tout

@@ -0,0 +1,5 @@
+(1, LITERAL, "print")
+(1, OPEN_BRACKET)
+(1, STRING, "HI")
+(1, CLOSE_BRACKET)
+(1, SEMICOLON)

test/vars/vars0.tout

@@ -0,0 +1,9 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 3.0)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, LITERAL, "a")
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)

test/vars/vars1.tout

@@ -0,0 +1,9 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, STRING, "wusi")
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, LITERAL, "a")
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)

test/vars/vars2.tout

@@ -0,0 +1,12 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 3.0)
+(1, SEMICOLON)
+(2, LITERAL, "a")
+(2, INC)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "a")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)

test/vars/vars3.tout

@@ -0,0 +1,12 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 3.0)
+(1, SEMICOLON)
+(2, INC)
+(2, LITERAL, "a")
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "a")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)

test/vars/vars4.tout

@@ -0,0 +1,21 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 3.0)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, INC)
+(2, LITERAL, "a")
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "a")
+(3, INC)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, LITERAL, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)

test/vars/vars5.tout

@@ -0,0 +1,12 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 3.0)
+(1, SEMICOLON)
+(2, LITERAL, "a")
+(2, DEC)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "a")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)

test/vars/vars6.tout

@@ -0,0 +1,12 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 3.0)
+(1, SEMICOLON)
+(2, DEC)
+(2, LITERAL, "a")
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "a")
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)

test/vars/vars7.tout

@@ -0,0 +1,21 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 3.0)
+(1, SEMICOLON)
+(2, LITERAL, "print")
+(2, OPEN_BRACKET)
+(2, DEC)
+(2, LITERAL, "a")
+(2, CLOSE_BRACKET)
+(2, SEMICOLON)
+(3, LITERAL, "print")
+(3, OPEN_BRACKET)
+(3, LITERAL, "a")
+(3, DEC)
+(3, CLOSE_BRACKET)
+(3, SEMICOLON)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, LITERAL, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)

test/vars/vars8.tout

@@ -0,0 +1,25 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 5.0)
+(1, SEMICOLON)
+(2, LITERAL, "a")
+(2, ADD_SET)
+(2, NUMBER, 1.0)
+(2, SEMICOLON)
+(3, LITERAL, "a")
+(3, SUB_SET)
+(3, NUMBER, 2.0)
+(3, SEMICOLON)
+(4, LITERAL, "a")
+(4, MUL_SET)
+(4, NUMBER, 3.0)
+(4, SEMICOLON)
+(5, LITERAL, "a")
+(5, DIV_SET)
+(5, NUMBER, 6.0)
+(5, SEMICOLON)
+(6, LITERAL, "print")
+(6, OPEN_BRACKET)
+(6, LITERAL, "a")
+(6, CLOSE_BRACKET)
+(6, SEMICOLON)

test/vars/vars9.tout

@@ -0,0 +1,33 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 5.0)
+(1, SEMICOLON)
+(2, LITERAL, "a")
+(2, SET)
+(2, LITERAL, "a")
+(2, ADD)
+(2, NUMBER, 1.0)
+(2, SEMICOLON)
+(3, LITERAL, "a")
+(3, SET)
+(3, LITERAL, "a")
+(3, SUB)
+(3, NUMBER, 2.0)
+(3, SEMICOLON)
+(4, LITERAL, "a")
+(4, SET)
+(4, LITERAL, "a")
+(4, MUL)
+(4, NUMBER, 3.0)
+(4, SEMICOLON)
+(5, LITERAL, "a")
+(5, SET)
+(5, LITERAL, "a")
+(5, DIV)
+(5, NUMBER, 6.0)
+(5, SEMICOLON)
+(6, LITERAL, "print")
+(6, OPEN_BRACKET)
+(6, LITERAL, "a")
+(6, CLOSE_BRACKET)
+(6, SEMICOLON)

test/while_break_continue/while_break_continue0.tout

@@ -0,0 +1,20 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 5.0)
+(1, SEMICOLON)
+(2, WHILE)
+(2, OPEN_BRACKET)
+(2, LITERAL, "a")
+(2, LESS)
+(2, NUMBER, 8.0)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, LITERAL, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, LITERAL, "a")
+(5, INC)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)

test/while_break_continue/while_break_continue1.tout

@@ -0,0 +1,20 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 20.0)
+(1, SEMICOLON)
+(2, WHILE)
+(2, OPEN_BRACKET)
+(2, LITERAL, "a")
+(2, LESS)
+(2, NUMBER, 8.0)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, LITERAL, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, LITERAL, "a")
+(5, INC)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)

test/while_break_continue/while_break_continue2.tout

@@ -0,0 +1,20 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 20.0)
+(1, SEMICOLON)
+(2, WHILE)
+(2, OPEN_BRACKET)
+(2, LITERAL, "a")
+(2, GREATER)
+(2, NUMBER, 0.0)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, LITERAL, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, LITERAL, "a")
+(5, DEC)
+(5, SEMICOLON)
+(6, CLOSE_CURVED_BRACKET)

test/while_break_continue/while_break_continue3.tout

@@ -0,0 +1,28 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 0.0)
+(1, SEMICOLON)
+(2, WHILE)
+(2, OPEN_BRACKET)
+(2, TRUE)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, LITERAL, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, LITERAL, "a")
+(5, INC)
+(5, SEMICOLON)
+(6, IF)
+(6, OPEN_BRACKET)
+(6, LITERAL, "a")
+(6, EQUAL)
+(6, NUMBER, 3.0)
+(6, CLOSE_BRACKET)
+(7, OPEN_CURVED_BRACKET)
+(8, BREAK)
+(8, SEMICOLON)
+(9, CLOSE_CURVED_BRACKET)
+(10, CLOSE_CURVED_BRACKET)

test/while_break_continue/while_break_continue4.tout

@@ -0,0 +1,28 @@
+(1, LITERAL, "a")
+(1, SET)
+(1, NUMBER, 10.0)
+(1, SEMICOLON)
+(2, WHILE)
+(2, OPEN_BRACKET)
+(2, TRUE)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "print")
+(4, OPEN_BRACKET)
+(4, LITERAL, "a")
+(4, CLOSE_BRACKET)
+(4, SEMICOLON)
+(5, LITERAL, "a")
+(5, DEC)
+(5, SEMICOLON)
+(6, IF)
+(6, OPEN_BRACKET)
+(6, LITERAL, "a")
+(6, EQUAL)
+(6, NUMBER, 3.0)
+(6, CLOSE_BRACKET)
+(7, OPEN_CURVED_BRACKET)
+(8, BREAK)
+(8, SEMICOLON)
+(9, CLOSE_CURVED_BRACKET)
+(10, CLOSE_CURVED_BRACKET)

test/while_break_continue/while_break_continue5.tout

@@ -0,0 +1,58 @@
+(1, LITERAL, "x")
+(1, SET)
+(1, NUMBER, 0.0)
+(1, SEMICOLON)
+(2, LITERAL, "y")
+(2, SET)
+(2, NUMBER, 0.0)
+(2, SEMICOLON)
+(3, LITERAL, "z")
+(3, SET)
+(3, NUMBER, 0.0)
+(3, SEMICOLON)
+(5, WHILE)
+(5, OPEN_BRACKET)
+(5, LITERAL, "x")
+(5, LESS)
+(5, NUMBER, 3.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, WHILE)
+(7, OPEN_BRACKET)
+(7, LITERAL, "y")
+(7, LESS)
+(7, NUMBER, 3.0)
+(7, CLOSE_BRACKET)
+(8, OPEN_CURVED_BRACKET)
+(9, WHILE)
+(9, OPEN_BRACKET)
+(9, LITERAL, "z")
+(9, LESS)
+(9, NUMBER, 3.0)
+(9, CLOSE_BRACKET)
+(10, OPEN_CURVED_BRACKET)
+(11, LITERAL, "print")
+(11, OPEN_BRACKET)
+(11, LITERAL, "x")
+(11, COMMA)
+(11, STRING, " ")
+(11, COMMA)
+(11, LITERAL, "y")
+(11, COMMA)
+(11, STRING, " ")
+(11, COMMA)
+(11, LITERAL, "z")
+(11, CLOSE_BRACKET)
+(11, SEMICOLON)
+(12, LITERAL, "z")
+(12, INC)
+(12, SEMICOLON)
+(13, CLOSE_CURVED_BRACKET)
+(14, LITERAL, "y")
+(14, INC)
+(14, SEMICOLON)
+(15, CLOSE_CURVED_BRACKET)
+(16, LITERAL, "x")
+(16, INC)
+(16, SEMICOLON)
+(17, CLOSE_CURVED_BRACKET)

test/while_break_continue/while_break_continue6.tout

@@ -0,0 +1,58 @@
+(1, LITERAL, "x")
+(1, SET)
+(1, NUMBER, 0.0)
+(1, SEMICOLON)
+(2, WHILE)
+(2, OPEN_BRACKET)
+(2, LITERAL, "x")
+(2, LESS)
+(2, NUMBER, 3.0)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "y")
+(4, SET)
+(4, NUMBER, 0.0)
+(4, SEMICOLON)
+(5, WHILE)
+(5, OPEN_BRACKET)
+(5, LITERAL, "y")
+(5, LESS)
+(5, NUMBER, 3.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, LITERAL, "z")
+(7, SET)
+(7, NUMBER, 0.0)
+(7, SEMICOLON)
+(8, WHILE)
+(8, OPEN_BRACKET)
+(8, LITERAL, "z")
+(8, LESS)
+(8, NUMBER, 3.0)
+(8, CLOSE_BRACKET)
+(9, OPEN_CURVED_BRACKET)
+(10, LITERAL, "print")
+(10, OPEN_BRACKET)
+(10, LITERAL, "x")
+(10, COMMA)
+(10, STRING, " ")
+(10, COMMA)
+(10, LITERAL, "y")
+(10, COMMA)
+(10, STRING, " ")
+(10, COMMA)
+(10, LITERAL, "z")
+(10, CLOSE_BRACKET)
+(10, SEMICOLON)
+(11, LITERAL, "z")
+(11, INC)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(13, LITERAL, "y")
+(13, INC)
+(13, SEMICOLON)
+(14, CLOSE_CURVED_BRACKET)
+(15, LITERAL, "x")
+(15, INC)
+(15, SEMICOLON)
+(16, CLOSE_CURVED_BRACKET)

test/while_break_continue/while_break_continue7.tout

@@ -0,0 +1,40 @@
+(1, LITERAL, "x")
+(1, SET)
+(1, NUMBER, 0.0)
+(1, SEMICOLON)
+(2, WHILE)
+(2, OPEN_BRACKET)
+(2, LITERAL, "x")
+(2, LESS)
+(2, NUMBER, 10.0)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "x")
+(4, INC)
+(4, SEMICOLON)
+(5, IF)
+(5, OPEN_BRACKET)
+(5, LITERAL, "x")
+(5, EQUAL)
+(5, NUMBER, 2.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, CONTINUE)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(9, IF)
+(9, OPEN_BRACKET)
+(9, LITERAL, "x")
+(9, GREATER)
+(9, NUMBER, 6.0)
+(9, CLOSE_BRACKET)
+(10, OPEN_CURVED_BRACKET)
+(11, CONTINUE)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(13, LITERAL, "print")
+(13, OPEN_BRACKET)
+(13, LITERAL, "x")
+(13, CLOSE_BRACKET)
+(13, SEMICOLON)
+(14, CLOSE_CURVED_BRACKET)

test/while_break_continue/while_break_continue8.tout

@@ -0,0 +1,40 @@
+(1, LITERAL, "x")
+(1, SET)
+(1, NUMBER, 0.0)
+(1, SEMICOLON)
+(2, WHILE)
+(2, OPEN_BRACKET)
+(2, LITERAL, "x")
+(2, LESS)
+(2, NUMBER, 10.0)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "x")
+(4, INC)
+(4, SEMICOLON)
+(5, IF)
+(5, OPEN_BRACKET)
+(5, LITERAL, "x")
+(5, EQUAL)
+(5, NUMBER, 2.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, CONTINUE)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(9, IF)
+(9, OPEN_BRACKET)
+(9, LITERAL, "x")
+(9, EQUAL)
+(9, NUMBER, 6.0)
+(9, CLOSE_BRACKET)
+(10, OPEN_CURVED_BRACKET)
+(11, CONTINUE)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(13, LITERAL, "print")
+(13, OPEN_BRACKET)
+(13, LITERAL, "x")
+(13, CLOSE_BRACKET)
+(13, SEMICOLON)
+(14, CLOSE_CURVED_BRACKET)

test/while_break_continue/while_break_continue9.tout

@@ -0,0 +1,40 @@
+(1, LITERAL, "x")
+(1, SET)
+(1, NUMBER, 0.0)
+(1, SEMICOLON)
+(2, WHILE)
+(2, OPEN_BRACKET)
+(2, LITERAL, "x")
+(2, LESS)
+(2, NUMBER, 10.0)
+(2, CLOSE_BRACKET)
+(3, OPEN_CURVED_BRACKET)
+(4, LITERAL, "x")
+(4, INC)
+(4, SEMICOLON)
+(5, IF)
+(5, OPEN_BRACKET)
+(5, LITERAL, "x")
+(5, EQUAL)
+(5, NUMBER, 2.0)
+(5, CLOSE_BRACKET)
+(6, OPEN_CURVED_BRACKET)
+(7, CONTINUE)
+(7, SEMICOLON)
+(8, CLOSE_CURVED_BRACKET)
+(9, IF)
+(9, OPEN_BRACKET)
+(9, LITERAL, "x")
+(9, EQUAL)
+(9, NUMBER, 5.0)
+(9, CLOSE_BRACKET)
+(10, OPEN_CURVED_BRACKET)
+(11, BREAK)
+(11, SEMICOLON)
+(12, CLOSE_CURVED_BRACKET)
+(13, LITERAL, "print")
+(13, OPEN_BRACKET)
+(13, LITERAL, "x")
+(13, CLOSE_BRACKET)
+(13, SEMICOLON)
+(14, CLOSE_CURVED_BRACKET)