/* 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;
class Zone;
class Module;
    
union LocalSlot
{
    int i32;
    float f;
    Address address;
    Object *obj;
    Array *array;
    Reference *ref;
    Function *fun;
    Module *module;
};

struct Top
{
    LocalSlot *sp;
    bytecode *pc;
    Frame *fp;
};

class Frame
{
    friend class Stack;

    Frame *prev_;
    bytecode *prevpc_;
    union {
        Function *fun_;
        Native *native_;
        Object *callee_;
    };
    Code *code_;

    // Position of the LIFO stack at function entry.
    Address lifoPosition_;
    
    // Loop nesting level, for LIFO stack balancing. LIFO stack balancing
    // is not strictly required, but it helps to avoid unnecessary waste,
    // since once the LIFO stack is depleted, we must use the heap instead.
    unsigned loopDepth_;

  public:
    Frame(Frame *prev, bytecode *prevpc, Function *fun, Code *code, Address lifoPosition)
      : prev_(prev),
        prevpc_(prevpc),
        fun_(fun),
        code_(code),
        lifoPosition_(lifoPosition),
        loopDepth_(0)
    {
    }

    Frame(Frame *prev, bytecode *prevpc, Native *native, Address lifoPosition)
      : prev_(prev),
        prevpc_(prevpc),
        native_(native),
        code_(NULL),
        lifoPosition_(lifoPosition)
    {
    }

    Address *loopStack() {
        return reinterpret_cast<Address *>(this + 1);
    }
    LocalSlot *locals() {
        return reinterpret_cast<LocalSlot *>(loopStack() + code_->maxLoopDepth());
    }
    LocalSlot *stackBase() {
        return locals() + code_->nlocals();
    }
    Function *fun() const {
        assert(fun_ && callee_->is(MapKind_Function));
        return fun_;
    }
    Function *maybeFun() const {
        return (fun_ && callee_->is(MapKind_Function)) ? fun_ : NULL;
    }
    bool isNative() const {
        return callee_ && callee_->is(MapKind_Native);
    }
    Native *native() const {
        assert(isNative());
        return native_;
    }
    Code *code() const {
        assert(code_);
        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 enterLoop(Zone *zone);
    void leaveLoop(Zone *zone);
    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];
    }
};

// RAII object for calling a native from C++.
class NativeArgs
{
    friend class Stack;

    Stack *stack_;
    LocalSlot *argsBase_;

  public:
    NativeArgs()
      : stack_(NULL),
        argsBase_(NULL)
    {
    }

    ~NativeArgs();

    intptr_t *args() {
        return reinterpret_cast<intptr_t *>(argsBase_);
    }
};

class Stack
{
    friend class InvokeArgs;
    friend class NativeArgs;

  private:
    static const size_t STACK_SIZE = 1024 * 1024;

  public:
    Stack(Zone *zone);
    ~Stack();

    bool initialize();

  public:
    Frame *pushInlineFrame(Handle<Function> fun);
    Frame *popInlineFrame();

    bool pushInvokeFrame(Handle<Function> fun, InvokeArgs &args);
    bool pushModuleFrame(Handle<Module> module, InvokeArgs &args);
    bool pushNativeFrame(Handle<Native> native, NativeArgs &args, unsigned argc);

    Top *top() {
        return &top_;
    }
    bool isInCallStack(Handle<Module> module);
    void accept(VirtualObjectVisitor *visitor);

  private:
    void popInvokeFrame(InvokeArgs &args);
    void popNativeFrame(NativeArgs &args);

  private:
    Zone *zone_;
    char *buffer_;
    char *end_;
    Top top_;
};

class StackIter
{
    bytecode *pc_;
    Frame *fp_;

  public:
    StackIter(Zone *zone);

    bool done() const;
    const char *function() const;
    unsigned lineNumber() const;
    const char *source() const;
    void prev();
};

}

#endif // _include_jc_stack_h_