/* vim: set ts=4 sw=4 tw=99 et:

 *

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of SourcePawn.

 *

 * SourcePawn is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * SourcePawn is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * SourcePawn. If not, see http://www.gnu.org/licenses/.

 */

#include <string.h>

#include "../Zone.h"

#include "../FixedArray.h"

#include "../Heap.h"

#include "../Strings.h"

#include "../TypeManager.h"

#include "Parser.h"

#include "../Heap-inl.h"

using namespace ke;

Parser::Parser(Zone *zone, CompileContext &cc, const char *stream, size_t length)

  : zone_(zone),

    cc_(cc),

    pool_(zone_->pool()),

    scanner_(cc, stream, length),

    unbound_(NULL)

{

    unbound_ = new (pool_) PoolList<NameProxy *>();

    imports_ = new (pool_) PoolList<ImportStatement *>();

}

bool

Parser::peek(TokenKind kind)

{

    return scanner_.peek() == kind;

}

bool

Parser::match(TokenKind kind)

{

    if (!peek(kind))

        return false;

    scanner_.scan();

    return true;

}

bool

Parser::matchSemicolon()

{

    return expect(TOK_SEMICOLON);

}

bool

Parser::expect(TokenKind kind)

{

    TokenKind got = scanner_.scan();

    if (got == kind)

        return true;

    cc_.reportError(scanner_.begin(), Message_WrongToken, TokenNames[kind], TokenNames[got]);

    return false;

}

bool

Parser::matchName(String **name, TokenKind kind)

{

    assert(kind == TOK_NAME || kind == TOK_LABEL);

    *name = NULL;

    if (!match(kind))

        return false;

    *name = zone_->makeSymbol(scanner_.literal(), scanner_.literal_length());

    return true;

}

String *

Parser::expectName()

{

    if (!expect(TOK_NAME))

        return NULL;

    return zone_->makeSymbol(scanner_.literal(), scanner_.literal_length());

}

Expression *

Parser::primitive()

{

    TokenKind kind = scanner_.peek();

    switch (kind) {

      case TOK_FLOAT_LITERAL:

      {

        scanner_.scan();

        double value = Scanner::ParseDouble(scanner_.literal());

        return new (pool_) FloatLiteral(scanner_.begin(), value);

      }

      case TOK_HEX_LITERAL:

      {

        scanner_.scan();

        int value = strtol(scanner_.literal(), NULL, 16);

        return new (pool_) IntegerLiteral(scanner_.begin(), value);

      }

      case TOK_INTEGER_LITERAL:

      {

        scanner_.scan();

        int value = atoi(scanner_.literal());

        return new (pool_) IntegerLiteral(scanner_.begin(), value);

      }

      case TOK_TRUE:

      case TOK_FALSE:

        scanner_.scan();

        return new (pool_) BooleanLiteral(scanner_.begin(), kind);

      case TOK_STRING_LITERAL:

      {

        scanner_.scan();

        Local<String> string(zone_, zone_->makeSymbol(scanner_.literal(), scanner_.literal_length()));

        return new (pool_) StringLiteral(scanner_.begin(), string);

      }

      default:

      {

        if (kind != TOK_ERROR)

            cc_.reportError(scanner_.begin(), Message_ExpectedExpression, TokenNames[kind]);

        return NULL;

      }

    }

}

Expression *

Parser::fixedArrayLiteral()

{

    SourcePosition pos = scanner_.begin();

    ExpressionList *list = new (pool_) ExpressionList();

    do {

        // { } is an illegal array literal.

        if (list->length() > 0 && match(TOK_LBRACE))

            break;

        Expression *expr = NULL;

        if (peek(TOK_LBRACE))

            expr = fixedArrayLiteral();

        else

            expr = primitive();

        if (!expr)

            return NULL;

        if (!list->append(expr))

            return NULL;

        if (!match(TOK_COMMA)) {

            if (!expect(TOK_RBRACE))

                return NULL;

            break;

        }

    } while (true);

    return new (pool_) ArrayLiteral(pos, TOK_LBRACE, list);

}

Expression *

Parser::prefix()

