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

     }

     void accept(VirtualObjectVisitor *visitor);

 };

 }

 #endif // _include_jc_stack_h_