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

 *

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of JITCraft.

 *

 * JITCraft 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.

 * 

 * Foobar 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

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

 */

#ifndef _include_jc_stack_h_

#define _include_jc_stack_h_

#include <stddef.h>

#include "Utility.h"

#include "Code.h"

#include "Functions.h"

#include "VirtualObjectVisitor.h"

namespace ke {

class Object;

class Array;

class Reference;

class Frame;

union LocalSlot

{

    int i32;

    float f;

    Address address;

    Object *obj;

    Array *array;

    Reference *ref;

};

struct Top

{

    LocalSlot *sp;

    bytecode *pc;

    Frame *fp;

    Top(LocalSlot *sp, bytecode *pc, Frame *fp)

      : sp(sp), pc(pc), fp(NULL)

    {

    }

    Top(LocalSlot *sp)

      : sp(sp), pc(NULL), fp(NULL)

    {

    }

};

class Frame

{

    friend class Stack;

    Frame *prev_;

    bytecode *prevpc_;

    Function *fun_;

    Code *code_;

    Address lifoPosition_;

  public:

    Frame(Frame *prev, bytecode *prevpc, Function *fun, Code *code, Address lifoPosition)

      : prev_(prev),

        prevpc_(prevpc),

        fun_(fun),

        code_(code),

        lifoPosition_(lifoPosition)

    {

    }

    LocalSlot *locals() {

        return reinterpret_cast<LocalSlot *>(this + 1);

    }

    LocalSlot *stackBase() {

        return locals() + code_->nlocals();

    }

    Function *fun() const {

        assert(fun_);

        return fun_;

    }

    Function *maybeFun() const {

        return fun_;

    }

    Code *code() const {

        return code_;

    }

    Frame *prev() const {

        return prev_;

    }

    bytecode *prevpc() const {

        return prevpc_;

    }

    Address lifoPosition() const {

        return lifoPosition_;

    }

    LocalSlot &arg(unsigned slot) {

        assert(slot < fun()->nargs());

        return *(reinterpret_cast<LocalSlot *>(this) - slot - 1);

    }

    void accept(VirtualObjectVisitor *visitor);

};

class Stack

{

    char *buffer_;

    char *end_;

    Top *top_;

  private:

    static const size_t STACK_SIZE = 1024 * 1024;

  public:

    Stack();

    ~Stack();

    bool initialize();

  public:

    Frame *pushFrame(Function *fun);

    Frame *popFrame();

    Top *top() {

        return top_;

    }

    void setTop(Top *top) {

        top_ = top;

    }

    Top begin() {

        return Top((LocalSlot *)buffer_);

    }

    bool isInCallStack(Handle<Module> module);

    void accept(VirtualObjectVisitor *visitor);

};

}

#endif // _include_jc_stack_h_