clamav/libclamav/js/js.c

/*
 * JavaScript interpreter main glue.
 * Copyright (c) 1998-1999 New Generation Software (NGS) Oy
 *
 * Author: Markku Rossi <mtr@ngs.fi>
 */

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA
 */

/*
 * $Source: /tmp/cvsroot-15-2-2007/clamav-devel/libclamav/js/js.c,v $
 * $Id: js.c,v 1.3 2006/10/28 11:27:44 njh Exp $
 */
#if HAVE_CONFIG_H
#include "clamav-config.h"
#endif

#ifdef	CL_EXPERIMENTAL

#include "js/js.h"
#include "js/jsint.h"

/*
 * Types and definitions.
 */

/* Context for js_global_method_stub. */
struct js_global_method_context_st
{
  JSGlobalMethodProc proc;
  void *context;
  JSFreeProc free_proc;
  JSInterpPtr interp;
};

typedef struct js_global_method_context_st JSGlobalMethodContext;

/* Context for user I/O function streams. */
struct js_user_io_func_ctx_st
{
  JSIOFunc func;
  void *context;
  long position;
};

typedef struct js_user_io_func_ctx_st JSUserIOFuncCtx;

struct js_method_reg_st
{
  JSSymbol sym;
  char *name;
  unsigned int flags;
  JSMethodProc method;
};

typedef struct js_method_reg_st JSMethodReg;

struct js_property_reg_st
{
  JSSymbol sym;
  char *name;
  unsigned int flags;
  JSPropertyProc property;
};

typedef struct js_property_reg_st JSPropertyReg;

/* The class handle. */
struct js_class_st
{
  char *name;
  JSInterpPtr interp;

  /* Flags. */
  unsigned int no_auto_destroy : 1;
  unsigned int interned : 1;

  void *class_context;
  JSFreeProc class_context_destructor;

  JSConstructor constructor;

  unsigned int num_methods;
  JSMethodReg *methods;

  unsigned int num_properties;
  JSPropertyReg *properties;
};

/* Object instance context. */
struct js_object_instance_ctx_st
{
  void *instance_context;
  JSFreeProc instance_context_destructor;
};

typedef struct js_object_instance_ctx_st JSObjectInstanceCtx;


/*
 * Prototypes for static functions.
 */

/* The module for JS' core global methods. */
static void js_core_globals (JSInterpPtr interp);

/*
 * Helper function to evaluate source <source> with compiler function
 * <compiler_function>.
 */
static int js_eval_source (JSInterpPtr interp, JSNode *source,
			   char *compiler_function);

/*
 * Helper function to compile source <source> with compiler function
 * <compiler_function>.  If <assembler_file> is not NULL, the
 * assembler listing of the compilation is saved to that file.  If
 * <byte_code_file> is not NULL, the byte_code data is saved to that
 * file.  If <bc_return> is not NULL, the resulting byte_code data is
 * returned in it as a JavaScript string node.
 */
static int js_compile_source (JSInterpPtr interp, JSNode *source,
			      char *compiler_function, char *assembler_file,
			      char *byte_code_file, JSNode *bc_return);

/*
 * The stub function for global methods, created with the
 * js_create_global_method() API function.
 */
static void js_global_method_stub (JSVirtualMachine *vm,
				   JSBuiltinInfo *builtin_info,
				   void *instance_context,
				   JSNode *result_return,
				   JSNode *args);

/*
 * Destructor for the global methods, created with the
 * js_create_global_method() API function.
 */
static void js_global_method_delete (JSBuiltinInfo *builtin_info,
				     void *instance_context);

static JSIOStream *iostream_iofunc (JSIOFunc func, void *context,
				    int readp, int writep);


/*
 * Global functions.
 */

const JSCharPtr
js_version ()
{
  return VERSION;
}


void
js_init_default_options (JSInterpOptions *options)
{
  memset (options, 0, sizeof (*options));

  options->stack_size = 2048;
  options->dispatch_method = JS_VM_DISPATCH_JUMPS;

  options->warn_undef = 1;

  options->optimize_peephole = 1;
  options->optimize_jumps_to_jumps = 1;

  options->fd_count = (unsigned long) -1;
}