{

    switch (scanner_.peek()) {

      case TOK_LPAREN:

      {

        scanner_.scan();

        Expression *expr = expression();

        if (!expr)

            return NULL;

        if (!expect(TOK_RPAREN))

            return NULL;

        return expr;

      }

      case TOK_NAME:

      {

        Local<String> name(zone_, expectName());

        if (!name)

            return NULL;

        return new (pool_) NameProxy(scanner_.begin(), name);

      }

      default:

        return primitive();

    }

}

// Parses only old-style declarations.

bool

Parser::typeAndName(Expression **type, String **namep)

{

    if (match(TOK_LABEL)) {

        // Old-style declaration:

        //   new X:type

        Local<String> name(zone_, zone_->makeSymbol(scanner_.literal(), scanner_.literal_length()));

        if (!name)

            return false;

        *type = new (pool_) NameProxy(scanner_.begin(), name);

        *namep = expectName();

        return !!*namep;

    }

    *type = NULL;

    *namep = expectName();

    return !!*namep;

}

// Parses both old and new style declarations.

bool

Parser::fullTypeAndName(Expression **type, String **namep, DeclKind kind)

{

    //   decl    ::= newdecl | olddecl

    //   newdecl ::= Type Ident

    //   olddecl ::= Label? (Ident | "...")

    //   type    ::= Ident

    //   label   ::= Ident ":"

    //

    if (match(TOK_LABEL)) {

        // We something of the form:

        //     Label Ident

        // or: Label "..."

        Local<String> name(zone_, zone_->makeSymbol(scanner_.literal(), scanner_.literal_length()));

        if (!name)

            return false;

        *type = new (pool_) NameProxy(scanner_.begin(), name);

        if (kind == DeclArg && match(TOK_ELLIPSES)) {

            *namep = NULL;

        } else {

            if ((*namep = expectName()) == NULL)

                return false;

        }

        return true;

    }

    Local<String> name(zone_, expectName());

    if (!name)

        return false;

    if (peek(TOK_NAME) || (kind == DeclArg && peek(TOK_ELLIPSES))) {

        // We got something of the form:

        //    Ident Ident

        *type = new (pool_) NameProxy(scanner_.begin(), name);

        if (peek(TOK_NAME)) {

            if ((*namep = expectName()) == NULL)

                return false;

        } else {

            *namep = NULL;

        }

        return true;

    }

    // We got something of the form:

    //    Ident

    *type = NULL;

    *namep = name;

    return true;

}

Expression *

Parser::call(Expression *callee)

{

    ExpressionList *arguments = new (pool_) ExpressionList();

    SourcePosition pos = scanner_.begin();

    expect(TOK_LPAREN);

    if (!match(TOK_RPAREN)) {

        while (true) {

            Expression *expr = expression();

            if (!expr)

                return NULL;

            if (!arguments->append(expr))

                return NULL;

            if (!match(TOK_COMMA))

                break;

        }

        if (!expect(TOK_RPAREN))

            return NULL;

    }

    return new (pool_) CallExpression(pos, callee, arguments);

}

Expression *

Parser::index(Expression *left)

{

    expect(TOK_LBRACKET);

    SourcePosition pos = scanner_.begin();

    Expression *expr = expression();

    if (!expr)

        return NULL;

    if (!expect(TOK_RBRACKET))

        return NULL;

    return new (pool_) IndexExpression(pos, left, expr);

}

Expression *

Parser::field(Expression *left)

{

    expect(TOK_DOT);

    SourcePosition pos = scanner_.begin();

    Local<String> name(zone_, expectName());

    if (!name)

        return NULL;

    return new (pool_) FieldExpression(pos, left, name);

}

Expression *

Parser::primary()

{

    Expression *expr = prefix();

    if (!expr)

        return NULL;

    for (;;) {

        switch (scanner_.peek()) {

          case TOK_LPAREN:

            if ((expr = call(expr)) == NULL)

                return NULL;

            break;

          case TOK_LBRACKET:

            if ((expr = index(expr)) == NULL)

                return NULL;

            break;

          case TOK_DOT:

            if ((expr = field(expr)) == NULL)

                return NULL;

            break;

          default:

            return expr;

        }

    }

}

Expression *

Parser::unary()

