[bpt/guile.git] / src / vm.c

/* Copyright (C) 2001 Free Software Foundation, Inc.
 *
 * This program 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 2, or (at your option)
 * any later version.
 * 
 * This program 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 this software; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307 USA
 *
 * As a special exception, the Free Software Foundation gives permission
 * for additional uses of the text contained in its release of GUILE.
 *
 * The exception is that, if you link the GUILE library with other files
 * to produce an executable, this does not by itself cause the
 * resulting executable to be covered by the GNU General Public License.
 * Your use of that executable is in no way restricted on account of
 * linking the GUILE library code into it.
 *
 * This exception does not however invalidate any other reasons why
 * the executable file might be covered by the GNU General Public License.
 *
 * This exception applies only to the code released by the
 * Free Software Foundation under the name GUILE.  If you copy
 * code from other Free Software Foundation releases into a copy of
 * GUILE, as the General Public License permits, the exception does
 * not apply to the code that you add in this way.  To avoid misleading
 * anyone as to the status of such modified files, you must delete
 * this exception notice from them.
 *
 * If you write modifications of your own for GUILE, it is your choice
 * whether to permit this exception to apply to your modifications.
 * If you do not wish that, delete this exception notice.  */

#if HAVE_CONFIG_H
#  include <config.h>
#endif

#include <string.h>
#include "envs.h"
#include "frames.h"
#include "instructions.h"
#include "objcodes.h"
#include "programs.h"
#include "vm.h"

/* I sometimes use this for debugging. */
#define vm_puts(OBJ)				\
{						\
  scm_display (OBJ, scm_current_error_port ()); \
  scm_newline (scm_current_error_port ());      \
}

\f
/*
 * VM Continuation
 */

scm_t_bits scm_tc16_vm_cont;


#define SCM_VM_CONT_P(OBJ)	SCM_SMOB_PREDICATE (scm_tc16_vm_cont, OBJ)
#define SCM_VM_CONT_VP(CONT)	((struct scm_vm *) SCM_CELL_WORD_1 (CONT))

static SCM
capture_vm_cont (struct scm_vm *vp)
{
  struct scm_vm *p = scm_gc_malloc (sizeof (*p), "capture_vm_cont");
  p->stack_size = vp->stack_limit - vp->sp;
  p->stack_base = scm_gc_malloc (p->stack_size * sizeof (SCM),
				 "capture_vm_cont");
  p->stack_limit = p->stack_base + p->stack_size - 2;
  p->ip = vp->ip;
  p->sp = (SCM *) (vp->stack_limit - vp->sp);
  p->fp = (SCM *) (vp->stack_limit - vp->fp);
  memcpy (p->stack_base, vp->sp + 1, vp->stack_size * sizeof (SCM));
  SCM_RETURN_NEWSMOB (scm_tc16_vm_cont, p);
}

static void
reinstate_vm_cont (struct scm_vm *vp, SCM cont)
{
  struct scm_vm *p = SCM_VM_CONT_VP (cont);
  if (vp->stack_size < p->stack_size)
    {
      /* puts ("FIXME: Need to expand"); */
      abort ();
    }
  vp->ip = p->ip;
  vp->sp = vp->stack_limit - (int) p->sp;
  vp->fp = vp->stack_limit - (int) p->fp;
  memcpy (vp->sp + 1, p->stack_base, p->stack_size * sizeof (SCM));
}

static SCM
vm_cont_mark (SCM obj)
{
  SCM *p;
  struct scm_vm *vp = SCM_VM_CONT_VP (obj);
  for (p = vp->stack_base; p <= vp->stack_limit; p++)
    if (SCM_NIMP (*p))
      scm_gc_mark (*p);
  return SCM_BOOL_F;
}

static scm_sizet
vm_cont_free (SCM obj)
{
  struct scm_vm *p = SCM_VM_CONT_VP (obj);

  scm_gc_free (p->stack_base, p->stack_size * sizeof (SCM), "stack-base");
  scm_gc_free (p, sizeof (struct scm_vm), "vm");

  return 0;
}

\f
/*
 * VM Internal functions
 */

SCM_SYMBOL (sym_vm_run, "vm-run");
SCM_SYMBOL (sym_vm_error, "vm-error");

static scm_byte_t *
vm_fetch_length (scm_byte_t *ip, size_t *lenp)
{
  /* NOTE: format defined in system/vm/conv.scm */
  *lenp = *ip++;
  if (*lenp < 254)
    return ip;
  else if (*lenp == 254)
    {
      int b1 = *ip++;
      int b2 = *ip++;
      *lenp = (b1 << 8) + b2;
    }
  else
    {
      int b1 = *ip++;
      int b2 = *ip++;
      int b3 = *ip++;
      int b4 = *ip++;
      *lenp = (b1 << 24) + (b2 << 16) + (b3 << 8) + b4;
    }
  return ip;
}

static SCM
vm_heapify_frames_1 (struct scm_vm *vp, SCM *fp, SCM *sp, SCM **destp)
{
  SCM frame;
  SCM *dl = SCM_FRAME_DYNAMIC_LINK (fp);
  SCM *src = SCM_FRAME_UPPER_ADDRESS (fp);
  SCM *dest = SCM_FRAME_LOWER_ADDRESS (fp);

  if (!dl)
    {
      /* The top frame */
      frame = scm_c_make_heap_frame (fp);
      fp = SCM_HEAP_FRAME_POINTER (frame);
      SCM_FRAME_HEAP_LINK (fp) = SCM_BOOL_T;
    }
  else
    {
      /* Child frames */
      SCM link = SCM_FRAME_HEAP_LINK (dl);
      if (!SCM_FALSEP (link))
	link = SCM_FRAME_LOWER_ADDRESS (dl)[-1]; /* self link */
      else
	link = vm_heapify_frames_1 (vp, dl, dest - 1, &dest);
      frame = scm_c_make_heap_frame (fp);
      fp = SCM_HEAP_FRAME_POINTER (frame);
      SCM_FRAME_HEAP_LINK (fp)    = link;
      SCM_FRAME_SET_DYNAMIC_LINK (fp, SCM_HEAP_FRAME_POINTER (link));
    }

  /* Move stack data */
  for (; src <= sp; src++, dest++)
    *dest = *src;
  *destp = dest;

  return frame;
}

