688 lines
16 KiB
C
688 lines
16 KiB
C
/*
|
|
* mooscript-context.c
|
|
*
|
|
* Copyright (C) 2004-2006 by Yevgen Muntyan <muntyan@math.tamu.edu>
|
|
*
|
|
* 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 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* See COPYING file that comes with this distribution.
|
|
*/
|
|
|
|
#include "mooscript-context.h"
|
|
#include "mooscript-parser.h"
|
|
#include "mooutils/moomarshals.h"
|
|
#include <glib/gprintf.h>
|
|
#include <gtk/gtkwindow.h>
|
|
|
|
#define N_POS_VARS 20
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_WINDOW,
|
|
PROP_NAME,
|
|
PROP_ARGV
|
|
};
|
|
|
|
enum {
|
|
GET_ENV_VAR,
|
|
N_SIGNALS
|
|
};
|
|
|
|
static guint signals[N_SIGNALS];
|
|
|
|
G_DEFINE_TYPE (MSContext, ms_context, G_TYPE_OBJECT)
|
|
|
|
|
|
#if GLIB_CHECK_VERSION(2,10,0)
|
|
#define ms_variable_alloc() g_slice_new0 (MSVariable)
|
|
#define ms_variable_free(v) g_slice_free (MSVariable, v)
|
|
#else
|
|
#define ms_variable_alloc() g_new0 (MSVariable, 1)
|
|
#define ms_variable_free(v) g_free (v)
|
|
#endif
|
|
|
|
static void
|
|
ms_context_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
MSContext *ctx = MS_CONTEXT (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_WINDOW:
|
|
ctx->window = g_value_get_object (value);
|
|
g_object_notify (object, "window");
|
|
break;
|
|
|
|
case PROP_NAME:
|
|
g_free (ctx->name);
|
|
ctx->window = g_strdup (g_value_get_string (value));
|
|
g_object_notify (object, "name");
|
|
break;
|
|
|
|
case PROP_ARGV:
|
|
g_strfreev (ctx->argv);
|
|
ctx->argv = g_strdupv (g_value_get_pointer (value));
|
|
ctx->argc = ctx->argv ? g_strv_length (ctx->argv) : 0;
|
|
g_object_notify (object, "argv");
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
ms_context_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
MSContext *ctx = MS_CONTEXT (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_WINDOW:
|
|
g_value_set_object (value, ctx->window);
|
|
break;
|
|
|
|
case PROP_NAME:
|
|
g_value_set_string (value, ctx->name);
|
|
break;
|
|
|
|
case PROP_ARGV:
|
|
g_value_set_pointer (value, ctx->argv);
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
default_print_func (const char *string,
|
|
G_GNUC_UNUSED MSContext *ctx)
|
|
{
|
|
g_print ("%s", string);
|
|
}
|
|
|
|
|
|
static GObject *
|
|
ms_context_constructor (GType type,
|
|
guint n_props,
|
|
GObjectConstructParam *props)
|
|
{
|
|
GObject *obj;
|
|
MSContext *ctx;
|
|
|
|
obj = G_OBJECT_CLASS(ms_context_parent_class)->constructor (type, n_props, props);
|
|
ctx = MS_CONTEXT (obj);
|
|
|
|
if (!ctx->name)
|
|
{
|
|
if (ctx->argv && ctx->argc)
|
|
ctx->name = g_strdup (ctx->argv[0]);
|
|
else
|
|
ctx->name = g_strdup ("script");
|
|
}
|
|
|
|
if (!ctx->argv || !ctx->argc)
|
|
{
|
|
g_strfreev (ctx->argv);
|
|
ctx->argv = g_new0 (char*, 2);
|
|
ctx->argv[0] = g_strdup (ctx->name);
|
|
ctx->argc = 1;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
|
|
static void
|
|
ms_context_init (MSContext *ctx)
|
|
{
|
|
ctx->vars = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
|
|
(GDestroyNotify) ms_variable_unref);
|
|
|
|
if (moo_python_running ())
|
|
ctx->py_dict = moo_py_get_script_dict ("__moo_script__");
|
|
|
|
ctx->print_func = default_print_func;
|
|
|
|
_ms_context_add_builtin (ctx);
|
|
}
|
|
|
|
|
|
static void
|
|
ms_context_finalize (GObject *object)
|
|
{
|
|
MSContext *ctx = MS_CONTEXT (object);
|
|
|
|
if (moo_python_running ())
|
|
moo_Py_DECREF (ctx->py_dict);
|
|
|
|
g_hash_table_destroy (ctx->vars);
|
|
g_free (ctx->error_msg);
|
|
|
|
ms_value_unref (ctx->return_val);
|
|
|
|
g_free (ctx->name);
|
|
g_strfreev (ctx->argv);
|
|
|
|
G_OBJECT_CLASS(ms_context_parent_class)->finalize (object);
|
|
}
|
|
|
|
|
|
static void
|
|
ms_context_class_init (MSContextClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->finalize = ms_context_finalize;
|
|
object_class->set_property = ms_context_set_property;
|
|
object_class->get_property = ms_context_get_property;
|
|
object_class->constructor = ms_context_constructor;
|
|
|
|
ms_type_init ();
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_WINDOW,
|
|
g_param_spec_object ("window",
|
|
"window",
|
|
"window",
|
|
GTK_TYPE_WINDOW,
|
|
G_PARAM_READWRITE));
|
|
|
|
signals[GET_ENV_VAR] =
|
|
g_signal_new ("get-env-var",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (MSContextClass, get_env_var),
|
|
NULL, NULL,
|
|
_moo_marshal_BOXED__STRING,
|
|
MS_TYPE_VALUE, 1,
|
|
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
}
|
|
|
|
|
|
MSContext *
|
|
ms_context_new (gpointer window)
|
|
{
|
|
MSContext *ctx = g_object_new (MS_TYPE_CONTEXT,
|
|
"window", window, NULL);
|
|
return ctx;
|
|
}
|
|
|
|
|
|
MSValue *
|
|
ms_context_eval_variable (MSContext *ctx,
|
|
const char *name)
|
|
{
|
|
MSVariable *var;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
var = ms_context_lookup_var (ctx, name);
|
|
|
|
if (!var)
|
|
return ms_context_format_error (ctx, MS_ERROR_NAME,
|
|
"no variable named '%s'",
|
|
name);
|
|
|
|
if (var->value)
|
|
return ms_value_ref (var->value);
|
|
|
|
return ms_func_call (var->func, NULL, 0, ctx);
|
|
}
|
|
|
|
|
|
gboolean
|
|
ms_context_assign_variable (MSContext *ctx,
|
|
const char *name,
|
|
MSValue *value)
|
|
{
|
|
MSVariable *var;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), FALSE);
|
|
g_return_val_if_fail (name != NULL, FALSE);
|
|
|
|
var = ms_context_lookup_var (ctx, name);
|
|
|
|
if (value)
|
|
{
|
|
if (var)
|
|
{
|
|
if (var->func)
|
|
{
|
|
g_object_unref (var->func);
|
|
var->func = NULL;
|
|
}
|
|
|
|
if (var->value != value)
|
|
{
|
|
ms_value_unref (var->value);
|
|
var->value = ms_value_ref (value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var = ms_variable_new_value (value);
|
|
ms_context_set_var (ctx, name, var);
|
|
ms_variable_unref (var);
|
|
}
|
|
}
|
|
else if (var)
|
|
{
|
|
ms_context_set_var (ctx, name, NULL);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
gboolean
|
|
ms_context_assign_string (MSContext *ctx,
|
|
const char *name,
|
|
const char *str_value)
|
|
{
|
|
MSValue *value = NULL;
|
|
gboolean retval;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), FALSE);
|
|
g_return_val_if_fail (name != NULL, FALSE);
|
|
|
|
if (str_value)
|
|
value = ms_value_string (str_value);
|
|
|
|
retval = ms_context_assign_variable (ctx, name, value);
|
|
|
|
ms_value_unref (value);
|
|
return retval;
|
|
}
|
|
|
|
|
|
gboolean
|
|
ms_context_assign_positional (MSContext *ctx,
|
|
guint n,
|
|
MSValue *value)
|
|
{
|
|
char *name;
|
|
gboolean result;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), FALSE);
|
|
|
|
name = g_strdup_printf ("_%d", n);
|
|
result = ms_context_assign_variable (ctx, name, value);
|
|
|
|
g_free (name);
|
|
return result;
|
|
}
|
|
|
|
|
|
MSVariable *
|
|
ms_context_lookup_var (MSContext *ctx,
|
|
const char *name)
|
|
{
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
return g_hash_table_lookup (ctx->vars, name);
|
|
}
|
|
|
|
|
|
gboolean
|
|
ms_context_set_var (MSContext *ctx,
|
|
const char *name,
|
|
MSVariable *var)
|
|
{
|
|
MSVariable *old;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), FALSE);
|
|
g_return_val_if_fail (name != NULL, FALSE);
|
|
|
|
old = g_hash_table_lookup (ctx->vars, name);
|
|
|
|
if (var != old)
|
|
{
|
|
if (var)
|
|
g_hash_table_insert (ctx->vars, g_strdup (name),
|
|
ms_variable_ref (var));
|
|
else
|
|
g_hash_table_remove (ctx->vars, name);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
gboolean
|
|
ms_context_set_func (MSContext *ctx,
|
|
const char *name,
|
|
MSFunc *func)
|
|
{
|
|
MSValue *vfunc;
|
|
gboolean ret;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), FALSE);
|
|
g_return_val_if_fail (name != NULL, FALSE);
|
|
g_return_val_if_fail (!func || MS_IS_FUNC (func), FALSE);
|
|
|
|
vfunc = ms_value_func (func);
|
|
ret = ms_context_assign_variable (ctx, name, vfunc);
|
|
ms_value_unref (vfunc);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
MSValue *
|
|
ms_context_set_error (MSContext *ctx,
|
|
MSError error,
|
|
const char *message)
|
|
{
|
|
const char *errname;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (!ctx->error && error, NULL);
|
|
g_return_val_if_fail (!ctx->error_msg, NULL);
|
|
|
|
ctx->error = error;
|
|
errname = ms_context_get_error_msg (ctx);
|
|
|
|
if (message && *message)
|
|
ctx->error_msg = g_strdup_printf ("%s: %s", errname, message);
|
|
else
|
|
ctx->error_msg = g_strdup (message);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
MSValue *
|
|
ms_context_format_error (MSContext *ctx,
|
|
MSError error,
|
|
const char *format,
|
|
...)
|
|
{
|
|
va_list args;
|
|
char *string;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (!ctx->error && error, NULL);
|
|
g_return_val_if_fail (!ctx->error_msg, NULL);
|
|
|
|
if (!format || !format[0])
|
|
{
|
|
ms_context_set_error (ctx, error, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
va_start (args, format);
|
|
string = ms_vaprintf (format, args);
|
|
va_end (args);
|
|
|
|
ms_context_set_error (ctx, error, string);
|
|
g_free (string);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void
|
|
ms_context_clear_error (MSContext *ctx)
|
|
{
|
|
g_return_if_fail (MS_IS_CONTEXT (ctx));
|
|
ctx->error = MS_ERROR_NONE;
|
|
g_free (ctx->error_msg);
|
|
ctx->error_msg = NULL;
|
|
}
|
|
|
|
|
|
const char *
|
|
ms_context_get_error_msg (MSContext *ctx)
|
|
{
|
|
static const char *msgs[MS_ERROR_LAST] = {
|
|
NULL, "Type error", "Value error", "Name error",
|
|
"Runtime error"
|
|
};
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (ctx->error < MS_ERROR_LAST, NULL);
|
|
g_return_val_if_fail (ctx->error != MS_ERROR_NONE, "ERROR");
|
|
|
|
if (ctx->error_msg)
|
|
return ctx->error_msg;
|
|
else
|
|
return msgs[ctx->error];
|
|
}
|
|
|
|
|
|
static MSVariable *
|
|
ms_variable_new (void)
|
|
{
|
|
MSVariable *var = ms_variable_alloc ();
|
|
var->ref_count = 1;
|
|
return var;
|
|
}
|
|
|
|
|
|
MSVariable *
|
|
ms_variable_new_value (MSValue *value)
|
|
{
|
|
MSVariable *var;
|
|
|
|
g_return_val_if_fail (value != NULL, NULL);
|
|
|
|
var = ms_variable_new ();
|
|
var->value = ms_value_ref (value);
|
|
|
|
return var;
|
|
}
|
|
|
|
|
|
MSVariable *
|
|
ms_variable_new_func (MSFunc *func)
|
|
{
|
|
MSVariable *var;
|
|
|
|
g_return_val_if_fail (MS_IS_FUNC (func), NULL);
|
|
|
|
var = ms_variable_new ();
|
|
var->func = g_object_ref (func);
|
|
|
|
return var;
|
|
}
|
|
|
|
|
|
MSVariable *
|
|
ms_variable_ref (MSVariable *var)
|
|
{
|
|
g_return_val_if_fail (var != NULL, NULL);
|
|
var->ref_count++;
|
|
return var;
|
|
}
|
|
|
|
|
|
void
|
|
ms_variable_unref (MSVariable *var)
|
|
{
|
|
g_return_if_fail (var != NULL);
|
|
|
|
if (!--var->ref_count)
|
|
{
|
|
ms_value_unref (var->value);
|
|
if (var->func)
|
|
g_object_unref (var->func);
|
|
ms_variable_free (var);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
ms_context_set_return (MSContext *ctx,
|
|
MSValue *val)
|
|
{
|
|
g_return_if_fail (MS_IS_CONTEXT (ctx));
|
|
g_return_if_fail (!ctx->return_set);
|
|
ctx->return_set = TRUE;
|
|
ctx->return_val = val ? ms_value_ref (val) : ms_value_none ();
|
|
}
|
|
|
|
|
|
void
|
|
ms_context_set_break (MSContext *ctx)
|
|
{
|
|
g_return_if_fail (MS_IS_CONTEXT (ctx));
|
|
g_return_if_fail (!ctx->break_set);
|
|
ctx->break_set = TRUE;
|
|
}
|
|
|
|
|
|
void
|
|
ms_context_set_continue (MSContext *ctx)
|
|
{
|
|
g_return_if_fail (MS_IS_CONTEXT (ctx));
|
|
g_return_if_fail (!ctx->continue_set);
|
|
ctx->continue_set = TRUE;
|
|
}
|
|
|
|
|
|
void
|
|
ms_context_unset_return (MSContext *ctx)
|
|
{
|
|
g_return_if_fail (MS_IS_CONTEXT (ctx));
|
|
g_return_if_fail (ctx->return_set);
|
|
ctx->return_set = FALSE;
|
|
ms_value_unref (ctx->return_val);
|
|
ctx->return_val = NULL;
|
|
}
|
|
|
|
|
|
void
|
|
ms_context_unset_break (MSContext *ctx)
|
|
{
|
|
g_return_if_fail (MS_IS_CONTEXT (ctx));
|
|
g_return_if_fail (ctx->break_set);
|
|
ctx->break_set = FALSE;
|
|
}
|
|
|
|
|
|
void
|
|
ms_context_unset_continue (MSContext *ctx)
|
|
{
|
|
g_return_if_fail (MS_IS_CONTEXT (ctx));
|
|
g_return_if_fail (ctx->continue_set);
|
|
ctx->continue_set = FALSE;
|
|
}
|
|
|
|
|
|
MSValue *
|
|
ms_context_run_script (MSContext *ctx,
|
|
const char *script)
|
|
{
|
|
MSNode *node;
|
|
MSValue *result;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (script != NULL, NULL);
|
|
|
|
node = ms_script_parse (script);
|
|
g_return_val_if_fail (node != NULL, NULL);
|
|
|
|
result = ms_top_node_eval (node, ctx);
|
|
|
|
ms_node_unref (node);
|
|
return result;
|
|
}
|
|
|
|
|
|
MSValue *
|
|
ms_context_get_env_variable (MSContext *ctx,
|
|
const char *name)
|
|
{
|
|
MSValue *val = NULL;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
|
|
g_signal_emit (ctx, signals[GET_ENV_VAR], 0, name, &val);
|
|
|
|
return val;
|
|
}
|
|
|
|
|
|
/************************************************************************/
|
|
/* Python
|
|
*/
|
|
|
|
void
|
|
ms_context_assign_py_var (MSContext *ctx,
|
|
const char *var,
|
|
MooPyObject *obj)
|
|
{
|
|
g_return_if_fail (MS_IS_CONTEXT (ctx));
|
|
g_return_if_fail (var != NULL);
|
|
g_return_if_fail (obj != NULL);
|
|
g_return_if_fail (moo_python_running ());
|
|
|
|
if (!ctx->py_dict)
|
|
ctx->py_dict = moo_py_get_script_dict ("__moo_script__");
|
|
|
|
moo_py_dict_set_item (ctx->py_dict, var, obj);
|
|
}
|
|
|
|
|
|
void
|
|
ms_context_assign_py_object (MSContext *ctx,
|
|
const char *var,
|
|
gpointer gobj)
|
|
{
|
|
MooPyObject *pyobj;
|
|
|
|
g_return_if_fail (moo_python_running ());
|
|
g_return_if_fail (MS_IS_CONTEXT (ctx));
|
|
g_return_if_fail (var != NULL);
|
|
g_return_if_fail (!gobj || G_IS_OBJECT (gobj));
|
|
|
|
pyobj = moo_py_object_from_gobject (gobj);
|
|
g_return_if_fail (pyobj != NULL);
|
|
ms_context_assign_py_var (ctx, var, pyobj);
|
|
moo_Py_DECREF (pyobj);
|
|
}
|
|
|
|
|
|
MSValue *
|
|
ms_context_run_python (MSContext *ctx,
|
|
const char *script)
|
|
{
|
|
MooPyObject *py_ret;
|
|
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (script != NULL, NULL);
|
|
|
|
if (!moo_python_running())
|
|
return ms_context_format_error (ctx, MS_ERROR_RUNTIME,
|
|
"Python support not available");
|
|
|
|
py_ret = moo_python_run_string (script, ctx->py_dict, ctx->py_dict);
|
|
|
|
if (py_ret)
|
|
{
|
|
moo_Py_DECREF (py_ret);
|
|
return ms_value_none ();
|
|
}
|
|
else
|
|
{
|
|
moo_PyErr_Print ();
|
|
return ms_context_format_error (ctx, MS_ERROR_RUNTIME,
|
|
"python script raised exception");
|
|
}
|
|
}
|