JSInterpPtr
js_create_interp (JSInterpOptions *options)
{
  JSInterpPtr interp = NULL;
  JSByteCode *bc;
  JSInterpOptions default_options;
  JSIOStream *s_stdin = NULL;
  JSIOStream *s_stdout = NULL;
  JSIOStream *s_stderr = NULL;

  /*
   * Sanity check to assure that the js.h and jsint.h APIs share a
   * same view to the world.
   */
  assert (sizeof (JSNode) == sizeof (JSType));

  interp = js_calloc (NULL, 1, sizeof (*interp));
  if (interp == NULL)
    return NULL;

  if (options == NULL)
    {
      js_init_default_options (&default_options);
      options = &default_options;
    }

  memcpy (&interp->options, options, sizeof (*options));

  /* The default system streams. */

  if (options->s_stdin)
    s_stdin = iostream_iofunc (options->s_stdin, options->s_context, 1, 0);
  else
    s_stdin = js_iostream_file (stdin, 1, 0, 0);

  if (s_stdin == NULL)
    goto error_out;

  if (options->s_stdout)
    s_stdout = iostream_iofunc (options->s_stdout, options->s_context, 0, 1);
  else
    s_stdout = js_iostream_file (stdout, 0, 1, 0);

  if (s_stdout == NULL)
    goto error_out;
  s_stdout->autoflush = 1;

  if (options->s_stderr)
    s_stderr = iostream_iofunc (options->s_stderr, options->s_context, 0, 1);
  else
    s_stderr = js_iostream_file (stderr, 0, 1, 0);

  if (s_stderr == NULL)
    goto error_out;
  s_stderr->autoflush = 1;

  /* Create virtual machine. */
  interp->vm = js_vm_create (options->stack_size,
			     options->dispatch_method,
			     options->verbose,
			     options->stacktrace_on_error,
			     s_stdin, s_stdout, s_stderr);
  if (interp->vm == NULL)
    goto error_out;

  /* Set some options. */
  interp->vm->warn_undef = options->warn_undef;

  /* Set the security options. */

  if (options->secure_builtin_file)
    interp->vm->security |= JS_VM_SECURE_FILE;
  if (options->secure_builtin_system)
    interp->vm->security |= JS_VM_SECURE_SYSTEM;

  /* Set the event hook. */
  interp->vm->hook			 = options->hook;
  interp->vm->hook_context		 = options->hook_context;
  interp->vm->hook_operand_count_trigger = options->hook_operand_count_trigger;

  /* The file descriptor limit. */
  interp->vm->fd_count = options->fd_count;

  if (!options->no_compiler)
    {
      int result;

      /* Define compiler to the virtual machine. */
      bc = js_bc_read_data (js_compiler_bytecode, js_compiler_bytecode_len);
      if (bc == NULL)
	goto error_out;

      result = js_vm_execute (interp->vm, bc);
      js_bc_free (bc);
      if (!result)
	goto error_out;
    }

  /* Initialize our extensions. */
  if (!js_define_module (interp, js_core_globals))
    goto error_out;

  /* Ok, we'r done. */

#if 0
#if JS_DEBUG_MEMORY_LEAKS
  /* Let's see how much memory an empty interpreter takes. */
  js_alloc_dump_blocks ();
#endif /* JS_DEBUG_MEMORY_LEAKS */
#endif

  return interp;


  /*
   * Error handling.
   */

 error_out:

  if (interp)
    {
      if (interp->vm)
	js_vm_destroy (interp->vm);
      js_free (interp);
    }

  if (s_stdin)
    js_iostream_close (s_stdin);
  if (s_stdout)
    js_iostream_close (s_stdout);
  if (s_stderr)
    js_iostream_close (s_stderr);

  return NULL;
}


void
js_destroy_interp (JSInterpPtr interp)
{
  js_vm_destroy (interp->vm);
  js_free (interp);

#if 0
#if JS_DEBUG_MEMORY_LEAKS
  /* Let's see how much memory we leak. */
  js_alloc_dump_blocks ();
#endif /* JS_DEBUG_MEMORY_LEAKS */
#endif
}


const JSCharPtr
js_error_message (JSInterpPtr interp)
{
  return interp->vm->error;
}


void
js_result (JSInterpPtr interp, JSType *result_return)
{
  memcpy (result_return, &interp->vm->exec_result, sizeof (*result_return));
}


int
js_eval (JSInterpPtr interp, char *code)
{
  JSNode source;

  js_vm_make_static_string (interp->vm, &source, code, strlen (code));
  return js_eval_source (interp, &source, "JSC$compile_string");
}


int
js_eval_data (JSInterpPtr interp, char *data, unsigned int datalen)
{
  JSNode source;

  js_vm_make_static_string (interp->vm, &source, data, datalen);
  return js_eval_source (interp, &source, "JSC$compile_string");
}


int
js_eval_file (JSInterpPtr interp, char *filename)
{
  char *cp;
  int result;

  cp = strrchr (filename, '.');
  if (cp && strcmp (cp, ".jsc") == 0)
    {
    run_bytecode:
      result = js_execute_byte_code_file (interp, filename);
    }
  else if (cp && strcmp (cp, ".js") == 0)
    {
    try_javascript:
      result = js_eval_javascript_file (interp, filename);
    }
  else
    {
      FILE *fp;

      /* Must look into the file. */

      fp = fopen (filename, "r");
      if (fp)
	{
	  int ch;

	  if ((ch = getc (fp)) == '#')
	    {
	      /* Skip the first sh-command line. */
	      while ((ch = getc (fp)) != EOF && ch != '\n')
		;
	      if (ch == EOF)
		{
		  fclose (fp);
		  goto try_javascript;
		}
	    }
	  else
	    ungetc (ch, fp);

	  /* Check if we can read the file magic. */
	  ch = getc (fp);
	  if (ch == 0xc0)
	    {
	      ch = getc (fp);
	      if (ch == 0x01)
		{
		  ch = getc (fp);
		  if (ch == 'J')
		    {
		      ch = getc (fp);
		      if (ch == 'S')
			{
			  /* Got it.  We find a valid byte-code file magic. */
			  fclose (fp);
			  goto run_bytecode;
			}
		    }
		}
	    }

	  fclose (fp);
	  /* FALLTHROUGH */
	}

      /*
       * If nothing else helps, we assume that the file contains JavaScript
       * source code that must be compiled.
       */
      goto try_javascript;
    }

  return result;
}


int
js_eval_javascript_file (JSInterpPtr interp, char *filename)
{
  JSNode source;

  js_vm_make_static_string (interp->vm, &source, filename, strlen (filename));
  return js_eval_source (interp, &source, "JSC$compile_file");
}