static SCM
vm_heapify_frames (SCM vm)
{
  struct scm_vm *vp = SCM_VM_DATA (vm);
  if (SCM_FALSEP (SCM_FRAME_HEAP_LINK (vp->fp)))
    {
      SCM *dest;
      vp->this_frame = vm_heapify_frames_1 (vp, vp->fp, vp->sp, &dest);
      vp->fp = SCM_HEAP_FRAME_POINTER (vp->this_frame);
      vp->sp = dest - 1;
    }
  return vp->this_frame;
}

\f
/*
 * VM
 */

#define VM_DEFAULT_STACK_SIZE	(16 * 1024)

#define VM_REGULAR_ENGINE	0
#define VM_DEBUG_ENGINE		1

#if 0
#define VM_NAME   vm_regular_engine
#define VM_ENGINE VM_REGULAR_ENGINE
#include "vm_engine.c"
#undef VM_NAME
#undef VM_ENGINE
#endif

#define VM_NAME	  vm_debug_engine
#define VM_ENGINE VM_DEBUG_ENGINE
#include "vm_engine.c"
#undef VM_NAME
#undef VM_ENGINE

scm_t_bits scm_tc16_vm;

static SCM the_vm;

static SCM
make_vm (void)
#define FUNC_NAME "make_vm"
{
  int i;
  struct scm_vm *vp = scm_gc_malloc (sizeof (struct scm_vm), "vm");

  vp->stack_size  = VM_DEFAULT_STACK_SIZE;
  vp->stack_base  = scm_gc_malloc (vp->stack_size * sizeof (SCM),
				   "stack-base");
  vp->stack_limit = vp->stack_base + vp->stack_size - 3;
  vp->ip    	  = NULL;
  vp->sp    	  = vp->stack_base - 1;
  vp->fp    	  = NULL;
  vp->time        = 0;
  vp->clock       = 0;
  vp->options     = SCM_EOL;
  vp->this_frame  = SCM_BOOL_F;
  vp->last_frame  = SCM_BOOL_F;
  for (i = 0; i < SCM_VM_NUM_HOOKS; i++)
    vp->hooks[i] = SCM_BOOL_F;
  SCM_RETURN_NEWSMOB (scm_tc16_vm, vp);
}
#undef FUNC_NAME

static SCM
vm_mark (SCM obj)
{
  int i;
  struct scm_vm *vp = SCM_VM_DATA (obj);

  /* mark the stack conservatively */
  scm_mark_locations ((SCM_STACKITEM *) vp->stack_base,
		      sizeof (SCM) * (vp->sp - vp->stack_base + 1));

  /* mark other objects  */
  for (i = 0; i < SCM_VM_NUM_HOOKS; i++)
    scm_gc_mark (vp->hooks[i]);
  scm_gc_mark (vp->this_frame);
  scm_gc_mark (vp->last_frame);
  return vp->options;
}

static scm_sizet
vm_free (SCM obj)
{
  struct scm_vm *vp = SCM_VM_DATA (obj);

  scm_gc_free (vp->stack_base, vp->stack_size * sizeof (SCM),
	       "stack-base");
  scm_gc_free (vp, sizeof (struct scm_vm), "vm");

  return 0;
}

SCM_SYMBOL (sym_debug, "debug");

SCM
scm_vm_apply (SCM vm, SCM program, SCM args)
#define FUNC_NAME "scm_vm_apply"
{
  SCM_VALIDATE_PROGRAM (1, program);
  return vm_run (vm, program, args);
}
#undef FUNC_NAME

/* Scheme interface */

SCM_DEFINE (scm_vm_version, "vm-version", 0, 0, 0,
	    (void),
	    "")
#define FUNC_NAME s_scm_vm_version
{
  return scm_from_locale_string (VERSION);
}
#undef FUNC_NAME

SCM_DEFINE (scm_the_vm, "the-vm", 0, 0, 0,
	    (),
	    "")
#define FUNC_NAME s_scm_the_vm
{
  return the_vm;
}
#undef FUNC_NAME


SCM_DEFINE (scm_vm_p, "vm?", 1, 0, 0,
	    (SCM obj),
	    "")
#define FUNC_NAME s_scm_vm_p
{
  return SCM_BOOL (SCM_VM_P (obj));
}
#undef FUNC_NAME

SCM_DEFINE (scm_make_vm, "make-vm", 0, 0, 0,
	    (void),
	    "")
