internal LoginResponse(string token)
 {
     Success  = true;
     Userdata = new TokenStruct {
         Token = token
     };
 }
Exemplo n.º 2
0
        public void TestNextToken()
        {
            const string input = @"
                            let five = 5;
                            let ten = 10;
                            
                            let add = fn(x, y) {
                                x + y;
                            }

                            let result = add(five, ten);

                            !-/*5;

                            1 < 1 > 1;

                            if (1 < 2) {
                                return true;
                            } else {
                                return false;
                            }

                            7 == 7;
                            5 != 5;
                        ";

            var data = new TokenStruct[73];

            data[0]  = new TokenStruct(TokenType.LET, "let");
            data[1]  = new TokenStruct(TokenType.IDENT, "five");
            data[2]  = new TokenStruct(TokenType.ASSIGN, "=");
            data[3]  = new TokenStruct(TokenType.INT, "5");
            data[4]  = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[5]  = new TokenStruct(TokenType.LET, "let");
            data[6]  = new TokenStruct(TokenType.IDENT, "ten");
            data[7]  = new TokenStruct(TokenType.ASSIGN, "=");
            data[8]  = new TokenStruct(TokenType.INT, "10");
            data[9]  = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[10] = new TokenStruct(TokenType.LET, "let");
            data[11] = new TokenStruct(TokenType.IDENT, "add");
            data[12] = new TokenStruct(TokenType.ASSIGN, "=");
            data[13] = new TokenStruct(TokenType.FUNCTION, "fn");
            data[14] = new TokenStruct(TokenType.LPAREN, "(");
            data[15] = new TokenStruct(TokenType.IDENT, "x");
            data[16] = new TokenStruct(TokenType.COMMA, ",");
            data[17] = new TokenStruct(TokenType.IDENT, "y");
            data[18] = new TokenStruct(TokenType.RPAREN, ")");
            data[19] = new TokenStruct(TokenType.LBRACE, "{");
            data[20] = new TokenStruct(TokenType.IDENT, "x");
            data[21] = new TokenStruct(TokenType.PLUS, "+");
            data[22] = new TokenStruct(TokenType.IDENT, "y");
            data[23] = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[24] = new TokenStruct(TokenType.RBRACE, "}");
            data[25] = new TokenStruct(TokenType.LET, "let");
            data[26] = new TokenStruct(TokenType.IDENT, "result");
            data[27] = new TokenStruct(TokenType.ASSIGN, "=");
            data[28] = new TokenStruct(TokenType.IDENT, "add");
            data[29] = new TokenStruct(TokenType.LPAREN, "(");
            data[30] = new TokenStruct(TokenType.IDENT, "five");
            data[31] = new TokenStruct(TokenType.COMMA, ",");
            data[32] = new TokenStruct(TokenType.IDENT, "ten");
            data[33] = new TokenStruct(TokenType.RPAREN, ")");
            data[34] = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[35] = new TokenStruct(TokenType.BANG, "!");
            data[36] = new TokenStruct(TokenType.MINUS, "-");
            data[37] = new TokenStruct(TokenType.SLASH, "/");
            data[38] = new TokenStruct(TokenType.ASTERISK, "*");
            data[39] = new TokenStruct(TokenType.INT, "5");
            data[40] = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[41] = new TokenStruct(TokenType.INT, "1");
            data[42] = new TokenStruct(TokenType.LT, "<");
            data[43] = new TokenStruct(TokenType.INT, "1");
            data[44] = new TokenStruct(TokenType.GT, ">");
            data[45] = new TokenStruct(TokenType.INT, "1");
            data[46] = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[47] = new TokenStruct(TokenType.IF, "if");
            data[48] = new TokenStruct(TokenType.LPAREN, "(");
            data[49] = new TokenStruct(TokenType.INT, "1");
            data[50] = new TokenStruct(TokenType.LT, "<");
            data[51] = new TokenStruct(TokenType.INT, "2");
            data[52] = new TokenStruct(TokenType.RPAREN, ")");
            data[53] = new TokenStruct(TokenType.LBRACE, "{");
            data[54] = new TokenStruct(TokenType.RETURN, "return");
            data[55] = new TokenStruct(TokenType.TRUE, "true");
            data[56] = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[57] = new TokenStruct(TokenType.RBRACE, "}");
            data[58] = new TokenStruct(TokenType.ELSE, "else");
            data[59] = new TokenStruct(TokenType.LBRACE, "{");
            data[60] = new TokenStruct(TokenType.RETURN, "return");
            data[61] = new TokenStruct(TokenType.FALSE, "false");
            data[62] = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[63] = new TokenStruct(TokenType.RBRACE, "}");
            data[64] = new TokenStruct(TokenType.INT, "7");
            data[65] = new TokenStruct(TokenType.EQ, "==");
            data[66] = new TokenStruct(TokenType.INT, "7");
            data[67] = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[68] = new TokenStruct(TokenType.INT, "5");
            data[69] = new TokenStruct(TokenType.NOT_EQ, "!=");
            data[70] = new TokenStruct(TokenType.INT, "5");
            data[71] = new TokenStruct(TokenType.SEMMICOLON, ";");
            data[72] = new TokenStruct(TokenType.EOF, "0");

            var lexer = new Lexer(input);

            foreach (var tokenStruct in data)
            {
                var token = lexer.NextToken();

                Assert.Equal(tokenStruct.Type, token.Type);
                Assert.Equal(tokenStruct.Literal, token.Literal);
            }
        }
        public string Format(string jsScript)
        {
            indentString = HTMLUtility.IndentString;
            input = jsScript;

            lastWord = string.Empty;
            lastToken = new TokenStruct(Token.START_EXPR, string.Empty);
            output = new Stack<string>();
            doJustClosed = false;
            varLine = false;
            varLineTainted = false;
            inCase = false;
            currentToken = new TokenStruct();

            modes = new Stack<Mode>();
            setMode(Mode.BLOCK);

            pos = 0;
            while (true)
            {
                currentToken = getNextToken();
                var t = currentToken;
                if (t.tokenType == Token.EOF)
                    break;
                switch (t.tokenType)
                {
                    case Token.WORD:
                        var arr = new string[] { "else", "catch", "finally" };
                        if (doJustClosed)
                        {
                            printSpace();
                            printToken();
                            printSpace();
                            doJustClosed = false;
                            break;
                        }

                        if (t.tokenText == "case" || t.tokenText == "default")
                        {
                            if (lastToken.tokenText == ":")
                            {
                                removeIndent();
                            }
                            else
                            {
                                unindent();
                                printNewLine();
                                indent();
                            }
                            printToken();
                            inCase = true;
                            break;
                        }
                        Prefix prefix = Prefix.NONE;
                        if (lastToken.tokenType == Token.END_BLOCK)
                        {
                            if (!(arr).Contains(t.tokenText.ToLower()))
                            {
                                prefix = Prefix.NEWLINE;
                            }
                            else
                            {
                                prefix = Prefix.SPACE;
                                printSpace();
                            }
                        }
                        else if (lastToken.tokenType == Token.SEMICOLON && (currentMode == Mode.BLOCK || currentMode == Mode.DO_BLOCK))
                        {
                            prefix = Prefix.NEWLINE;
                        }
                        else if (lastToken.tokenType == Token.SEMICOLON && currentMode == Mode.EXPRESSION)
                        {
                            prefix = Prefix.SPACE;
                        }
                        else if (lastToken.tokenType == Token.STRING)
                        {
                            prefix = Prefix.NEWLINE;
                        }
                        else if (lastToken.tokenType == Token.WORD)
                        {
                            prefix = Prefix.SPACE;
                        }
                        else if (lastToken.tokenType == Token.START_BLOCK)
                        {
                            prefix = Prefix.NEWLINE;
                        }
                        else if (lastToken.tokenType == Token.END_EXPR)
                        {
                            printSpace();
                            prefix = Prefix.NEWLINE;
                        }

                        if (lastToken.tokenType != Token.END_BLOCK && arr.Contains(t.tokenText.ToLower()))
                        {
                            printNewLine();
                        }
                        else if (lineStarters.Contains(t.tokenText) || prefix == Prefix.NEWLINE)
                        {
                            if (lastToken.tokenText == "else")
                            {
                                printSpace();
                            }
                            else if ((lastToken.tokenType == Token.START_EXPR || lastToken.tokenText == "=" ||
                                lastToken.tokenText == ",") && t.tokenText == "function")
                            {

                            }
                            else if (lastToken.tokenType == Token.WORD && (lastToken.tokenText == "return" || lastToken.tokenText == "throw"))
                            {
                                printSpace();
                            }
                            else if (lastToken.tokenType != Token.END_EXPR)
                            {
                                if ((lastToken.tokenType != Token.START_EXPR || t.tokenText != "var") &&
                                    lastToken.tokenText != ":")
                                {
                                    if (t.tokenText == "if" && lastToken.tokenType == Token.WORD
                                        && lastWord == "else")
                                    {
                                        printSpace();
                                    }
                                    else
                                    {
                                        printNewLine();
                                    }
                                }
                            }
                            else
                            {
                                if (lineStarters.Contains(t.tokenText) && lastToken.tokenText != ")")
                                {
                                    printNewLine();
                                }
                            }
                        }
                        else if (prefix == Prefix.SPACE)
                        {
                            printSpace();
                        }
                        printToken();
                        lastWord = t.tokenText;

                        if (t.tokenText == "var")
                        {
                            varLine = true;
                            varLineTainted = false;
                        }
                        if (t.tokenText == "if" || t.tokenText == "else")
                        {
                            ifFlag = true;
                        }

                        break;
                    case Token.OPERATOR:
                        bool startDelim = true;
                        bool endDelim = true;
                        if (varLine && t.tokenText != ",")
                        {
                            varLineTainted = true;
                            if (t.tokenText == ":")
                            {
                                varLine = false;
                            }
                        }
                        if (varLine && t.tokenText == "," && currentMode == Mode.EXPRESSION)
                        {
                            varLineTainted = false;
                        }
                        if (t.tokenText == ":" && inCase)
                        {
                            printToken();
                            printNewLine();
                            break;
                        }
                        if (t.tokenText == "::")
                        {
                            printToken();
                            break;
                        }

                        inCase = false;

                        if (t.tokenText == ",")
                        {
                            if (varLine)
                            {
                                if (varLineTainted)
                                {
                                    printToken();
                                    printNewLine();
                                    varLineTainted = false;
                                }
                                else
                                {
                                    printToken();
                                    printSpace();
                                }
                            }
                            else if (lastToken.tokenType == Token.END_BLOCK)
                            {
                                printToken();
                                printNewLine();
                            }
                            else
                            {
                                if (currentMode == Mode.BLOCK)
                                {
                                    printToken();
                                    printNewLine();
                                }
                                else
                                {
                                    printToken();
                                    printSpace();
                                }
                            }
                            break;
                        }
                        else if (t.tokenText == "--" || t.tokenText == "++")
                        {
                            if (lastToken.tokenText == ";")
                            {
                                startDelim = true;
                                endDelim = false;
                            }
                            else
                            {
                                startDelim = endDelim = false;
                            }
                        }else if ( t.tokenText == "!" && lastToken.tokenType == Token.START_EXPR)
                        {
                            startDelim = endDelim = false;
                        }
                        else if (lastToken.tokenType == Token.OPERATOR)
                        {
                            startDelim = endDelim = false;
                        }
                        else if (lastToken.tokenType == Token.END_EXPR)
                        {
                            startDelim = endDelim = true;
                        }
                        else if (t.tokenText == ".")
                        {
                            startDelim = endDelim = false;
                        }
                        else if (t.tokenText == ":")
                        {
                            startDelim = Regex.IsMatch(lastToken.tokenText, @"^\d+?");
                        }
                        if(startDelim)
                            printSpace();
                        printToken();
                        if(endDelim)
                            printSpace();
                        break;
                    case Token.START_EXPR:
                        varLine = false;
                        setMode(Mode.EXPRESSION);
                        if (lastToken.tokenText == ";")
                        {
                            printNewLine();
                        }
                        else if (lastToken.tokenType == Token.END_EXPR || lastToken.tokenType == Token.START_EXPR)
                        {
                        }
                        else if (lastToken.tokenType != Token.WORD && lastToken.tokenType != Token.OPERATOR)
                        {
                            printSpace();
                        }
                        else if (lineStarters.Contains(lastWord) && lastWord != "function")
                        {
                            printSpace();
                        }
                        printToken();
                        break;
                    case Token.END_EXPR:
                        printToken();
                        restoreMode();
                        break;
                    case Token.START_BLOCK:
                        if (lastWord == "do")
                            setMode(Mode.DO_BLOCK);
                        else
                            setMode(Mode.BLOCK);
                        if (lastToken.tokenType != Token.OPERATOR && lastToken.tokenType != Token.START_EXPR)
                        {
                            if (lastToken.tokenType == Token.START_BLOCK)
                                printNewLine();
                            else
                                printSpace();
                        }
                        printToken();
                        indent();
                        break;
                    case Token.END_BLOCK:
                        if (lastToken.tokenType == Token.START_BLOCK)
                        {
                            trimOutput();
                            unindent();
                        }
                        else {
                            unindent();
                            printNewLine();
                        }
                        printToken();
                        restoreMode();
                        break;
                    case Token.SEMICOLON:
                        printToken();
                        varLine = false;
                        break;
                    case Token.BLOCK_COMMENT:
                        printNewLine();
                        printToken();
                        printNewLine();
                        break;
                    case Token.COMMENT:
                        printSpace();
                        printToken();
                        printNewLine();
                        break;
                    case Token.STRING:
                        if (lastToken.tokenType == Token.START_BLOCK ||
                            lastToken.tokenType == Token.END_BLOCK ||
                            lastToken.tokenType == Token.SEMICOLON)
                        {
                            printNewLine();
                        }
                        else if (lastToken.tokenType == Token.WORD)
                        {
                            printSpace();
                        }
                        printToken();
                        break;
                    case Token.UNKNOWN:
                        printToken();
                        break;
                    default:
                        break;
                }
                lastToken = currentToken;
            }
            string r = output.ToArray().Aggregate("",(a,s) => s+a);
            r = Regex.Replace(r, @"\n+$", "");
            return r;
        }