int
js_execute_byte_code_file (JSInterpPtr interp, char *filename)
{
  JSByteCode *bc;
  FILE *fp;
  int result;

  fp = fopen (filename, "rb");
  if (fp == NULL)
    {
      /* Let's borrow vm's error buffer. */
      sprintf (interp->vm->error, "couldn't open byte-code file \"%s\": %s",
	       filename, strerror (errno));
      return 0;
    }

  bc = js_bc_read_file (fp);
  fclose (fp);

  if (bc == NULL)
    /* XXX Error message. */
    return 0;

  /* Execute it. */

  result = js_vm_execute (interp->vm, bc);
  js_bc_free (bc);

  return result;
}


int
js_apply (JSInterpPtr interp, char *name, unsigned int argc, JSType *argv)
{
  JSNode *args;
  unsigned int ui;
  int result;

  args = js_malloc (NULL, (argc + 1) * sizeof (JSNode));
  if (args == NULL)
    {
      sprintf (interp->vm->error, "VM: out of memory");
      return 0;
    }

  /* Set the argument count. */
  args[0].type = JS_INTEGER;
  args[0].u.vinteger = argc;

  /* Set the arguments. */
  for (ui = 0; ui < argc; ui++)
    JS_COPY (&args[ui + 1], (JSNode *) &argv[ui]);

  /* Call it. */
  result = js_vm_apply (interp->vm, name, NULL, argc + 1, args);

  js_free (args);

  return result;
}


int
js_compile (JSInterpPtr interp,  char *input_file, char *assembler_file,
	    char *byte_code_file)
{
  JSNode source;

  js_vm_make_static_string (interp->vm, &source, input_file,
			    strlen (input_file));
  return js_compile_source (interp, &source, "JSC$compile_file",
			    assembler_file, byte_code_file, NULL);
}


int
js_compile_to_byte_code (JSInterpPtr interp, char *input_file,
			 unsigned char **bc_return,
			 unsigned int *bc_len_return)
{
  JSNode source;
  int result;

  js_vm_make_static_string (interp->vm, &source, input_file,
			    strlen (input_file));
  result = js_compile_source (interp, &source, "JSC$compile_file",
			      NULL, NULL, &source);
  if (result == 0)
    return 0;

  /* Pass the data to the caller. */
  *bc_return = source.u.vstring->data;
  *bc_len_return = source.u.vstring->len;

  return result;
}


int
js_compile_data_to_byte_code (JSInterpPtr interp, char *data,
			      unsigned int datalen,
			      unsigned char **bc_return,
			      unsigned int *bc_len_return)
{
  JSNode source;
  int result;

  js_vm_make_static_string (interp->vm, &source, data, datalen);
  result = js_compile_source (interp, &source, "JSC$compile_string",
			      NULL, NULL, &source);
  if (result == 0)
    return 0;

  /* Pass the data to the caller. */
  *bc_return = source.u.vstring->data;
  *bc_len_return = source.u.vstring->len;

  return result;
}


int
js_execute_byte_code (JSInterpPtr interp, unsigned char *bc_data,
		      unsigned int bc_data_len)
{
  JSByteCode *bc;
  int result;

  bc = js_bc_read_data (bc_data, bc_data_len);
  if (bc == NULL)
    /* Not a valid byte-code data. */
    return 0;

  /* Execute it. */
  result = js_vm_execute (interp->vm, bc);
  js_bc_free (bc);

  return result;
}


/* Classes. */

JSClassPtr
js_class_create (void *class_context, JSFreeProc class_context_destructor,
		 int no_auto_destroy, JSConstructor constructor)
{
  JSClassPtr cls;

  cls = js_calloc (NULL, 1, sizeof (*cls));
  if (cls == NULL)
    return NULL;

  cls->class_context = class_context;
  cls->class_context_destructor = class_context_destructor;

  cls->no_auto_destroy = no_auto_destroy;
  cls->constructor = constructor;

  return cls;
}


void
js_class_destroy (JSClassPtr cls)
{
  if (cls == NULL)
    return;

  if (cls->class_context_destructor)
    (*cls->class_context_destructor) (cls->class_context);

  js_free (cls);
}


JSVoidPtr
js_class_context (JSClassPtr cls)
{
  if (cls)
    return cls->class_context;

  return NULL;
}


int
js_class_define_method (JSClassPtr cls, char *name, unsigned int flags,
			JSMethodProc method)
{
  JSMethodReg *nmethods;

  nmethods = js_realloc (NULL, cls->methods,
			 (cls->num_methods + 1) * sizeof (JSMethodReg));
  if (nmethods == NULL)
    return 0;

  cls->methods = nmethods;

  /*
   * The names are interned to symbols when the class is defined to the
   * interpreter.
   */

  cls->methods[cls->num_methods].name = js_strdup (NULL, name);
  if (cls->methods[cls->num_methods].name == NULL)
    return 0;

  cls->methods[cls->num_methods].flags = flags;
  cls->methods[cls->num_methods].method = method;

  cls->num_methods++;

  return 1;
}


int
js_class_define_property (JSClassPtr cls, char *name, unsigned int flags,
			  JSPropertyProc property)
{
  JSPropertyReg *nprops;

  nprops = js_realloc (NULL, cls->properties,
		       (cls->num_properties + 1) * sizeof (JSPropertyReg));
  if (nprops == NULL)
    return 0;

  cls->properties = nprops;

  cls->properties[cls->num_properties].name = js_strdup (NULL, name);
  if (cls->properties[cls->num_properties].name == NULL)
    return 0;

  cls->properties[cls->num_properties].flags = flags;
  cls->properties[cls->num_properties].property = property;

  cls->num_properties++;

  return 1;
}


