/* 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 "Parser.h"

#include "FixedArray.h"

#include "Heap.h"

#include "Strings.h"

#include "TypeManager.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),

    scope_(NULL),

    unbound_(NULL)

{

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

}

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;

}

Scope *

Parser::enterScope(Scope::Kind kind)

{

    scope_ = new (pool_) Scope(pool_, kind, scope_);

    if (!scope_->initialize())

        return NULL;

    return scope_;

}

NameProxy *

Parser::bind(Handle<String> name)

{

    BoundName *bound = scope_->lookup(name);

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

    if (!bound && !unbound_->append(proxy))

        return NULL;

    return proxy;

}

BoundName *

Parser::bindType(Handle<String> name)

{

    if (BoundName *binding = scope_->lookup(name))

        return binding;

    return new (pool_) UnboundName(scope_, name);

}

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());

}

void

Parser::redeclarationError(BoundName *other)

{

    cc_.reportError(scanner_.begin(), Message_RedeclaredName, other->name()->chars(),

                    other->pos().line, other->pos().col);

}

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<ByteArray> array(zone_, ByteArray::New(zone_, scanner_.literal_length() + 1));

        if (!array)

            return NULL;

        memcpy(array->raw(), scanner_.literal(), scanner_.literal_length() + 1);

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

      }

      default:

      {

        if (kind != TOK_ERROR)

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

        return NULL;

      }

    }

}

Expression *

Parser::arrayLiteral(TokenKind kind)

{

    assert(kind == TOK_LBRACE || kind == TOK_LBRACKET);

    TokenKind close = (kind == TOK_LBRACE)

                      ? TOK_RBRACE

                      : TOK_RBRACKET;

    SourcePosition pos = scanner_.begin();

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

    do {

        if (match(close))

            break;

        Expression *expr = NULL;

        if (kind == TOK_LBRACE) {

            if (peek(TOK_LBRACE))

                expr = arrayLiteral(TOK_LBRACE);

            else

                expr = primitive();

        } else {

            expr = expression();

        }

        if (!expr)

            return NULL;

        if (!list->append(expr))

            return NULL;

        if (!match(TOK_COMMA)) {

            if (!expect(close))

                return NULL;

            break;

        }

    } while (true);

    return new (pool_) ArrayLiteral(pos, kind, 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 bind(name);

      }

      default:

        return primitive();

    }

}

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;

        BoundName *type = NULL;

        if (tag)

            type = bindType(tag);

        Expression *expr = unary();

        if (!expr)

            return NULL;

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

      }

      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();

        Expression *right = equals();

        if (!right)

            return NULL;

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

    }

    return left;

}

Expression *

Parser::or_()

{

    Expression *left = and_();

    while (left) {

        if (!match(TOK_OR))

            break;

        SourcePosition pos = scanner_.begin();

        Expression *right = and_();

        if (!right)

            return NULL;

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

    }

    return left;

}