#define FUNC_NAME s_scm_make_vm,
{
  return make_vm ();
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_ip, "vm:ip", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_ip
{
  SCM_VALIDATE_VM (1, vm);
  return scm_from_ulong ((unsigned long) SCM_VM_DATA (vm)->ip);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_sp, "vm:sp", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_sp
{
  SCM_VALIDATE_VM (1, vm);
  return scm_from_ulong ((unsigned long) SCM_VM_DATA (vm)->sp);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_fp, "vm:fp", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_fp
{
  SCM_VALIDATE_VM (1, vm);
  return scm_from_ulong ((unsigned long) SCM_VM_DATA (vm)->fp);
}
#undef FUNC_NAME

#define VM_DEFINE_HOOK(n)				\
{							\
  struct scm_vm *vp;					\
  SCM_VALIDATE_VM (1, vm);				\
  vp = SCM_VM_DATA (vm);				\
  if (SCM_FALSEP (vp->hooks[n]))			\
    vp->hooks[n] = scm_make_hook (SCM_I_MAKINUM (1));	\
  return vp->hooks[n];					\
}

SCM_DEFINE (scm_vm_boot_hook, "vm-boot-hook", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_boot_hook
{
  VM_DEFINE_HOOK (SCM_VM_BOOT_HOOK);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_halt_hook, "vm-halt-hook", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_halt_hook
{
  VM_DEFINE_HOOK (SCM_VM_HALT_HOOK);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_next_hook, "vm-next-hook", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_next_hook
{
  VM_DEFINE_HOOK (SCM_VM_NEXT_HOOK);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_break_hook, "vm-break-hook", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_break_hook
{
  VM_DEFINE_HOOK (SCM_VM_BREAK_HOOK);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_enter_hook, "vm-enter-hook", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_enter_hook
{
  VM_DEFINE_HOOK (SCM_VM_ENTER_HOOK);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_apply_hook, "vm-apply-hook", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_apply_hook
{
  VM_DEFINE_HOOK (SCM_VM_APPLY_HOOK);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_exit_hook, "vm-exit-hook", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_exit_hook
{
  VM_DEFINE_HOOK (SCM_VM_EXIT_HOOK);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_return_hook, "vm-return-hook", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_return_hook
{
  VM_DEFINE_HOOK (SCM_VM_RETURN_HOOK);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_option, "vm-option", 2, 0, 0,
	    (SCM vm, SCM key),
	    "")
#define FUNC_NAME s_scm_vm_option
{
  SCM_VALIDATE_VM (1, vm);
  return scm_assq_ref (SCM_VM_DATA (vm)->options, key);
}
#undef FUNC_NAME

SCM_DEFINE (scm_set_vm_option_x, "set-vm-option!", 3, 0, 0,
	    (SCM vm, SCM key, SCM val),
	    "")
#define FUNC_NAME s_scm_set_vm_option_x
{
  SCM_VALIDATE_VM (1, vm);
  SCM_VM_DATA (vm)->options
    = scm_assq_set_x (SCM_VM_DATA (vm)->options, key, val);
  return SCM_UNSPECIFIED;
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_stats, "vm-stats", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_stats
{
  SCM stats;

  SCM_VALIDATE_VM (1, vm);

  stats = scm_make_vector (SCM_I_MAKINUM (2), SCM_UNSPECIFIED);
  scm_vector_set_x (stats, SCM_I_MAKINUM (0),
		    scm_from_ulong (SCM_VM_DATA (vm)->time));
  scm_vector_set_x (stats, SCM_I_MAKINUM (1),
		    scm_from_ulong (SCM_VM_DATA (vm)->clock));

  return stats;
}
#undef FUNC_NAME

#define VM_CHECK_RUNNING(vm) 				\
  if (!SCM_VM_DATA (vm)->ip)				\
    SCM_MISC_ERROR ("Not running", SCM_LIST1 (vm))

SCM_DEFINE (scm_vm_this_frame, "vm-this-frame", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_this_frame
{
  SCM_VALIDATE_VM (1, vm);
  return SCM_VM_DATA (vm)->this_frame;
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_last_frame, "vm-last-frame", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_last_frame
{
  SCM_VALIDATE_VM (1, vm);
  return SCM_VM_DATA (vm)->last_frame;
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_fetch_code, "vm-fetch-code", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_fetch_code
{
  int i;
  SCM list;
  scm_byte_t *ip;
  struct scm_instruction *p;

  SCM_VALIDATE_VM (1, vm);
  VM_CHECK_RUNNING (vm);

  ip = SCM_VM_DATA (vm)->ip;
  p = SCM_INSTRUCTION (*ip);

  list = SCM_LIST1 (scm_str2symbol (p->name));
  for (i = 1; i <= p->len; i++)
    list = scm_cons (SCM_I_MAKINUM (ip[i]), list);
  return scm_reverse_x (list, SCM_EOL);
}
#undef FUNC_NAME

SCM_DEFINE (scm_vm_fetch_stack, "vm-fetch-stack", 1, 0, 0,
	    (SCM vm),
	    "")
#define FUNC_NAME s_scm_vm_fetch_stack
{
  SCM *sp;
  SCM ls = SCM_EOL;
  struct scm_vm *vp;

  SCM_VALIDATE_VM (1, vm);
  VM_CHECK_RUNNING (vm);

  vp = SCM_VM_DATA (vm);
  for (sp = vp->stack_base; sp <= vp->sp; sp++)
    ls = scm_cons (*sp, ls);
  return ls;
}
#undef FUNC_NAME

\f
/*
 * Initialize
 */

void
scm_init_vm (void)
{
  scm_init_frames ();
  scm_init_instructions ();
  scm_init_objcodes ();
  scm_init_programs ();

  scm_tc16_vm_cont = scm_make_smob_type ("vm-cont", 0);
  scm_set_smob_mark (scm_tc16_vm_cont, vm_cont_mark);
  scm_set_smob_free (scm_tc16_vm_cont, vm_cont_free);

  scm_tc16_vm = scm_make_smob_type ("vm", 0);
  scm_set_smob_mark (scm_tc16_vm, vm_mark);
  scm_set_smob_free (scm_tc16_vm, vm_free);
  scm_set_smob_apply (scm_tc16_vm, scm_vm_apply, 1, 0, 1);

  the_vm = scm_permanent_object (make_vm ());

#ifndef SCM_MAGIC_SNARFER
#include "vm.x"
#endif
}

/*
  Local Variables:
  c-file-style: "gnu"
  End:
*/
Commit	Line	Data
8f5cfc81	1	/* Copyright (C) 2001 Free Software Foundation, Inc.
a98cef7e KN	2	*
	3	* This program is free software; you can redistribute it and/or modify
	4	* it under the terms of the GNU General Public License as published by
	5	* the Free Software Foundation; either version 2, or (at your option)
	6	* any later version.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this software; see the file COPYING. If not, write to
	15	* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
	16	* Boston, MA 02111-1307 USA
	17	*
	18	* As a special exception, the Free Software Foundation gives permission
	19	* for additional uses of the text contained in its release of GUILE.
	20	*
	21	* The exception is that, if you link the GUILE library with other files
	22	* to produce an executable, this does not by itself cause the
	23	* resulting executable to be covered by the GNU General Public License.
	24	* Your use of that executable is in no way restricted on account of
	25	* linking the GUILE library code into it.
	26	*
	27	* This exception does not however invalidate any other reasons why
	28	* the executable file might be covered by the GNU General Public License.
	29	*
	30	* This exception applies only to the code released by the
	31	* Free Software Foundation under the name GUILE. If you copy
	32	* code from other Free Software Foundation releases into a copy of
	33	* GUILE, as the General Public License permits, the exception does
	34	* not apply to the code that you add in this way. To avoid misleading
	35	* anyone as to the status of such modified files, you must delete
	36	* this exception notice from them.
	37	*
	38	* If you write modifications of your own for GUILE, it is your choice
	39	* whether to permit this exception to apply to your modifications.
	40	* If you do not wish that, delete this exception notice. */
	41
13c47753 AW	42	#if HAVE_CONFIG_H
	43	# include <config.h>
	44	#endif
	45
17e90c5e	46	#include <string.h>
ac99cb0c KN	47	#include "envs.h"
ac99cb0c KN	48	#include "frames.h"
17e90c5e	49	#include "instructions.h"
8f5cfc81	50	#include "objcodes.h"
ac99cb0c	51	#include "programs.h"
a98cef7e KN	52	#include "vm.h"
a98cef7e KN	53
a98cef7e KN	54	/* I sometimes use this for debugging. */
	55	#define vm_puts(OBJ) \
	56	{ \
22bcbe8c AW	57	scm_display (OBJ, scm_current_error_port ()); \
22bcbe8c AW	58	scm_newline (scm_current_error_port ()); \
a98cef7e KN	59	}
	60
	61	\f
a98cef7e KN	62	/*
	63	* VM Continuation
	64	*/
	65
f9e8c09d	66	scm_t_bits scm_tc16_vm_cont;
17e90c5e KN	67
	68
	69	#define SCM_VM_CONT_P(OBJ) SCM_SMOB_PREDICATE (scm_tc16_vm_cont, OBJ)
3d5ee0cd	70	#define SCM_VM_CONT_VP(CONT) ((struct scm_vm *) SCM_CELL_WORD_1 (CONT))
a98cef7e KN	71
a98cef7e KN	72	static SCM
3d5ee0cd	73	capture_vm_cont (struct scm_vm *vp)
a98cef7e	74	{
d8eeb67c	75	struct scm_vm p = scm_gc_malloc (sizeof (p), "capture_vm_cont");
3d5ee0cd	76	p->stack_size = vp->stack_limit - vp->sp;
d8eeb67c LC	77	p->stack_base = scm_gc_malloc (p->stack_size * sizeof (SCM),
d8eeb67c LC	78	"capture_vm_cont");
17e90c5e	79	p->stack_limit = p->stack_base + p->stack_size - 2;
3d5ee0cd KN	80	p->ip = vp->ip;
	81	p->sp = (SCM *) (vp->stack_limit - vp->sp);
	82	p->fp = (SCM *) (vp->stack_limit - vp->fp);
	83	memcpy (p->stack_base, vp->sp + 1, vp->stack_size * sizeof (SCM));
17e90c5e	84	SCM_RETURN_NEWSMOB (scm_tc16_vm_cont, p);
a98cef7e KN	85	}
	86
	87	static void
3d5ee0cd	88	reinstate_vm_cont (struct scm_vm *vp, SCM cont)
a98cef7e	89	{
3d5ee0cd KN	90	struct scm_vm *p = SCM_VM_CONT_VP (cont);
3d5ee0cd KN	91	if (vp->stack_size < p->stack_size)
a98cef7e	92	{
17e90c5e	93	/* puts ("FIXME: Need to expand"); */
a98cef7e KN	94	abort ();
a98cef7e KN	95	}
3d5ee0cd KN	96	vp->ip = p->ip;
	97	vp->sp = vp->stack_limit - (int) p->sp;
	98	vp->fp = vp->stack_limit - (int) p->fp;
	99	memcpy (vp->sp + 1, p->stack_base, p->stack_size * sizeof (SCM));
a98cef7e KN	100	}
	101
	102	static SCM
17e90c5e	103	vm_cont_mark (SCM obj)
a98cef7e KN	104	{
a98cef7e KN	105	SCM *p;
3d5ee0cd KN	106	struct scm_vm *vp = SCM_VM_CONT_VP (obj);
3d5ee0cd KN	107	for (p = vp->stack_base; p <= vp->stack_limit; p++)
a98cef7e KN	108	if (SCM_NIMP (*p))
	109	scm_gc_mark (*p);
	110	return SCM_BOOL_F;
	111	}
	112
	113	static scm_sizet
17e90c5e	114	vm_cont_free (SCM obj)
a98cef7e	115	{
3d5ee0cd	116	struct scm_vm *p = SCM_VM_CONT_VP (obj);
d8eeb67c LC	117
	118	scm_gc_free (p->stack_base, p->stack_size * sizeof (SCM), "stack-base");
	119	scm_gc_free (p, sizeof (struct scm_vm), "vm");
	120
	121	return 0;
a98cef7e KN	122	}
a98cef7e KN	123
17e90c5e KN	124	\f
	125	/*
	126	* VM Internal functions
	127	*/
	128
41f248a8	129	SCM_SYMBOL (sym_vm_run, "vm-run");
17e90c5e KN	130	SCM_SYMBOL (sym_vm_error, "vm-error");
	131
	132	static scm_byte_t *
	133	vm_fetch_length (scm_byte_t ip, size_t lenp)
a98cef7e	134	{
4bfb26f5	135	/* NOTE: format defined in system/vm/conv.scm */
17e90c5e KN	136	lenp = ip++;
	137	if (*lenp < 254)
	138	return ip;
	139	else if (*lenp == 254)
46cd9a34 KN	140	{
	141	int b1 = *ip++;
	142	int b2 = *ip++;
	143	*lenp = (b1 << 8) + b2;
	144	}
17e90c5e	145	else
46cd9a34 KN	146	{
	147	int b1 = *ip++;
	148	int b2 = *ip++;
	149	int b3 = *ip++;
	150	int b4 = *ip++;
	151	*lenp = (b1 << 24) + (b2 << 16) + (b3 << 8) + b4;
	152	}
17e90c5e	153	return ip;
a98cef7e KN	154	}
a98cef7e KN	155
af988bbf	156	static SCM
a6df585a	157	vm_heapify_frames_1 (struct scm_vm vp, SCM fp, SCM sp, SCM *destp)
af988bbf	158	{
a6df585a	159	SCM frame;
af988bbf	160	SCM *dl = SCM_FRAME_DYNAMIC_LINK (fp);
a6df585a KN	161	SCM *src = SCM_FRAME_UPPER_ADDRESS (fp);
a6df585a KN	162	SCM *dest = SCM_FRAME_LOWER_ADDRESS (fp);
af988bbf KN	163
	164	if (!dl)
	165	{
	166	/* The top frame */
af988bbf KN	167	frame = scm_c_make_heap_frame (fp);
	168	fp = SCM_HEAP_FRAME_POINTER (frame);
	169	SCM_FRAME_HEAP_LINK (fp) = SCM_BOOL_T;
	170	}
	171	else
	172	{
a6df585a	173	/* Child frames */
af988bbf KN	174	SCM link = SCM_FRAME_HEAP_LINK (dl);
af988bbf KN	175	if (!SCM_FALSEP (link))
a6df585a	176	link = SCM_FRAME_LOWER_ADDRESS (dl)[-1]; /* self link */
af988bbf	177	else
a6df585a	178	link = vm_heapify_frames_1 (vp, dl, dest - 1, &dest);
af988bbf KN	179	frame = scm_c_make_heap_frame (fp);
	180	fp = SCM_HEAP_FRAME_POINTER (frame);
	181	SCM_FRAME_HEAP_LINK (fp) = link;
b6368dbb	182	SCM_FRAME_SET_DYNAMIC_LINK (fp, SCM_HEAP_FRAME_POINTER (link));
af988bbf KN	183	}
	184
	185	/* Move stack data */
a6df585a KN	186	for (; src <= sp; src++, dest++)
	187	dest = src;
	188	*destp = dest;
af988bbf KN	189
	190	return frame;
	191	}
	192
	193	static SCM
	194	vm_heapify_frames (SCM vm)
	195	{
	196	struct scm_vm *vp = SCM_VM_DATA (vm);
	197	if (SCM_FALSEP (SCM_FRAME_HEAP_LINK (vp->fp)))
	198	{
a6df585a KN	199	SCM *dest;
a6df585a KN	200	vp->this_frame = vm_heapify_frames_1 (vp, vp->fp, vp->sp, &dest);
af988bbf	201	vp->fp = SCM_HEAP_FRAME_POINTER (vp->this_frame);
a6df585a	202	vp->sp = dest - 1;
af988bbf KN	203	}
	204	return vp->this_frame;
	205	}
	206
a98cef7e KN	207	\f
	208	/*
	209	* VM
	210	*/
	211
c0a25ecc	212	#define VM_DEFAULT_STACK_SIZE (16 * 1024)
17e90c5e KN	213
	214	#define VM_REGULAR_ENGINE 0
	215	#define VM_DEBUG_ENGINE 1
	216
	217	#if 0
	218	#define VM_NAME vm_regular_engine
	219	#define VM_ENGINE VM_REGULAR_ENGINE
	220	#include "vm_engine.c"
	221	#undef VM_NAME
	222	#undef VM_ENGINE
	223	#endif
	224
	225	#define VM_NAME vm_debug_engine
	226	#define VM_ENGINE VM_DEBUG_ENGINE
	227	#include "vm_engine.c"
	228	#undef VM_NAME
	229	#undef VM_ENGINE
	230
f9e8c09d	231	scm_t_bits scm_tc16_vm;
a98cef7e	232
499a4c07 KN	233	static SCM the_vm;
499a4c07 KN	234
a98cef7e	235	static SCM
17e90c5e KN	236	make_vm (void)
17e90c5e KN	237	#define FUNC_NAME "make_vm"
a98cef7e	238	{
17e90c5e	239	int i;
d8eeb67c LC	240	struct scm_vm *vp = scm_gc_malloc (sizeof (struct scm_vm), "vm");
d8eeb67c LC	241
3d5ee0cd	242	vp->stack_size = VM_DEFAULT_STACK_SIZE;
d8eeb67c LC	243	vp->stack_base = scm_gc_malloc (vp->stack_size * sizeof (SCM),
d8eeb67c LC	244	"stack-base");
3616e9e9 KN	245	vp->stack_limit = vp->stack_base + vp->stack_size - 3;
	246	vp->ip = NULL;
	247	vp->sp = vp->stack_base - 1;
	248	vp->fp = NULL;
3d5ee0cd KN	249	vp->time = 0;
	250	vp->clock = 0;
	251	vp->options = SCM_EOL;
af988bbf	252	vp->this_frame = SCM_BOOL_F;
ac99cb0c	253	vp->last_frame = SCM_BOOL_F;
17e90c5e	254	for (i = 0; i < SCM_VM_NUM_HOOKS; i++)
3d5ee0cd KN	255	vp->hooks[i] = SCM_BOOL_F;
3d5ee0cd KN	256	SCM_RETURN_NEWSMOB (scm_tc16_vm, vp);
a98cef7e	257	}
17e90c5e	258	#undef FUNC_NAME
a98cef7e KN	259
a98cef7e KN	260	static SCM
17e90c5e	261	vm_mark (SCM obj)
a98cef7e	262	{
17e90c5e	263	int i;
3d5ee0cd	264	struct scm_vm *vp = SCM_VM_DATA (obj);
17e90c5e	265
af988bbf KN	266	/* mark the stack conservatively */
	267	scm_mark_locations ((SCM_STACKITEM *) vp->stack_base,
	268	sizeof (SCM) * (vp->sp - vp->stack_base + 1));
a98cef7e	269
af988bbf	270	/* mark other objects */
17e90c5e	271	for (i = 0; i < SCM_VM_NUM_HOOKS; i++)
3d5ee0cd	272	scm_gc_mark (vp->hooks[i]);
af988bbf	273	scm_gc_mark (vp->this_frame);
ac99cb0c	274	scm_gc_mark (vp->last_frame);
3d5ee0cd	275	return vp->options;
a98cef7e KN	276	}
a98cef7e KN	277
17e90c5e KN	278	static scm_sizet
	279	vm_free (SCM obj)
	280	{
3d5ee0cd	281	struct scm_vm *vp = SCM_VM_DATA (obj);
d8eeb67c LC	282
	283	scm_gc_free (vp->stack_base, vp->stack_size * sizeof (SCM),
	284	"stack-base");
	285	scm_gc_free (vp, sizeof (struct scm_vm), "vm");
	286
	287	return 0;
17e90c5e KN	288	}
	289
	290	SCM_SYMBOL (sym_debug, "debug");
	291
	292	SCM
	293	scm_vm_apply (SCM vm, SCM program, SCM args)
	294	#define FUNC_NAME "scm_vm_apply"
a98cef7e	295	{
17e90c5e	296	SCM_VALIDATE_PROGRAM (1, program);
41f248a8	297	return vm_run (vm, program, args);
a98cef7e	298	}
17e90c5e	299	#undef FUNC_NAME
a98cef7e KN	300
	301	/* Scheme interface */
	302
	303	SCM_DEFINE (scm_vm_version, "vm-version", 0, 0, 0,
17e90c5e KN	304	(void),
17e90c5e KN	305	"")
a98cef7e KN	306	#define FUNC_NAME s_scm_vm_version
a98cef7e KN	307	{
fa19602c	308	return scm_from_locale_string (VERSION);
a98cef7e KN	309	}
	310	#undef FUNC_NAME
	311
499a4c07 KN	312	SCM_DEFINE (scm_the_vm, "the-vm", 0, 0, 0,
	313	(),
	314	"")
	315	#define FUNC_NAME s_scm_the_vm
	316	{
	317	return the_vm;
	318	}
	319	#undef FUNC_NAME
	320
	321
a98cef7e KN	322	SCM_DEFINE (scm_vm_p, "vm?", 1, 0, 0,
a98cef7e KN	323	(SCM obj),
17e90c5e	324	"")
a98cef7e KN	325	#define FUNC_NAME s_scm_vm_p
	326	{
	327	return SCM_BOOL (SCM_VM_P (obj));
	328	}
	329	#undef FUNC_NAME
	330
	331	SCM_DEFINE (scm_make_vm, "make-vm", 0, 0, 0,
17e90c5e KN	332	(void),
	333	"")
	334	#define FUNC_NAME s_scm_make_vm,
a98cef7e	335	{
17e90c5e	336	return make_vm ();
a98cef7e KN	337	}
	338	#undef FUNC_NAME
	339
17e90c5e	340	SCM_DEFINE (scm_vm_ip, "vm:ip", 1, 0, 0,
a98cef7e	341	(SCM vm),
17e90c5e KN	342	"")
17e90c5e KN	343	#define FUNC_NAME s_scm_vm_ip
a98cef7e KN	344	{
a98cef7e KN	345	SCM_VALIDATE_VM (1, vm);
f41cb00c	346	return scm_from_ulong ((unsigned long) SCM_VM_DATA (vm)->ip);
a98cef7e KN	347	}
	348	#undef FUNC_NAME
	349
	350	SCM_DEFINE (scm_vm_sp, "vm:sp", 1, 0, 0,
	351	(SCM vm),
17e90c5e	352	"")
a98cef7e KN	353	#define FUNC_NAME s_scm_vm_sp
	354	{
	355	SCM_VALIDATE_VM (1, vm);
f41cb00c	356	return scm_from_ulong ((unsigned long) SCM_VM_DATA (vm)->sp);
a98cef7e KN	357	}
	358	#undef FUNC_NAME
	359
	360	SCM_DEFINE (scm_vm_fp, "vm:fp", 1, 0, 0,
	361	(SCM vm),
17e90c5e	362	"")
a98cef7e KN	363	#define FUNC_NAME s_scm_vm_fp
	364	{
	365	SCM_VALIDATE_VM (1, vm);
f41cb00c	366	return scm_from_ulong ((unsigned long) SCM_VM_DATA (vm)->fp);
a98cef7e KN	367	}
	368	#undef FUNC_NAME
	369
17e90c5e KN	370	#define VM_DEFINE_HOOK(n) \
17e90c5e KN	371	{ \
3d5ee0cd	372	struct scm_vm *vp; \
17e90c5e	373	SCM_VALIDATE_VM (1, vm); \
3d5ee0cd KN	374	vp = SCM_VM_DATA (vm); \
3d5ee0cd KN	375	if (SCM_FALSEP (vp->hooks[n])) \
238e7a11	376	vp->hooks[n] = scm_make_hook (SCM_I_MAKINUM (1)); \
3d5ee0cd	377	return vp->hooks[n]; \
17e90c5e KN	378	}
	379
	380	SCM_DEFINE (scm_vm_boot_hook, "vm-boot-hook", 1, 0, 0,
a98cef7e	381	(SCM vm),
17e90c5e KN	382	"")
17e90c5e KN	383	#define FUNC_NAME s_scm_vm_boot_hook
a98cef7e	384	{
17e90c5e	385	VM_DEFINE_HOOK (SCM_VM_BOOT_HOOK);
a98cef7e KN	386	}
	387	#undef FUNC_NAME
	388
17e90c5e KN	389	SCM_DEFINE (scm_vm_halt_hook, "vm-halt-hook", 1, 0, 0,
	390	(SCM vm),
	391	"")
	392	#define FUNC_NAME s_scm_vm_halt_hook
a98cef7e	393	{
17e90c5e	394	VM_DEFINE_HOOK (SCM_VM_HALT_HOOK);
a98cef7e KN	395	}
	396	#undef FUNC_NAME
	397
17e90c5e	398	SCM_DEFINE (scm_vm_next_hook, "vm-next-hook", 1, 0, 0,
a98cef7e	399	(SCM vm),
17e90c5e KN	400	"")
17e90c5e KN	401	#define FUNC_NAME s_scm_vm_next_hook
a98cef7e	402	{
17e90c5e	403	VM_DEFINE_HOOK (SCM_VM_NEXT_HOOK);
a98cef7e KN	404	}
	405	#undef FUNC_NAME
	406
7a0d0cee KN	407	SCM_DEFINE (scm_vm_break_hook, "vm-break-hook", 1, 0, 0,
	408	(SCM vm),
	409	"")
	410	#define FUNC_NAME s_scm_vm_break_hook
	411	{
	412	VM_DEFINE_HOOK (SCM_VM_BREAK_HOOK);
	413	}
	414	#undef FUNC_NAME
	415
17e90c5e KN	416	SCM_DEFINE (scm_vm_enter_hook, "vm-enter-hook", 1, 0, 0,
	417	(SCM vm),
	418	"")
	419	#define FUNC_NAME s_scm_vm_enter_hook
a98cef7e	420	{
17e90c5e	421	VM_DEFINE_HOOK (SCM_VM_ENTER_HOOK);
a98cef7e KN	422	}
	423	#undef FUNC_NAME
	424
17e90c5e KN	425	SCM_DEFINE (scm_vm_apply_hook, "vm-apply-hook", 1, 0, 0,
	426	(SCM vm),
	427	"")
	428	#define FUNC_NAME s_scm_vm_apply_hook
a98cef7e	429	{
17e90c5e	430	VM_DEFINE_HOOK (SCM_VM_APPLY_HOOK);
a98cef7e KN	431	}
	432	#undef FUNC_NAME
	433
17e90c5e	434	SCM_DEFINE (scm_vm_exit_hook, "vm-exit-hook", 1, 0, 0,
a98cef7e	435	(SCM vm),
17e90c5e KN	436	"")
17e90c5e KN	437	#define FUNC_NAME s_scm_vm_exit_hook
a98cef7e	438	{
17e90c5e	439	VM_DEFINE_HOOK (SCM_VM_EXIT_HOOK);
a98cef7e KN	440	}
	441	#undef FUNC_NAME
	442
17e90c5e	443	SCM_DEFINE (scm_vm_return_hook, "vm-return-hook", 1, 0, 0,
a98cef7e	444	(SCM vm),
17e90c5e KN	445	"")
17e90c5e KN	446	#define FUNC_NAME s_scm_vm_return_hook
a98cef7e	447	{
17e90c5e	448	VM_DEFINE_HOOK (SCM_VM_RETURN_HOOK);
a98cef7e KN	449	}
	450	#undef FUNC_NAME
	451
17e90c5e KN	452	SCM_DEFINE (scm_vm_option, "vm-option", 2, 0, 0,
	453	(SCM vm, SCM key),
	454	"")
	455	#define FUNC_NAME s_scm_vm_option
a98cef7e KN	456	{
a98cef7e KN	457	SCM_VALIDATE_VM (1, vm);
17e90c5e	458	return scm_assq_ref (SCM_VM_DATA (vm)->options, key);
a98cef7e KN	459	}
	460	#undef FUNC_NAME
	461
17e90c5e KN	462	SCM_DEFINE (scm_set_vm_option_x, "set-vm-option!", 3, 0, 0,
	463	(SCM vm, SCM key, SCM val),
	464	"")
	465	#define FUNC_NAME s_scm_set_vm_option_x
a98cef7e KN	466	{
a98cef7e KN	467	SCM_VALIDATE_VM (1, vm);
17e90c5e KN	468	SCM_VM_DATA (vm)->options
	469	= scm_assq_set_x (SCM_VM_DATA (vm)->options, key, val);
	470	return SCM_UNSPECIFIED;
a98cef7e KN	471	}
	472	#undef FUNC_NAME
	473
17e90c5e	474	SCM_DEFINE (scm_vm_stats, "vm-stats", 1, 0, 0,
a98cef7e	475	(SCM vm),
17e90c5e KN	476	"")
17e90c5e KN	477	#define FUNC_NAME s_scm_vm_stats
a98cef7e	478	{
17e90c5e KN	479	SCM stats;
17e90c5e KN	480
a98cef7e	481	SCM_VALIDATE_VM (1, vm);
17e90c5e	482
2d80426a LC	483	stats = scm_make_vector (SCM_I_MAKINUM (2), SCM_UNSPECIFIED);
2d80426a LC	484	scm_vector_set_x (stats, SCM_I_MAKINUM (0),
f9e8c09d	485	scm_from_ulong (SCM_VM_DATA (vm)->time));
2d80426a	486	scm_vector_set_x (stats, SCM_I_MAKINUM (1),
f9e8c09d	487	scm_from_ulong (SCM_VM_DATA (vm)->clock));
17e90c5e KN	488
17e90c5e KN	489	return stats;
a98cef7e KN	490	}
	491	#undef FUNC_NAME
	492
17e90c5e KN	493	#define VM_CHECK_RUNNING(vm) \
	494	if (!SCM_VM_DATA (vm)->ip) \
	495	SCM_MISC_ERROR ("Not running", SCM_LIST1 (vm))
	496
af988bbf	497	SCM_DEFINE (scm_vm_this_frame, "vm-this-frame", 1, 0, 0,
a98cef7e	498	(SCM vm),
17e90c5e	499	"")
af988bbf	500	#define FUNC_NAME s_scm_vm_this_frame
a98cef7e KN	501	{
a98cef7e KN	502	SCM_VALIDATE_VM (1, vm);
af988bbf	503	return SCM_VM_DATA (vm)->this_frame;
ac99cb0c KN	504	}
	505	#undef FUNC_NAME
	506
	507	SCM_DEFINE (scm_vm_last_frame, "vm-last-frame", 1, 0, 0,
	508	(SCM vm),
	509	"")
	510	#define FUNC_NAME s_scm_vm_last_frame
	511	{
	512	SCM_VALIDATE_VM (1, vm);
	513	return SCM_VM_DATA (vm)->last_frame;
a98cef7e KN	514	}
	515	#undef FUNC_NAME
	516
17e90c5e KN	517	SCM_DEFINE (scm_vm_fetch_code, "vm-fetch-code", 1, 0, 0,
	518	(SCM vm),
	519	"")
	520	#define FUNC_NAME s_scm_vm_fetch_code
	521	{
	522	int i;
	523	SCM list;
	524	scm_byte_t *ip;
	525	struct scm_instruction *p;
a98cef7e	526
17e90c5e KN	527	SCM_VALIDATE_VM (1, vm);
17e90c5e KN	528	VM_CHECK_RUNNING (vm);
a98cef7e	529
17e90c5e KN	530	ip = SCM_VM_DATA (vm)->ip;
17e90c5e KN	531	p = SCM_INSTRUCTION (*ip);
a98cef7e	532
17e90c5e KN	533	list = SCM_LIST1 (scm_str2symbol (p->name));
17e90c5e KN	534	for (i = 1; i <= p->len; i++)
2d80426a	535	list = scm_cons (SCM_I_MAKINUM (ip[i]), list);
17e90c5e KN	536	return scm_reverse_x (list, SCM_EOL);
	537	}
	538	#undef FUNC_NAME
	539
	540	SCM_DEFINE (scm_vm_fetch_stack, "vm-fetch-stack", 1, 0, 0,
	541	(SCM vm),
	542	"")
	543	#define FUNC_NAME s_scm_vm_fetch_stack
a98cef7e	544	{
3616e9e9 KN	545	SCM *sp;
	546	SCM ls = SCM_EOL;
	547	struct scm_vm *vp;
a98cef7e KN	548
a98cef7e KN	549	SCM_VALIDATE_VM (1, vm);
17e90c5e	550	VM_CHECK_RUNNING (vm);
a98cef7e	551
3616e9e9	552	vp = SCM_VM_DATA (vm);
af988bbf	553	for (sp = vp->stack_base; sp <= vp->sp; sp++)
3616e9e9 KN	554	ls = scm_cons (*sp, ls);
3616e9e9 KN	555	return ls;
a98cef7e KN	556	}
	557	#undef FUNC_NAME
	558
	559	\f
	560	/*
17e90c5e	561	* Initialize
a98cef7e KN	562	*/
a98cef7e KN	563
17e90c5e KN	564	void
	565	scm_init_vm (void)
	566	{
ac99cb0c	567	scm_init_frames ();
17e90c5e	568	scm_init_instructions ();
8f5cfc81	569	scm_init_objcodes ();
ac99cb0c	570	scm_init_programs ();
a98cef7e	571
17e90c5e KN	572	scm_tc16_vm_cont = scm_make_smob_type ("vm-cont", 0);
	573	scm_set_smob_mark (scm_tc16_vm_cont, vm_cont_mark);
	574	scm_set_smob_free (scm_tc16_vm_cont, vm_cont_free);
a98cef7e	575
17e90c5e KN	576	scm_tc16_vm = scm_make_smob_type ("vm", 0);
	577	scm_set_smob_mark (scm_tc16_vm, vm_mark);
	578	scm_set_smob_free (scm_tc16_vm, vm_free);
	579	scm_set_smob_apply (scm_tc16_vm, scm_vm_apply, 1, 0, 1);
a98cef7e	580
499a4c07 KN	581	the_vm = scm_permanent_object (make_vm ());
499a4c07 KN	582
17e90c5e	583	#ifndef SCM_MAGIC_SNARFER
a98cef7e	584	#include "vm.x"
17e90c5e	585	#endif
a98cef7e	586	}
17e90c5e KN	587
	588	/*
	589	Local Variables:
	590	c-file-style: "gnu"
	591	End:
	592	*/