/* The stub functions for JSClass built-in objects. */

/* Method proc. */
static int
cls_method (JSVirtualMachine *vm, JSBuiltinInfo *builtin_info,
	    void *instance_context, JSSymbol method, JSNode *result_return,
	    JSNode *args)
{
  JSClassPtr cls = builtin_info->obj_context;
  JSObjectInstanceCtx *ictx = instance_context;
  int i;
  JSMethodResult result;
  char msg[1024];

  /* Let's see if we know the method. */
  for (i = 0; i < cls->num_methods; i++)
    if (cls->methods[i].sym == method)
      {
	/* Found it. */

	/* Check flags. */
	if ((cls->methods[i].flags & JS_CF_STATIC) == 0
	    && instance_context == NULL)
	  /* An instance method called from the `main' class. */
	  break;

	result = (*cls->methods[i].method) (cls,
					    (ictx
					     ? ictx->instance_context
					     : NULL),
					    cls->interp, args[0].u.vinteger,
					    (JSType *) &args[1],
					    (JSType *) result_return,
					    msg);
	if (result == JS_ERROR)
	  {
	    sprintf (vm->error, "%s.%s(): %s", cls->name,
		     cls->methods[i].name, msg);
	    js_vm_error (vm);
	  }

	return JS_PROPERTY_FOUND;
      }

  return JS_PROPERTY_UNKNOWN;
}

/* Property proc. */
static int
cls_property (JSVirtualMachine *vm, JSBuiltinInfo *builtin_info,
	      void *instance_context, JSSymbol property, int set, JSNode *node)
{
  JSClassPtr cls = builtin_info->obj_context;
  JSObjectInstanceCtx *ictx = instance_context;
  JSMethodResult result;
  char msg[1024];
  int i;

  /* Find the property. */
  for (i = 0; i < cls->num_properties; i++)
    if (cls->properties[i].sym == property)
      {
	/* Found it. */

	/* Check flags. */

	if ((cls->properties[i].flags & JS_CF_STATIC) == 0
	    && instance_context == NULL)
	  break;

	if ((cls->properties[i].flags & JS_CF_IMMUTABLE) && set)
	  {
	    sprintf (vm->error, "%s.%s: immutable property",
		     cls->name, cls->properties[i].name);
	    js_vm_error (vm);
	  }

	result = (*cls->properties[i].property) (cls,
						 (ictx
						  ? ictx->instance_context
						  : NULL),
						 cls->interp, set,
						 (JSType *) node, msg);
	if (result == JS_ERROR)
	  {
	    sprintf (vm->error, "%s.%s: %s", cls->name,
		     cls->properties[i].name, msg);
	    js_vm_error (vm);
	  }

	return JS_PROPERTY_FOUND;
      }

  if (!set)
    node->type = JS_UNDEFINED;

  return JS_PROPERTY_UNKNOWN;
}

/* New proc. */
static void
cls_new_proc (JSVirtualMachine *vm, JSBuiltinInfo *builtin_info, JSNode *args,
	      JSNode *result_return)
{
  JSClassPtr cls = builtin_info->obj_context;
  JSMethodResult result;
  char msg[1024];
  void *instance_context;
  JSFreeProc instance_context_destructor;
  JSObjectInstanceCtx *ictx;

  result = (*cls->constructor) (cls, cls->interp, args[0].u.vinteger,
				(JSType *) &args[1], &instance_context,
				&instance_context_destructor,
				msg);
  if (result == JS_ERROR)
    {
      sprintf (vm->error, "new %s(): %s", cls->name, msg);
      js_vm_error (vm);
    }

  ictx = js_calloc (vm, 1, sizeof (*ictx));
  ictx->instance_context = instance_context;
  ictx->instance_context_destructor = instance_context_destructor;

  js_vm_builtin_create (vm, result_return, builtin_info, ictx);
}


/* Delete proc. */
static void
cls_delete_proc (JSBuiltinInfo *builtin_info, void *instance_context)
{
  JSObjectInstanceCtx *ictx = instance_context;

  if (ictx)
    {
      if (ictx->instance_context_destructor)
	(*ictx->instance_context_destructor) (ictx->instance_context);

      js_free (ictx);
    }
}

/*
 * This is called to destroy the class handle, when there are no more
 * references to it.
 */
static void
js_class_destructor (void *context)
{
  JSClassPtr cls = context;

  if (cls->no_auto_destroy)
    return;

  js_class_destroy (cls);
}


static void
intern_symbols (JSVirtualMachine *vm, JSClassPtr cls)
{
  int i;

  for (i = 0; i < cls->num_methods; i++)
    cls->methods[i].sym = js_vm_intern (vm, cls->methods[i].name);

  for (i = 0; i < cls->num_properties; i++)
    cls->properties[i].sym = js_vm_intern (vm, cls->properties[i].name);

  cls->interned = 1;
}


static JSBuiltinInfo *
one_builtin_info_please (JSVirtualMachine *vm, JSClassPtr cls)
{
  JSBuiltinInfo *info;

  info = js_vm_builtin_info_create (vm);

  info->method_proc		= cls_method;
  info->property_proc		= cls_property;

  if (cls->constructor)
    {
      info->new_proc 		= cls_new_proc;
      info->delete_proc		= cls_delete_proc;
    }

  info->obj_context		= cls;
  info->obj_context_delete	= js_class_destructor;

  return info;
}


