/home/gian/Progetti/falcon/core/include/falcon/vmcontext.h

Go to the documentation of this file.

/*
   FALCON - The Falcon Programming Language.
   FILE: flc_vmcontext.h

   Virtual Machine coroutine execution context.
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: mar nov 9 2004

   -------------------------------------------------------------------
   (C) Copyright 2004: the FALCON developers (see list in AUTHORS file)

   See LICENSE file for licensing details.
*/

#ifndef flc_vmcontext_H
#define flc_vmcontext_H

#include <falcon/setup.h>
#include <falcon/types.h>
#include <falcon/genericvector.h>
#include <falcon/genericlist.h>
#include <falcon/basealloc.h>
#include <falcon/livemodule.h>
#include <falcon/stackframe.h>

namespace Falcon {

class Symbol;
class Item;
class VMSemaphore;

class FALCON_DYN_CLASS VMContext: public BaseAlloc
{
   Item m_regA;
   Item m_regB;

   //Item m_regS1;
   Item m_regL1;
   Item m_regL2;
   Item m_regBind;
   Item m_regBindP;

   ItemArray m_stack;
   VMSemaphore *m_sleepingOn;

   const Symbol* m_symbol;

   LiveModule *m_lmodule;

   numeric m_schedule;

   int32 m_priority;

   uint32 m_pc;

   uint32 m_pc_next;

   uint32 m_stackBase;

   uint32 m_tryFrame;

   bool m_atomicMode;

   friend class VMSemaphore;

public:
   VMContext();
   VMContext( const VMContext& other );
   ~VMContext();

   void wakeup( bool signaled = false );

   void priority( int32 value ) { m_priority = value; }
   int32 priority() const { return m_priority; }

   void schedule( numeric value ) { m_schedule = value; }
   numeric schedule() const { return m_schedule; }

   void scheduleAfter( numeric secs );

   bool isWaitingForever() const { return m_sleepingOn != 0 && m_schedule < 0; }

   VMSemaphore* waitingOn() const { return m_sleepingOn; }

   void waitOn( VMSemaphore* sem, numeric value=-1 );
   void signaled();

   //===========================
   uint32& pc() { return m_pc; }
   const uint32& pc() const { return m_pc; }

   uint32& pc_next() { return m_pc_next; }
   const uint32& pc_next() const { return m_pc_next; }

   uint32& stackBase() { return m_stackBase; }
   const uint32& stackBase() const { return m_stackBase; }

   uint32& tryFrame() { return m_tryFrame; }
   const uint32& tryFrame() const { return m_tryFrame; }

   Item &regA() { return m_regA; }
   const Item &regA() const { return m_regA; }
   Item &regB() { return m_regB; }
   const Item &regB() const { return m_regB; }

   Item &regBind() { return m_regBind; }
   const Item &regBind() const { return m_regBind; }
   /*
   Item &regBind() { return currentFrame()->m_binding; }
   const Item &regBind() const { return currentFrame()->m_binding; }
   */
   Item &regBindP() { return m_regBindP; }
   const Item &regBindP() const { return m_regBindP; }

   Item &self() { return currentFrame()->m_self; }
   const Item &self() const { return currentFrame()->m_self; }

   /*
   Item &self() { return m_regS1; }
   const Item &self() const { return m_regS1; }
   */
   const Item &latch() const { return m_regL1; }
   Item &latch() { return m_regL1; }

   const Item &latcher() const { return m_regL2; }
   Item &latcher() { return m_regL2; }

   ItemArray &stack() { return m_stack; }
   const ItemArray &stack() const { return m_stack; }

   VMSemaphore *sleepingOn() const { return m_sleepingOn; }
   void sleepOn( VMSemaphore *sl ) { m_sleepingOn = sl; }

   ItemArray &globals() { return m_lmodule->globals(); }

   const ItemArray &globals() const { return m_lmodule->globals(); }

   LiveModule *lmodule() const { return m_lmodule; }

   void lmodule(LiveModule *lm) { m_lmodule = lm; }

   const Symbol *symbol() const { return m_symbol; }

   void symbol( const Symbol* s ) { m_symbol = s; }

   byte* code() const {
      fassert( symbol()->isFunction() );
      return symbol()->getFuncDef()->code();
   }

   StackFrame* currentFrame() const
   {
      return (StackFrame *) &m_stack[ stackBase() - VM_FRAME_SPACE ];
   }

   void createFrame( uint32 pcount, ext_func_frame_t frameEndFunc = 0 );

   bool atomicMode() const { return m_atomicMode; }
   void atomicMode( bool b ) { m_atomicMode = b; }

   void addLocals( uint32 space )
   {
      if ( stack().length() < stackBase() + space )
         stack().resize( stackBase() + space );
   }

   const Item *local( uint32 itemId ) const
   {
      return stack()[ stackBase() + itemId ].dereference();
   }

   Item *local( uint32 itemId )
   {
      return stack()[ stackBase() + itemId ].dereference();
   }

   void returnHandler( ext_func_frame_t callbackFunc )
   {
      currentFrame()->m_endFrameFunc = callbackFunc;
   }


   ext_func_frame_t returnHandler() const
   {
      if ( stackBase() > VM_FRAME_SPACE )
      {
         return currentFrame()->m_endFrameFunc;
      }
      return 0;
   }

   void pushParameter( const Item &item ) { stack().append(item); }

};

}

#endif

/* end of flc_vmcontext.h */

---