/*
    * Copyright (c) 2001, Zoltan Farkas All Rights Reserved.
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    *
    * This library 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 Lesser General Public
   * License along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
   */
  
  package net.sf.zel.vm;
  
  
  import java.io.InputStream;
  import java.io.PrintStream;
  import java.util.Map;
  import java.util.concurrent.Future;
  import java.util.concurrent.ThreadPoolExecutor;
  
  
  /**
   * Virtual Machine Execution Context
   * 
   * @author zoly
   */
  public class ExecutionContext
          implements Cloneable
  {
  
      public ThreadPoolExecutor execService;
  
      public ResultCache resultCache;
  
      /**
       * The virtual machine heap
       */
      public Map heap = null;
  
      /**
       * current memory context
       */
      public Map memContext = null;
  
      /**
       * the program
       */
      public Program code = null;
      
      /**
       * The Instruction pointer
       */
      public int ip = 0;
      
      /**
       * The halt register
       */
      public boolean terminated = false;
      
      /**
       * The main stack
       */
      public SimpleStack stack;
      
      /**
       * The memory context stack
       */
      public SimpleStack memContextStack = new SimpleStack(32);
      
      /**
       * Standard Input
       */
      public InputStream in = null;
      
      /**
       * Standard Output
       */
      public PrintStream out = null;
      
      /**
       * Standard Error Output
       */
      public PrintStream err = null;
  
  
      /**
       * The parent Execution Context
       */
      public ExecutionContext parent = null;
  
  
      /**
      * Default constructor - private, does some init
      */
     private ExecutionContext()
     {
         this.in = System.in;
         this.out = System.out;
         this.err = System.err;
     }
 
     /**
      * Initializes execution context with MAP based heap memory
      *
      * @param program Program
      * @param heap Map
      */
     public ExecutionContext(Program program, java.util.Map heap, ThreadPoolExecutor execService)
     {
         this();
         code = program;
         this.heap = heap;
         this.memContext = heap;
         this.execService= execService;
         init();
     }
 
 
     private void init()
     {
         this.stack = new SimpleStack(32);
         if (execService == null)
         {
             this.stack = new SimpleStack(32);
             this.resultCache = new SimpleResultCache();
         }
         else
         {
             this.resultCache = new SynchronizedResultCache();
         }
     }
 
 
     /**
      * aditional constructor that allows you to set the standard Input/Output streams
      * @param program
      * @param heap
      * @param in
      * @param out
      * @param err 
      */
     public ExecutionContext(Program program, java.util.Map heap, InputStream in, PrintStream out, PrintStream err, ThreadPoolExecutor execService)
     {
         code = program;
         this.heap = heap;
         this.memContext = heap;
         this.in = in;
         this.out = out;
         this.err = err;
         this.execService= execService;
         init();
     }
 
     /**
      * pops object out of stack
      * @return Object
      */
 
     public Object popSyncStackVal()
     {
         Object result = this.stack.pop();
         if (result instanceof Future<?>)
             try
             {
                 return ((Future<Object>) result).get();
             } catch (Exception ex)
             {
                 throw new RuntimeException(ex);
             }
         else return result;
     }
 
 
 
     public ExecutionContext getSubProgramContext(Program program) 
     {
         ExecutionContext ec;
         try
         {
             ec = (ExecutionContext) this.clone();
         } catch (CloneNotSupportedException ex)
         {
             throw new RuntimeException("Execution Context must be clonable", ex);
         }
         ec.code = program;
         ec.ip =0;        
         ec.stack = new SimpleStack(32);        
         ec.parent = this;
         return ec;
     }
 
 
     public Map newMem()
     {
         try
         {
             return this.memContext.getClass().newInstance();
         } catch (InstantiationException ex)
         {
             throw new RuntimeException(ex);
         } catch (IllegalAccessException ex)
         {
             throw new RuntimeException(ex);
         }
     }
 
     /**
      * Constructs string with the execution context
      * @return String
      */
     @Override
     public String toString()
     {
         StringBuilder result = new StringBuilder();
         result.append("\nStack:");
         result.append(stack.toString());
         result.append("\nMemCtx:");
         result.append(memContext); 
         result.append("\nHeap:");
         result.append(heap);  
         result.append("\nProgram:");
         result.append(code);
         result.append("\nInstruction pointer: " + ip);
         if (parent != null)
             result.append("\n Called from: ").append(parent);
         return result.toString();
     }
 }