int
js_define_class (JSInterpPtr interp, JSClassPtr cls, char *name)
{
  JSNode *n;
  JSVirtualMachine *vm = interp->vm;
  JSBuiltinInfo *info;

  /* XXX We need a top-level here */

  cls->name = js_strdup (vm, name);
  cls->interp = interp;

  if (!cls->interned)
    /* Intern the symbols and properties. */
    intern_symbols (interp->vm, cls);

  /* Define it to the interpreter. */

  info = one_builtin_info_please (vm, cls);

  n = &vm->globals[js_vm_intern (vm, name)];
  js_vm_builtin_create (vm, n, info, NULL);

  return 1;
}


int
js_instantiate_class (JSInterpPtr interp, JSClassPtr cls, void *ictx,
		      JSFreeProc ictx_destructor, JSType *result_return)
{
  JSObjectInstanceCtx *instance;
  JSVirtualMachine *vm = interp->vm;
  JSBuiltinInfo *info;

  if (!cls->interned)
    /* Intern the symbols and properties. */
    intern_symbols (vm, cls);

  /* Create an instance. */
  instance = js_calloc (vm, 1, sizeof (*instance));
  instance->instance_context = ictx;
  instance->instance_context_destructor = ictx_destructor;

  /* Create a fresh builtin info. */
  info = one_builtin_info_please (vm, cls);

  /* And create it.  */
  js_vm_builtin_create (vm, (JSNode *) result_return, info, instance);

  return 1;
}


const JSClassPtr
js_lookup_class (JSInterpPtr interp, char *name)
{
  JSNode *n;
  JSVirtualMachine *vm = interp->vm;

  n = &vm->globals[js_vm_intern (vm, name)];
  if (n->type != JS_BUILTIN)
    return NULL;

  if (n->u.vbuiltin->info->method_proc != cls_method)
    /* This is a wrong built-in. */
    return NULL;

  return (JSClassPtr) n->u.vbuiltin->info->obj_context;
}


int
js_isa (JSInterpPtr interp, JSType *object, JSClassPtr cls,
	void **instance_context_return)
{
  JSNode *n = (JSNode *) object;
  JSObjectInstanceCtx *instance;

  if (n->type != JS_BUILTIN || n->u.vbuiltin->info->obj_context != cls
      || n->u.vbuiltin->instance_context == NULL)
    return 0;

  if (instance_context_return)
    {
      instance = (JSObjectInstanceCtx *) n->u.vbuiltin->instance_context;
      *instance_context_return = instance->instance_context;
    }

  return 1;
}



/* Type functions. */

void
js_type_make_string (JSInterpPtr interp, JSType *type, unsigned char *data,
		     unsigned int length)
{
  JSNode *n = (JSNode *) type;

  js_vm_make_string (interp->vm, n, data, length);
}


void
js_type_make_array (JSInterpPtr interp, JSType *type, unsigned int length)
{
  JSNode *n = (JSNode *) type;

  js_vm_make_array (interp->vm, n, length);
}


void
js_set_var (JSInterpPtr interp, char *name, JSType *value)
{
  JSNode *n = &interp->vm->globals[js_vm_intern (interp->vm, name)];
  JS_COPY (n, (JSNode *) value);
}


void
js_get_var (JSInterpPtr interp, char *name, JSType *value)
{
  JSNode *n = &interp->vm->globals[js_vm_intern (interp->vm, name)];
  JS_COPY ((JSNode *) value, n);
}


void
js_get_options (JSInterpPtr interp, JSInterpOptions *options)
{
  memcpy (options, &interp->options, sizeof (*options));
}


void
js_set_options (JSInterpPtr interp, JSInterpOptions *options)
{
  memcpy (&interp->options, options, sizeof (*options));

  /* User can change the security options, */

  if (interp->options.secure_builtin_file)
    interp->vm->security |= JS_VM_SECURE_FILE;
  else
    interp->vm->security &= ~JS_VM_SECURE_FILE;

  if (interp->options.secure_builtin_system)
    interp->vm->security |= JS_VM_SECURE_SYSTEM;
  else
    interp->vm->security &= ~JS_VM_SECURE_SYSTEM;

  /* and the event hook. */
  interp->vm->hook			 = options->hook;
  interp->vm->hook_context		 = options->hook_context;
  interp->vm->hook_operand_count_trigger = options->hook_operand_count_trigger;
}


int
js_create_global_method (JSInterpPtr interp, char *name,
			 JSGlobalMethodProc proc, void *context,
			 JSFreeProc context_free_proc)
{
  JSNode *n = &interp->vm->globals[js_vm_intern (interp->vm, name)];
  JSVirtualMachine *vm = interp->vm;
  int result = 1;

  /* Need one toplevel here. */
  {
    JSErrorHandlerFrame handler;

    /* We must create the toplevel ourself. */
    memset (&handler, 0, sizeof (handler));
    handler.next = vm->error_handler;
    vm->error_handler = &handler;

    if (setjmp (vm->error_handler->error_jmp))
      /* An error occurred. */
      result = 0;
    else
      {
	JSBuiltinInfo *info;
	JSGlobalMethodContext *ctx;

	/* Context. */
	ctx = js_calloc (vm, 1, sizeof (*ctx));

	ctx->proc = proc;
	ctx->context = context;
	ctx->free_proc = context_free_proc;
	ctx->interp = interp;

	/* Info. */
	info = js_vm_builtin_info_create (vm);
	info->global_method_proc = js_global_method_stub;
	info->delete_proc = js_global_method_delete;

	/* Create the builtin. */
	js_vm_builtin_create (interp->vm, n, info, ctx);
      }

    /* Pop the error handler. */
    vm->error_handler = vm->error_handler->next;
  }

  return result;
}


