/* 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;

class Stack;

union LocalSlot

{

    int i32;

    float f;

    Address address;

    Object *obj;

    Array *array;

    Reference *ref;

};

struct Top

{

    LocalSlot *sp;

    bytecode *pc;

    Frame *fp;

};

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

};

// RAII object for calling a function from C++.

class InvokeArgs

{

    friend class Stack;

    Stack *stack_;

    LocalSlot *args_;

    unsigned nargs_;

  public:

    InvokeArgs()

      : stack_(NULL),

        args_(NULL),

        nargs_(0)

    {

    }

    ~InvokeArgs();

    LocalSlot &arg(unsigned index) {

        assert(index < nargs_);

        return args_[nargs_ - index - 1];

    }

};

class Stack

{

    friend class InvokeArgs;

  private:

    static const size_t STACK_SIZE = 1024 * 1024;

  public:

    Stack();

    ~Stack();

    bool initialize();

  public:

    Frame *pushInlineFrame(Handle<Function> fun);

    Frame *popInlineFrame();

    bool pushInvokeFrame(Handle<Function> fun, InvokeArgs &args);

    Top *top() {

        return &top_;

    }

    bool isInCallStack(Handle<Module> module);

    void accept(VirtualObjectVisitor *visitor);

  private:

    void popInvokeFrame(InvokeArgs &args);

  private:

    char *buffer_;

    char *end_;

    Top top_;

};

}

#endif // _include_jc_stack_h_