{

    TokenKind token = scanner_.peek();

    SourcePosition pos = scanner_.begin();

    switch (token) {

      case TOK_INCREMENT:

      case TOK_DECREMENT:

      {

        scanner_.scan();

        Expression *expr = unary();

        if (!expr)

            return NULL;

        return new (pool_) IncDecExpression(pos, token, expr, false);

      }

      case TOK_MINUS:

      case TOK_NOT:

      case TOK_TILDE:

      {

        scanner_.scan();

        Expression *expr = unary();

        if (!expr)

            return NULL;

        return new (pool_) UnaryExpression(pos, token, expr);

      }

      case TOK_SIZEOF:

      {

        scanner_.scan();

        if (!expect(TOK_LPAREN))

            return NULL;

        Expression *expr = unary();

        if (!expr)

            return NULL;

        if (!expect(TOK_RPAREN))

            return NULL;

        return new (pool_) UnaryExpression(pos, token, expr);

      }

      case TOK_LABEL:

      {

        scanner_.scan();

        Local<String> tag(zone_, zone_->makeSymbol(scanner_.literal(), scanner_.literal_length()));

        if (!tag)

            return NULL;

        NameProxy *proxy = new (pool_) NameProxy(scanner_.begin(), tag);

        Expression *expr = unary();

        if (!expr)

            return NULL;

        return new (pool_) UnaryExpression(pos, TOK_LABEL, expr, proxy);

      }

      default:

        break;

    }

    Expression *expr = primary();

    token = scanner_.peek();

    if (token == TOK_INCREMENT || token == TOK_DECREMENT) {

        scanner_.scan();

        return new (pool_) IncDecExpression(pos, token, expr, true);

    }

    return expr;

}

Expression *

Parser::multiplication()

{

    Expression *left = unary();

    do {

        if (!match(TOK_SLASH) && !match(TOK_STAR) && !match(TOK_PERCENT))

            break;

        SourcePosition pos = scanner_.begin();

        TokenKind kind = scanner_.last();

        Expression *right = unary();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    } while (left);

    return left;

}

Expression *

Parser::addition()

{

    Expression *left = multiplication();

    while (left) {

        if (!match(TOK_PLUS) && !match(TOK_MINUS))

            break;

        SourcePosition pos = scanner_.begin();

        TokenKind kind = scanner_.last();

        Expression *right = multiplication();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    }

    return left;

}

Expression *

Parser::shift()

{

    Expression *left = addition();

    while (left) {

        if (!match(TOK_SHL) && !match(TOK_SHR) && !match(TOK_USHR))

            break;

        SourcePosition pos = scanner_.begin();

        TokenKind kind = scanner_.last();

        Expression *right = addition();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    }

    return left;

}

Expression *

Parser::bitand_()

{

    Expression *left = shift();

    while (left) {

        if (!match(TOK_BITAND))

            break;

        SourcePosition pos = scanner_.begin();

        Expression *right = shift();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, TOK_BITAND, left, right);

    }

    return left;

}

Expression *

Parser::bitxor()

{

    Expression *left = bitand_();

    while (left) {

        if (!match(TOK_BITXOR))

            break;

        SourcePosition pos = scanner_.begin();

        Expression *right = shift();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, TOK_BITXOR, left, right);

    }

    return left;

}

Expression *

Parser::bitor_()

{

    Expression *left = bitxor();

    while (left) {

        if (!match(TOK_BITOR))

            break;

        SourcePosition pos = scanner_.begin();

        Expression *right = bitxor();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, TOK_BITOR, left, right);

    }

    return left;

}

Expression *

Parser::relational()

{

    Expression *left = bitor_();

    while (left) {

        TokenKind kind = scanner_.peek();

        if (kind < TOK_LT || kind > TOK_GE)

            break;

        scanner_.scan();

        SourcePosition pos = scanner_.begin();

        Expression *right = shift();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    }

    return left;

}

Expression *

Parser::equals()

{

    Expression *left = relational();

    while (left) {

        if (!match(TOK_EQUALS) && !match(TOK_NOTEQUALS))

            break;

        TokenKind kind = scanner_.last();

        SourcePosition pos = scanner_.begin();

        Expression *right = relational();

        if (!right)

            return NULL;

        left = new (pool_) BinaryExpression(pos, kind, left, right);

    }

    return left;

}

Expression *

Parser::and_()

{

    Expression *left = equals();

    while (left) {

        if (!match(TOK_AND))

            break;

        SourcePosition pos = scanner_.begin();