int
js_define_module (JSInterpPtr interp, JSModuleInitProc init_proc)
{
  JSErrorHandlerFrame handler;
  JSVirtualMachine *vm = interp->vm;
  int result = 1;

  /* Just call the init proc in a toplevel. */

  memset (&handler, 0, sizeof (handler));
  handler.next = vm->error_handler;
  vm->error_handler = &handler;

  if (setjmp (vm->error_handler->error_jmp))
    /* An error occurred. */
    result = 0;
  else
    /* Call the module init proc. */
    (*init_proc) (interp);

  /* Pop the error handler. */
  vm->error_handler = vm->error_handler->next;

  return result;
}



/*
 * Static functions.
 */

static int
js_eval_source (JSInterpPtr interp, JSNode *source, char *compiler_function)
{
  JSNode argv[5];
  int i = 0;
  int result;
  JSByteCode *bc;

  /* Let's compile the code. */

  /* Argument count. */
  argv[i].type = JS_INTEGER;
  argv[i].u.vinteger = 4;
  i++;

  /* Source to compiler. */
  JS_COPY (&argv[i], source);
  i++;

  /* Flags. */
  argv[i].type = JS_INTEGER;
  argv[i].u.vinteger = 0;

  if (interp->options.verbose)
    argv[i].u.vinteger = JSC_FLAG_VERBOSE;

  argv[i].u.vinteger |= JSC_FLAG_GENERATE_DEBUG_INFO;

  argv[i].u.vinteger |= JSC_FLAG_OPTIMIZE_PEEPHOLE;
  argv[i].u.vinteger |= JSC_FLAG_OPTIMIZE_JUMPS;
  argv[i].u.vinteger |= JSC_FLAG_WARN_WITH_CLOBBER;
  i++;

  /* Assembler file. */
  argv[i].type = JS_NULL;
  i++;

  /* Byte-code file. */
  argv[i].type = JS_NULL;
  i++;

  /* Call the compiler entry point. */
  result = js_vm_apply (interp->vm, compiler_function, NULL, i, argv);
  if (result == 0)
    return 0;

  /*
   * The resulting byte-code file is now at vm->exec_result.
   *
   * Note!  The byte-code is a string allocated form the vm heap.
   * The garbage collector can free it when it wants since the result
   * isn't protected.  However, we have no risk here because we
   * first convert the byte-code data block to our internal
   * JSByteCode block that shares no memory with the original data.
   */

  assert (interp->vm->exec_result.type == JS_STRING);

  bc = js_bc_read_data (interp->vm->exec_result.u.vstring->data,
			interp->vm->exec_result.u.vstring->len);

  /* And finally, execute it. */
  result = js_vm_execute (interp->vm, bc);

  /* Free the byte-code. */
  js_bc_free (bc);

  return result;
}


static int
js_compile_source (JSInterpPtr interp,  JSNode *source,
		   char *compiler_function, char *assembler_file,
		   char *byte_code_file, JSNode *bc_return)
{
  JSNode argv[5];
  int i = 0;
  int result;

  /* Init arguments. */

  argv[i].type = JS_INTEGER;
  argv[i].u.vinteger = 4;
  i++;

  /* Source to compiler. */
  JS_COPY (&argv[1], source);
  i++;

  /* Flags. */
  argv[i].type = JS_INTEGER;
  argv[i].u.vinteger = 0;

  if (interp->options.verbose)
    argv[i].u.vinteger |= JSC_FLAG_VERBOSE;
  if (interp->options.annotate_assembler)
    argv[i].u.vinteger |= JSC_FLAG_ANNOTATE_ASSEMBLER;
  if (interp->options.debug_info)
    argv[i].u.vinteger |= JSC_FLAG_GENERATE_DEBUG_INFO;
  if (interp->options.executable_bc_files)
    argv[i].u.vinteger |= JSC_FLAG_GENERATE_EXECUTABLE_BC_FILES;

  if (interp->options.warn_unused_argument)
    argv[i].u.vinteger |= JSC_FLAG_WARN_UNUSED_ARGUMENT;
  if (interp->options.warn_unused_variable)
    argv[i].u.vinteger |= JSC_FLAG_WARN_UNUSED_VARIABLE;
  if (interp->options.warn_shadow)
    argv[i].u.vinteger |= JSC_FLAG_WARN_SHADOW;
  if (interp->options.warn_with_clobber)
    argv[i].u.vinteger |= JSC_FLAG_WARN_WITH_CLOBBER;
  if (interp->options.warn_missing_semicolon)
    argv[i].u.vinteger |= JSC_FLAG_WARN_MISSING_SEMICOLON;
  if (interp->options.warn_strict_ecma)
    argv[i].u.vinteger |= JSC_FLAG_WARN_STRICT_ECMA;
  if (interp->options.warn_deprecated)
    argv[i].u.vinteger |= JSC_FLAG_WARN_DEPRECATED;

  if (interp->options.optimize_peephole)
    argv[i].u.vinteger |= JSC_FLAG_OPTIMIZE_PEEPHOLE;
  if (interp->options.optimize_jumps_to_jumps)
    argv[i].u.vinteger |= JSC_FLAG_OPTIMIZE_JUMPS;
  if (interp->options.optimize_bc_size)
    argv[i].u.vinteger |= JSC_FLAG_OPTIMIZE_BC_SIZE;
  if (interp->options.optimize_heavy)
    argv[i].u.vinteger |= JSC_FLAG_OPTIMIZE_HEAVY;

  i++;

  /* Assembler file. */
  if (assembler_file)
    js_vm_make_static_string (interp->vm, &argv[i], assembler_file,
			      strlen (assembler_file));
  else
    argv[i].type = JS_NULL;
  i++;

  /* Byte-code file. */
  if (byte_code_file)
    js_vm_make_static_string (interp->vm, &argv[i], byte_code_file,
			      strlen (byte_code_file));
  else
    argv[i].type = JS_NULL;
  i++;

  /* Call the compiler entry point. */
  result = js_vm_apply (interp->vm, compiler_function, NULL, i, argv);
  if (result == 0)
    return 0;

  if (bc_return)
    /* User wanted to get the resulting byte-code data.  Here it is. */
    JS_COPY (bc_return, &interp->vm->exec_result);

  return result;
}


/*
 * Global methods.
 */

static void
eval_global_method (JSVirtualMachine *vm, JSBuiltinInfo *builtin_info,
		    void *instance_context, JSNode *result_return,
		    JSNode *args)
{
  JSInterpPtr interp = instance_context;

  if (args->u.vinteger != 1)
    {
      sprintf (vm->error, "eval(): illegal amount of arguments");
      js_vm_error (vm);
    }
  if (args[1].type != JS_STRING)
    {
      /* Return it to the caller. */
      JS_COPY (result_return, &args[1]);
      return;
    }

  /*
   * Ok, we'r ready to eval it.  The source strings is our argument, so,
   * it is in the stack and therefore, protected for gc.
   */
  if (!js_eval_source (interp, &args[1], "JSC$compile_string"))
    {
      /* The evaluation failed.  Throw it as an error to our caller. */
      js_vm_error (vm);
    }

  /* Pass the return value to our caller. */
  JS_COPY (result_return, &vm->exec_result);
}


static void
load_global_method (JSVirtualMachine *vm, JSBuiltinInfo *builtin_info,
		    void *instance_context,
		    JSNode *result_return, JSNode *args)
{
  JSInterpPtr interp = instance_context;
  int i;
  int result;

  if (args->u.vinteger == 0)
    {
      sprintf (vm->error, "load(): no arguments given");
      js_vm_error (vm);
    }

  for (i = 1; i <= args->u.vinteger; i++)
    {
      char *cp;

      if (args[i].type != JS_STRING)
	{
	  sprintf (vm->error, "load(): illegal argument");
	  js_vm_error (vm);
	}

      cp = js_string_to_c_string (vm, &args[i]);
      result = js_eval_file (interp, cp);
      js_free (cp);

      if (!result)
	js_vm_error (vm);
    }

  result_return->type = JS_BOOLEAN;
  result_return->u.vboolean = 1;
}


static void
load_class_global_method (JSVirtualMachine *vm, JSBuiltinInfo *builtin_info,
			  void *instance_context,
			  JSNode *result_return, JSNode *args)
{
  JSInterpPtr interp = instance_context;
  int i;

  if (args->u.vinteger == 0)
    {
      sprintf (vm->error, "loadClass(): no arguments given");
      js_vm_error (vm);
    }

  for (i = 1; i <= args->u.vinteger; i++)
    {
      char *cp, *cp2;
      void *lib;
      void (*func) (JSInterpPtr interp);
      char *func_name;
      char buf[512];

      if (args[i].type != JS_STRING)
	{
	  sprintf (vm->error, "loadClass(): illegal argument");
	  js_vm_error (vm);
	}

      cp = js_string_to_c_string (vm, &args[i]);

      /* Extract the function name. */
      func_name = strrchr (cp, ':');
      if (func_name == NULL)
	{
	  func_name = strrchr (cp, '/');
	  if (func_name == NULL)
	    func_name = cp;
	  else
	    func_name++;
	}
      else
	{
	  *func_name = '\0';
	  func_name++;
	}

      /* Try to open the library. */
      lib = js_dl_open (cp, buf, sizeof (buf));
      if (lib == NULL)
	{
	  sprintf (vm->error, "loadClass(): couldn't open library `%s': %s",
		   cp, buf);
	  js_vm_error (vm);
	}

      /*
       * Strip all suffixes from the library name: if the <func_name>
       * is extracted from it, this will convert the library name
       * `foo.so.x.y' to the canonical entry point name `foo'.
       */
      cp2 = strchr (cp, '.');
      if (cp2)
	*cp2 = '\0';

      func = js_dl_sym (lib, func_name, buf, sizeof (buf));
      if (func == NULL)
	{
	  sprintf (vm->error,
		   "loadClass(): couldn't find the init function `%s': %s",
		   func_name, buf);
	  js_vm_error (vm);
	}

      /* All done with this argument. */
      js_free (cp);

      /*
       * And finally, call the library entry point.  All possible errors
       * will throw us to the containing top-level.
       */
      (*func) (interp);
    }

  result_return->type = JS_UNDEFINED;
}


static void
call_method_global_method (JSVirtualMachine *vm, JSBuiltinInfo *builtin_info,
			   void *instance_context,
			   JSNode *result_return, JSNode *args)
{
  JSInterpPtr interp = instance_context;
  JSNode *argv;
  int i;
  int result;
  char *cp;

  if (args->u.vinteger != 3)
    {
      sprintf (vm->error, "callMethod(): illegal amount of arguments");
      js_vm_error (vm);
    }
  if (args[2].type != JS_STRING)
    {
    illegal_argument:
      sprintf (vm->error, "callMethod(): illegal argument");
      js_vm_error (vm);
    }
  if (args[3].type != JS_ARRAY)
    goto illegal_argument;

  /* Create the argument array. */
  argv = js_malloc (vm, (args[3].u.varray->length + 1) * sizeof (JSNode));

  /* The argument count. */
  argv[0].type = JS_INTEGER;
  argv[0].u.vinteger = args[3].u.varray->length;

  for (i = 0; i < args[3].u.varray->length; i++)
    JS_COPY (&argv[i + 1], &args[3].u.varray->data[i]);

  /* Method name to C string. */
  cp = js_string_to_c_string (vm, &args[2]);

  /* Call it. */
  result = js_vm_call_method (vm, &args[1], cp, args[3].u.varray->length + 1,
			      argv);

  /* Cleanup. */
  js_free (cp);
  js_free (argv);

  if (result)
    JS_COPY (result_return, &vm->exec_result);
  else
    /* The error message is already there. */
    js_vm_error (vm);
}


static void
js_core_globals (JSInterpPtr interp)
{
  JSNode *n;
  JSBuiltinInfo *info;
  JSVirtualMachine *vm = interp->vm;

  if (!interp->options.no_compiler)
    {
      /* Command `eval'. */

      info = js_vm_builtin_info_create (vm);
      info->global_method_proc = eval_global_method;

      n = &interp->vm->globals[js_vm_intern (interp->vm, "eval")];

      js_vm_builtin_create (interp->vm, n, info, interp);
    }

  /* Command `load'. */

  info = js_vm_builtin_info_create (vm);
  info->global_method_proc = load_global_method;

  n = &interp->vm->globals[js_vm_intern (interp->vm, "load")];
  js_vm_builtin_create (interp->vm, n, info, interp);

  /* Command `loadClass'. */

  info = js_vm_builtin_info_create (vm);
  info->global_method_proc = load_class_global_method;

  n = &interp->vm->globals[js_vm_intern (interp->vm, "loadClass")];
  js_vm_builtin_create (interp->vm, n, info, interp);

  /* Command `callMethod'. */

  info = js_vm_builtin_info_create (vm);
  info->global_method_proc = call_method_global_method;

  n = &interp->vm->globals[js_vm_intern (interp->vm, "callMethod")];
  js_vm_builtin_create (interp->vm, n, info, interp);
}


static void
js_global_method_stub (JSVirtualMachine *vm, JSBuiltinInfo *builtin_info,
		       void *instance_context, JSNode *result_return,
		       JSNode *args)
{
  JSMethodResult result;
  JSGlobalMethodContext *ctx = instance_context;

  /* Set the default result. */
  result_return->type = JS_UNDEFINED;

  /* Call the user supplied function. */
  result = (*ctx->proc) (ctx->context, ctx->interp, args->u.vinteger,
			 (JSType *) &args[1], (JSType *) result_return,
			 vm->error);
  if (result != JS_OK)
    js_vm_error (ctx->interp->vm);
}


static void
js_global_method_delete (JSBuiltinInfo *builtin_info, void *instance_context)
{
  JSGlobalMethodContext *ctx = instance_context;

  if (ctx)
    {
      if (ctx->free_proc)
	(*ctx->free_proc) (ctx->context);

      js_free (ctx);
    }
}


/* I/O Stream to user I/O function. */

static int
iofunc_io (void *context, unsigned char *buffer, unsigned int todo,
	   int *error_return)
{
  JSUserIOFuncCtx *ctx = context;
  int moved;

  *error_return = 0;

  moved = (*ctx->func) (ctx->context, buffer, todo);
  if (moved >= 0)
    ctx->position += moved;

  return moved;
}


static int
iofunc_seek (void *context, long offset, int whence)
{
  return -1;
}


static long
iofunc_get_position (void *context)
{
  JSUserIOFuncCtx *ctx = context;

  return ctx->position;
}


static long
iofunc_get_length (void *context)
{
  return -1;
}


static void
iofunc_close (void *context)
{
  js_free (context);
}


static JSIOStream *
iostream_iofunc (JSIOFunc func, void *context, int readp, int writep)
{
  JSIOStream *stream = js_iostream_new ();
  JSUserIOFuncCtx *ctx;

  if (stream == NULL)
    return NULL;

  ctx = js_malloc (NULL, sizeof (*ctx));
  if (ctx == NULL)
    {
      (void) js_iostream_close (stream);
      return NULL;
    }

  /* Init context. */
  ctx->func = func;
  ctx->context = context;
  ctx->position = 0;

  if (readp)
    stream->read = iofunc_io;
  if (writep)
    stream->write = iofunc_io;

  stream->seek		= iofunc_seek;
  stream->get_position	= iofunc_get_position;
  stream->get_length	= iofunc_get_length;
  stream->close		= iofunc_close;
  stream->context 	= ctx;

  return stream;
}
#endif	/*CL_EXPERIMENTAL*/