1599 lines
34 KiB
C
1599 lines
34 KiB
C
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4; coding: utf-8 -*-
|
|
*
|
|
* as-script-node.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-node.h"
|
|
#include "mooscript-func.h"
|
|
#include "mooscript-context.h"
|
|
#include "mooutils/moopython.h"
|
|
#include <string.h>
|
|
|
|
|
|
MSValue *
|
|
_ms_node_eval (MSNode *node,
|
|
MSContext *ctx)
|
|
{
|
|
g_return_val_if_fail (node != NULL, NULL);
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (node->eval != NULL, NULL);
|
|
return node->eval (node, ctx);
|
|
}
|
|
|
|
|
|
MSValue *
|
|
ms_top_node_eval (MSNode *node,
|
|
MSContext *ctx)
|
|
{
|
|
MSValue *ret;
|
|
|
|
g_return_val_if_fail (node != NULL, NULL);
|
|
g_return_val_if_fail (MS_IS_CONTEXT (ctx), NULL);
|
|
g_return_val_if_fail (node->eval != NULL, NULL);
|
|
|
|
ret = _ms_node_eval (node, ctx);
|
|
|
|
if (ctx->return_set)
|
|
ms_context_unset_return (ctx);
|
|
if (ctx->break_set)
|
|
ms_context_unset_break (ctx);
|
|
if (ctx->continue_set)
|
|
ms_context_unset_continue (ctx);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static MSNode *
|
|
ms_node_new (gsize node_size,
|
|
MSNodeType type,
|
|
MSNodeEval eval,
|
|
MSNodeDestroy destroy)
|
|
{
|
|
MSNode *node;
|
|
|
|
g_assert (node_size >= sizeof (MSNode));
|
|
g_assert (type && type < MS_TYPE_NODE_LAST);
|
|
|
|
node = g_malloc0 (node_size);
|
|
node->ref_count = 1;
|
|
node->type = type;
|
|
node->eval = eval;
|
|
node->destroy = destroy;
|
|
|
|
return node;
|
|
}
|
|
|
|
#define NODE_NEW(Type_,type_,eval_,destroy_) \
|
|
((Type_*) ms_node_new (sizeof (Type_), type_, eval_, destroy_))
|
|
|
|
|
|
gpointer
|
|
ms_node_ref (gpointer node)
|
|
{
|
|
if (node)
|
|
MS_NODE(node)->ref_count++;
|
|
return node;
|
|
}
|
|
|
|
|
|
void
|
|
ms_node_unref (gpointer node)
|
|
{
|
|
if (node && !--MS_NODE(node)->ref_count)
|
|
{
|
|
if (MS_NODE(node)->destroy)
|
|
MS_NODE(node)->destroy (node);
|
|
g_free (node);
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeList
|
|
*/
|
|
|
|
static MSValue*
|
|
ms_node_list_eval (MSNode *node,
|
|
MSContext *ctx)
|
|
{
|
|
guint i;
|
|
MSValue *ret = NULL;
|
|
MSNodeList *list = MS_NODE_LIST (node);
|
|
|
|
if (!list->n_nodes)
|
|
return ms_value_none ();
|
|
|
|
for (i = 0; i < list->n_nodes; ++i)
|
|
{
|
|
ret = _ms_node_eval (list->nodes[i], ctx);
|
|
|
|
if (!ret)
|
|
return NULL;
|
|
|
|
if (ctx->return_set)
|
|
{
|
|
ms_value_unref (ret);
|
|
ret = ms_value_ref (ctx->return_val);
|
|
break;
|
|
}
|
|
|
|
if (ctx->break_set || ctx->continue_set)
|
|
break;
|
|
|
|
if (i + 1 < list->n_nodes)
|
|
ms_value_unref (ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void
|
|
ms_node_list_destroy (MSNode *node)
|
|
{
|
|
guint i;
|
|
MSNodeList *list = MS_NODE_LIST (node);
|
|
for (i = 0; i < list->n_nodes; ++i)
|
|
ms_node_unref (list->nodes[i]);
|
|
g_free (list->nodes);
|
|
}
|
|
|
|
|
|
MSNodeList *
|
|
ms_node_list_new (void)
|
|
{
|
|
return NODE_NEW (MSNodeList,
|
|
MS_TYPE_NODE_LIST,
|
|
ms_node_list_eval,
|
|
ms_node_list_destroy);
|
|
}
|
|
|
|
|
|
void
|
|
ms_node_list_add (MSNodeList *list,
|
|
MSNode *node)
|
|
{
|
|
g_return_if_fail (list != NULL && node != NULL);
|
|
g_return_if_fail (MS_NODE_TYPE (list) == MS_TYPE_NODE_LIST);
|
|
|
|
if (list->n_nodes_allocd__ == list->n_nodes)
|
|
{
|
|
MSNode **tmp;
|
|
list->n_nodes_allocd__ = MAX (list->n_nodes_allocd__ + 2,
|
|
1.2 * list->n_nodes_allocd__);
|
|
tmp = g_new0 (MSNode*, list->n_nodes_allocd__);
|
|
if (list->n_nodes)
|
|
memcpy (tmp, list->nodes, list->n_nodes * sizeof(MSNode*));
|
|
g_free (list->nodes);
|
|
list->nodes = tmp;
|
|
}
|
|
|
|
list->nodes[list->n_nodes++] = ms_node_ref (node);
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeVar
|
|
*/
|
|
|
|
static void
|
|
ms_node_var_destroy (MSNode *node)
|
|
{
|
|
MSNodeVar *var = MS_NODE_VAR (node);
|
|
g_free (var->name);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_var_eval (MSNode *node,
|
|
MSContext *ctx)
|
|
{
|
|
MSNodeVar *var = MS_NODE_VAR (node);
|
|
return ms_context_eval_variable (ctx, var->name);
|
|
}
|
|
|
|
|
|
MSNodeVar *
|
|
ms_node_var_new (const char *name)
|
|
{
|
|
MSNodeVar *var;
|
|
|
|
g_return_val_if_fail (name && name[0], NULL);
|
|
|
|
var = NODE_NEW (MSNodeVar,
|
|
MS_TYPE_NODE_VAR,
|
|
ms_node_var_eval,
|
|
ms_node_var_destroy);
|
|
|
|
var->name = g_strdup (name);
|
|
|
|
return var;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeFunction
|
|
*/
|
|
|
|
static void
|
|
ms_node_function_destroy (MSNode *node)
|
|
{
|
|
ms_node_unref (MS_NODE_FUNCTION(node)->func);
|
|
ms_node_unref (MS_NODE_FUNCTION(node)->args);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_function_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
guint i, n_args;
|
|
MSValue **args;
|
|
MSValue *ret, *func;
|
|
MSNodeFunction *node = MS_NODE_FUNCTION (node_);
|
|
|
|
g_return_val_if_fail (node->func != NULL, NULL);
|
|
|
|
func = _ms_node_eval (node->func, ctx);
|
|
|
|
if (!func)
|
|
return NULL;
|
|
|
|
if (!ms_value_is_func (func))
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_TYPE,
|
|
"object <%r> is not a function",
|
|
func);
|
|
ms_value_unref (func);
|
|
return NULL;
|
|
}
|
|
|
|
n_args = node->args ? node->args->n_nodes : 0;
|
|
args = NULL;
|
|
ret = NULL;
|
|
|
|
if (n_args)
|
|
{
|
|
args = g_new0 (MSValue*, n_args);
|
|
|
|
for (i = 0; i < n_args; ++i)
|
|
{
|
|
args[i] = _ms_node_eval (node->args->nodes[i], ctx);
|
|
|
|
if (!args[i])
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ret = ms_value_call (func, args, n_args, ctx);
|
|
|
|
out:
|
|
for (i = 0; i < n_args; ++i)
|
|
ms_value_unref (args[i]);
|
|
g_free (args);
|
|
ms_value_unref (func);
|
|
return ret;
|
|
}
|
|
|
|
|
|
MSNodeFunction *
|
|
ms_node_function_new (MSNode *func,
|
|
MSNodeList *args)
|
|
{
|
|
MSNodeFunction *node;
|
|
|
|
g_return_val_if_fail (func != NULL, NULL);
|
|
g_return_val_if_fail (!args || MS_IS_NODE_LIST (args), NULL);
|
|
|
|
if (args && !args->n_nodes)
|
|
args = NULL;
|
|
|
|
node = NODE_NEW (MSNodeFunction,
|
|
MS_TYPE_NODE_FUNCTION,
|
|
ms_node_function_eval,
|
|
ms_node_function_destroy);
|
|
|
|
node->func = ms_node_ref (func);
|
|
node->args = ms_node_ref (args);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
MSNodeFunction *
|
|
ms_node_binary_op_new (MSBinaryOp op,
|
|
MSNode *a,
|
|
MSNode *b)
|
|
{
|
|
MSNodeFunction *node;
|
|
MSNodeList *args;
|
|
const char *name;
|
|
MSNodeVar *func;
|
|
|
|
g_return_val_if_fail (a && b, NULL);
|
|
|
|
name = ms_binary_op_name (op);
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
func = ms_node_var_new (name);
|
|
|
|
args = ms_node_list_new ();
|
|
ms_node_list_add (args, a);
|
|
ms_node_list_add (args, b);
|
|
|
|
node = ms_node_function_new (MS_NODE (func), args);
|
|
|
|
ms_node_unref (args);
|
|
ms_node_unref (func);
|
|
return node;
|
|
}
|
|
|
|
|
|
MSNodeFunction *
|
|
ms_node_unary_op_new (MSUnaryOp op,
|
|
MSNode *val)
|
|
{
|
|
MSNodeFunction *node;
|
|
MSNodeList *args;
|
|
const char *name;
|
|
MSNodeVar *func;
|
|
|
|
g_return_val_if_fail (val != NULL, NULL);
|
|
|
|
name = ms_unary_op_name (op);
|
|
g_return_val_if_fail (name != NULL, NULL);
|
|
func = ms_node_var_new (name);
|
|
|
|
args = ms_node_list_new ();
|
|
ms_node_list_add (args, val);
|
|
|
|
node = ms_node_function_new (MS_NODE (func), args);
|
|
|
|
ms_node_unref (args);
|
|
ms_node_unref (func);
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeIfElse
|
|
*/
|
|
|
|
static void
|
|
ms_node_if_else_destroy (MSNode *node_)
|
|
{
|
|
MSNodeIfElse *node = MS_NODE_IF_ELSE (node_);
|
|
ms_node_unref (node->condition);
|
|
ms_node_unref (node->then_);
|
|
ms_node_unref (node->else_);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_if_else_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSValue *ret = NULL, *cond;
|
|
MSNodeIfElse *node = MS_NODE_IF_ELSE (node_);
|
|
|
|
g_return_val_if_fail (node->condition != NULL, NULL);
|
|
g_return_val_if_fail (node->then_ != NULL, NULL);
|
|
|
|
cond = _ms_node_eval (node->condition, ctx);
|
|
|
|
if (!cond)
|
|
return NULL;
|
|
|
|
if (ms_value_get_bool (cond))
|
|
ret = _ms_node_eval (node->then_, ctx);
|
|
else if (node->else_)
|
|
ret = _ms_node_eval (node->else_, ctx);
|
|
else
|
|
ret = ms_value_none ();
|
|
|
|
if (ctx->return_set)
|
|
{
|
|
ms_value_unref (ret);
|
|
ret = ms_value_ref (ctx->return_val);
|
|
}
|
|
|
|
ms_value_unref (cond);
|
|
return ret;
|
|
}
|
|
|
|
|
|
MSNodeIfElse *
|
|
ms_node_if_else_new (MSNode *condition,
|
|
MSNode *then_,
|
|
MSNode *else_)
|
|
{
|
|
MSNodeIfElse *node;
|
|
|
|
g_return_val_if_fail (condition && then_, NULL);
|
|
|
|
node = NODE_NEW (MSNodeIfElse,
|
|
MS_TYPE_NODE_IF_ELSE,
|
|
ms_node_if_else_eval,
|
|
ms_node_if_else_destroy);
|
|
|
|
node->condition = ms_node_ref (condition);
|
|
node->then_ = ms_node_ref (then_);
|
|
node->else_ = else_ ? ms_node_ref (else_) : NULL;
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeWhile
|
|
*/
|
|
|
|
static void
|
|
ms_node_while_destroy (MSNode *node)
|
|
{
|
|
MSNodeWhile *wh = MS_NODE_WHILE (node);
|
|
ms_node_unref (wh->condition);
|
|
ms_node_unref (wh->what);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_loop_while (MSContext *ctx,
|
|
MSNode *condition,
|
|
MSNode *what)
|
|
{
|
|
MSValue *ret;
|
|
|
|
g_return_val_if_fail (condition != NULL, NULL);
|
|
|
|
ret = NULL;
|
|
|
|
while (TRUE)
|
|
{
|
|
MSValue *cond = _ms_node_eval (condition, ctx);
|
|
gboolean doit;
|
|
|
|
if (!cond)
|
|
return NULL;
|
|
|
|
doit = ms_value_get_bool (cond);
|
|
ms_value_unref (cond);
|
|
|
|
if (doit)
|
|
{
|
|
ms_value_unref (ret);
|
|
|
|
if (what)
|
|
ret = _ms_node_eval (what, ctx);
|
|
else
|
|
ret = ms_value_none ();
|
|
|
|
if (!ret)
|
|
return NULL;
|
|
|
|
if (ctx->return_set)
|
|
{
|
|
ms_value_unref (ret);
|
|
ret = ms_value_ref (ctx->return_val);
|
|
break;
|
|
}
|
|
|
|
if (ctx->break_set)
|
|
{
|
|
ms_context_unset_break (ctx);
|
|
break;
|
|
}
|
|
|
|
if (ctx->continue_set)
|
|
ms_context_unset_continue (ctx);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret ? ret : ms_value_none ();
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_loop_do_while (MSContext *ctx,
|
|
MSNode *condition,
|
|
MSNode *what)
|
|
{
|
|
MSValue *ret;
|
|
|
|
g_return_val_if_fail (condition != NULL, NULL);
|
|
|
|
ret = NULL;
|
|
|
|
while (TRUE)
|
|
{
|
|
MSValue *cond;
|
|
gboolean stop;
|
|
|
|
ms_value_unref (ret);
|
|
|
|
if (what)
|
|
ret = _ms_node_eval (what, ctx);
|
|
else
|
|
ret = ms_value_none ();
|
|
|
|
if (!ret)
|
|
return NULL;
|
|
|
|
if (ctx->return_set)
|
|
{
|
|
ms_value_unref (ret);
|
|
ret = ms_value_ref (ctx->return_val);
|
|
break;
|
|
}
|
|
|
|
if (ctx->break_set)
|
|
{
|
|
ms_context_unset_break (ctx);
|
|
break;
|
|
}
|
|
|
|
if (ctx->continue_set)
|
|
ms_context_unset_continue (ctx);
|
|
|
|
cond = _ms_node_eval (condition, ctx);
|
|
|
|
if (!cond)
|
|
return NULL;
|
|
|
|
stop = !ms_value_get_bool (cond);
|
|
ms_value_unref (cond);
|
|
|
|
if (stop)
|
|
break;
|
|
}
|
|
|
|
return ret ? ret : ms_value_none ();
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_while_eval (MSNode *node,
|
|
MSContext *ctx)
|
|
{
|
|
MSNodeWhile *wh = MS_NODE_WHILE (node);
|
|
|
|
g_return_val_if_fail (wh->condition != NULL, NULL);
|
|
|
|
switch (wh->type)
|
|
{
|
|
case MS_COND_BEFORE:
|
|
return ms_loop_while (ctx, wh->condition, wh->what);
|
|
case MS_COND_AFTER:
|
|
return ms_loop_do_while (ctx, wh->condition, wh->what);
|
|
}
|
|
|
|
g_return_val_if_reached (NULL);
|
|
}
|
|
|
|
|
|
MSNodeWhile*
|
|
ms_node_while_new (MSCondType type,
|
|
MSNode *cond,
|
|
MSNode *what)
|
|
{
|
|
MSNodeWhile *wh;
|
|
|
|
g_return_val_if_fail (cond != NULL, NULL);
|
|
|
|
wh = NODE_NEW (MSNodeWhile,
|
|
MS_TYPE_NODE_WHILE,
|
|
ms_node_while_eval,
|
|
ms_node_while_destroy);
|
|
|
|
wh->type = type;
|
|
wh->condition = ms_node_ref (cond);
|
|
wh->what = what ? ms_node_ref (what) : NULL;
|
|
|
|
return wh;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeFor
|
|
*/
|
|
|
|
static void
|
|
ms_node_for_destroy (MSNode *node)
|
|
{
|
|
MSNodeFor *loop = MS_NODE_FOR (node);
|
|
ms_node_unref (loop->variable);
|
|
ms_node_unref (loop->list);
|
|
ms_node_unref (loop->what);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_for_eval (MSNode *node,
|
|
MSContext *ctx)
|
|
{
|
|
MSNodeVar *var;
|
|
MSNodeFor *loop = MS_NODE_FOR (node);
|
|
MSValue *vallist = NULL;
|
|
MSValue *ret = NULL;
|
|
guint i;
|
|
|
|
g_return_val_if_fail (loop->variable != NULL, NULL);
|
|
g_return_val_if_fail (loop->list != NULL, NULL);
|
|
|
|
if (!MS_IS_NODE_VAR (loop->variable))
|
|
return ms_context_format_error (ctx, MS_ERROR_TYPE,
|
|
"illegal loop variable <%r>",
|
|
loop->variable);
|
|
|
|
vallist = _ms_node_eval (loop->list, ctx);
|
|
|
|
if (!vallist)
|
|
return NULL;
|
|
|
|
if (MS_VALUE_TYPE (vallist) != MS_VALUE_LIST)
|
|
return ms_context_format_error (ctx, MS_ERROR_TYPE,
|
|
"illegal loop list <%r>",
|
|
vallist);
|
|
|
|
var = MS_NODE_VAR (loop->variable);
|
|
|
|
for (i = 0; i < vallist->list.n_elms; ++i)
|
|
{
|
|
if (!ms_context_assign_variable (ctx, var->name, vallist->list.elms[i]))
|
|
goto error;
|
|
|
|
ms_value_unref (ret);
|
|
|
|
if (loop->what)
|
|
ret = _ms_node_eval (loop->what, ctx);
|
|
else
|
|
ret = ms_value_none ();
|
|
|
|
if (!ret)
|
|
goto error;
|
|
|
|
if (ctx->return_set)
|
|
{
|
|
ms_value_unref (ret);
|
|
ret = ms_value_ref (ctx->return_val);
|
|
break;
|
|
}
|
|
|
|
if (ctx->break_set)
|
|
{
|
|
ms_context_unset_break (ctx);
|
|
break;
|
|
}
|
|
|
|
if (ctx->continue_set)
|
|
ms_context_unset_continue (ctx);
|
|
}
|
|
|
|
if (!ret)
|
|
ret = ms_value_none ();
|
|
|
|
ms_value_unref (vallist);
|
|
return ret;
|
|
|
|
error:
|
|
ms_value_unref (ret);
|
|
ms_value_unref (vallist);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
MSNodeFor*
|
|
ms_node_for_new (MSNode *var,
|
|
MSNode *list,
|
|
MSNode *what)
|
|
{
|
|
MSNodeFor *loop;
|
|
|
|
g_return_val_if_fail (var && list, NULL);
|
|
|
|
loop = NODE_NEW (MSNodeFor,
|
|
MS_TYPE_NODE_FOR,
|
|
ms_node_for_eval,
|
|
ms_node_for_destroy);
|
|
|
|
loop->variable = ms_node_ref (var);
|
|
loop->list = ms_node_ref (list);
|
|
loop->what = what ? ms_node_ref (what) : NULL;
|
|
|
|
return loop;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeAssign
|
|
*/
|
|
|
|
static void
|
|
ms_node_assign_destroy (MSNode *node_)
|
|
{
|
|
MSNodeAssign *node = MS_NODE_ASSIGN (node_);
|
|
ms_node_unref (node->var);
|
|
ms_node_unref (node->val);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_assign_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSValue *value;
|
|
MSNodeAssign *node = MS_NODE_ASSIGN (node_);
|
|
|
|
g_return_val_if_fail (node->var != NULL, NULL);
|
|
g_return_val_if_fail (node->val != NULL, NULL);
|
|
|
|
value = _ms_node_eval (node->val, ctx);
|
|
|
|
if (!value)
|
|
return NULL;
|
|
|
|
if (!ms_context_assign_variable (ctx, node->var->name, value))
|
|
{
|
|
ms_value_unref (value);
|
|
return NULL;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
MSNodeAssign *
|
|
ms_node_assign_new (MSNodeVar *var,
|
|
MSNode *val)
|
|
{
|
|
MSNodeAssign *node;
|
|
|
|
g_return_val_if_fail (MS_IS_NODE_VAR (var), NULL);
|
|
g_return_val_if_fail (val != NULL, NULL);
|
|
|
|
node = NODE_NEW (MSNodeAssign,
|
|
MS_TYPE_NODE_ASSIGN,
|
|
ms_node_assign_eval,
|
|
ms_node_assign_destroy);
|
|
|
|
node->var = ms_node_ref (var);
|
|
node->val = ms_node_ref (val);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeValue
|
|
*/
|
|
|
|
static void
|
|
ms_node_value_destroy (MSNode *node)
|
|
{
|
|
MSNodeValue *val = MS_NODE_VALUE (node);
|
|
ms_value_unref (val->value);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_value_eval (MSNode *node,
|
|
G_GNUC_UNUSED MSContext *ctx)
|
|
{
|
|
return ms_value_ref (MS_NODE_VALUE(node)->value);
|
|
}
|
|
|
|
|
|
MSNodeValue *
|
|
ms_node_value_new (MSValue *value)
|
|
{
|
|
MSNodeValue *node;
|
|
|
|
g_return_val_if_fail (value != NULL, NULL);
|
|
|
|
node = NODE_NEW (MSNodeValue,
|
|
MS_TYPE_NODE_VALUE,
|
|
ms_node_value_eval,
|
|
ms_node_value_destroy);
|
|
|
|
node->value = ms_value_ref (value);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeValList
|
|
*/
|
|
|
|
static void
|
|
ms_node_val_list_destroy (MSNode *node_)
|
|
{
|
|
MSNodeValList *node = MS_NODE_VAL_LIST (node_);
|
|
ms_node_unref (node->elms);
|
|
ms_node_unref (node->first);
|
|
ms_node_unref (node->last);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_val_range_eval (MSNodeValList *node,
|
|
MSContext *ctx)
|
|
{
|
|
MSValue *ret;
|
|
guint n_elms, i;
|
|
MSValue *vfirst, *vlast;
|
|
int first, last;
|
|
|
|
g_assert (node->type == MS_VAL_RANGE);
|
|
|
|
vfirst = _ms_node_eval (node->first, ctx);
|
|
|
|
if (!vfirst)
|
|
return NULL;
|
|
|
|
vlast = _ms_node_eval (node->last, ctx);
|
|
|
|
if (!vlast)
|
|
{
|
|
ms_value_unref (vfirst);
|
|
return NULL;
|
|
}
|
|
|
|
if (!ms_value_get_int (vfirst, &first) || !ms_value_get_int (vlast, &last))
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_TYPE,
|
|
"illegal list bounds <%r> and <%r>",
|
|
vfirst, vlast);
|
|
ms_value_unref (vfirst);
|
|
ms_value_unref (vlast);
|
|
return NULL;
|
|
}
|
|
|
|
ms_value_unref (vfirst);
|
|
ms_value_unref (vlast);
|
|
|
|
if (first > last)
|
|
return ms_value_list (0);
|
|
|
|
n_elms = last - first + 1;
|
|
ret = ms_value_list (n_elms);
|
|
|
|
for (i = 0; i < n_elms; ++i)
|
|
{
|
|
MSValue *val = ms_value_int (first + i);
|
|
ms_value_list_set_elm (ret, i, val);
|
|
ms_value_unref (val);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_val_list_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSValue *ret;
|
|
guint n_elms, i;
|
|
MSNodeValList *node = MS_NODE_VAL_LIST (node_);
|
|
|
|
switch (node->type)
|
|
{
|
|
case MS_VAL_LIST:
|
|
n_elms = node->elms ? node->elms->n_nodes : 0;
|
|
ret = ms_value_list (n_elms);
|
|
|
|
for (i = 0; i < n_elms; ++i)
|
|
{
|
|
MSValue *elm = _ms_node_eval (node->elms->nodes[i], ctx);
|
|
|
|
if (!elm)
|
|
{
|
|
ms_value_unref (ret);
|
|
return NULL;
|
|
}
|
|
|
|
ms_value_list_set_elm (ret, i, elm);
|
|
ms_value_unref (elm);
|
|
}
|
|
|
|
return ret;
|
|
|
|
case MS_VAL_RANGE:
|
|
return ms_node_val_range_eval (node, ctx);
|
|
}
|
|
|
|
g_return_val_if_reached (NULL);
|
|
}
|
|
|
|
|
|
static MSNodeValList *
|
|
ms_node_val_list_new_ (void)
|
|
{
|
|
return NODE_NEW (MSNodeValList,
|
|
MS_TYPE_NODE_VAL_LIST,
|
|
ms_node_val_list_eval,
|
|
ms_node_val_list_destroy);
|
|
}
|
|
|
|
|
|
MSNodeValList *
|
|
ms_node_val_list_new (MSNodeList *list)
|
|
{
|
|
MSNodeValList *node;
|
|
|
|
g_return_val_if_fail (!list || MS_IS_NODE_LIST (list), NULL);
|
|
|
|
if (list && !list->n_nodes)
|
|
list = NULL;
|
|
|
|
node = ms_node_val_list_new_ ();
|
|
node->type = MS_VAL_LIST;
|
|
node->elms = list ? ms_node_ref (list) : NULL;
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
MSNodeValList *
|
|
ms_node_val_range_new (MSNode *first,
|
|
MSNode *last)
|
|
{
|
|
MSNodeValList *node;
|
|
|
|
g_return_val_if_fail (first && last, NULL);
|
|
|
|
node = ms_node_val_list_new_ ();
|
|
node->type = MS_VAL_RANGE;
|
|
node->first = ms_node_ref (first);
|
|
node->last = ms_node_ref (last);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodePython
|
|
*/
|
|
|
|
static void
|
|
ms_node_python_destroy (MSNode *node)
|
|
{
|
|
g_free (MS_NODE_PYTHON(node)->script);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_python_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
return ms_context_run_python (ctx, MS_NODE_PYTHON(node_)->script);
|
|
}
|
|
|
|
|
|
MSNodePython *
|
|
ms_node_python_new (const char *script)
|
|
{
|
|
MSNodePython *node;
|
|
|
|
g_return_val_if_fail (script != NULL, NULL);
|
|
|
|
node = NODE_NEW (MSNodePython,
|
|
MS_TYPE_NODE_PYTHON,
|
|
ms_node_python_eval,
|
|
ms_node_python_destroy);
|
|
|
|
node->script = g_strdup (script);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeGetItem
|
|
*/
|
|
|
|
static void
|
|
ms_node_get_item_destroy (MSNode *node)
|
|
{
|
|
ms_node_unref (MS_NODE_GET_ITEM(node)->obj);
|
|
ms_node_unref (MS_NODE_GET_ITEM(node)->key);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_get_item_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSNodeGetItem *node = MS_NODE_GET_ITEM (node_);
|
|
MSValue *obj = NULL, *key = NULL, *val = NULL;
|
|
guint len;
|
|
int index;
|
|
|
|
obj = _ms_node_eval (node->obj, ctx);
|
|
|
|
if (!obj)
|
|
goto error;
|
|
|
|
key = _ms_node_eval (node->key, ctx);
|
|
|
|
if (!key)
|
|
goto error;
|
|
|
|
if (MS_VALUE_TYPE (obj) == MS_VALUE_DICT)
|
|
{
|
|
if (MS_VALUE_TYPE (key) == MS_VALUE_STRING)
|
|
{
|
|
val = ms_value_dict_get_elm (obj, key->str);
|
|
|
|
if (!val)
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"no key '%s'", key->str);
|
|
goto error;
|
|
}
|
|
|
|
goto out;
|
|
}
|
|
else
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"invalid dict key <%r>",
|
|
key);
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
if (!ms_value_get_int (key, &index))
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"invalid list index <%r>",
|
|
key);
|
|
goto error;
|
|
}
|
|
|
|
if (index < 0)
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"index out of range");
|
|
goto error;
|
|
}
|
|
|
|
switch (MS_VALUE_TYPE (obj))
|
|
{
|
|
case MS_VALUE_STRING:
|
|
len = g_utf8_strlen (obj->str, -1);
|
|
break;
|
|
|
|
case MS_VALUE_LIST:
|
|
len = obj->list.n_elms;
|
|
break;
|
|
|
|
default:
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"<%r> is not subscriptable",
|
|
obj);
|
|
goto error;
|
|
}
|
|
|
|
if ((guint) index >= len)
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"index out of range");
|
|
goto error;
|
|
}
|
|
|
|
switch (MS_VALUE_TYPE (obj))
|
|
{
|
|
case MS_VALUE_STRING:
|
|
val = ms_value_string_len (g_utf8_offset_to_pointer (obj->str, index), 1);
|
|
break;
|
|
|
|
case MS_VALUE_LIST:
|
|
val = ms_value_ref (obj->list.elms[index]);
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
out:
|
|
ms_value_unref (obj);
|
|
ms_value_unref (key);
|
|
return val;
|
|
|
|
error:
|
|
ms_value_unref (obj);
|
|
ms_value_unref (key);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
MSNodeGetItem *
|
|
ms_node_get_item_new (MSNode *obj,
|
|
MSNode *key)
|
|
{
|
|
MSNodeGetItem *node;
|
|
|
|
g_return_val_if_fail (obj && key, NULL);
|
|
|
|
node = NODE_NEW (MSNodeGetItem,
|
|
MS_TYPE_NODE_GET_ITEM,
|
|
ms_node_get_item_eval,
|
|
ms_node_get_item_destroy);
|
|
|
|
node->obj = ms_node_ref (obj);
|
|
node->key = ms_node_ref (key);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeSetItem
|
|
*/
|
|
|
|
static void
|
|
ms_node_set_item_destroy (MSNode *node)
|
|
{
|
|
ms_node_unref (MS_NODE_SET_ITEM(node)->obj);
|
|
ms_node_unref (MS_NODE_SET_ITEM(node)->key);
|
|
ms_node_unref (MS_NODE_SET_ITEM(node)->val);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_set_item_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSNodeSetItem *node = MS_NODE_SET_ITEM (node_);
|
|
MSValue *obj = NULL, *key = NULL, *val = NULL;
|
|
guint len;
|
|
int index;
|
|
|
|
obj = _ms_node_eval (node->obj, ctx);
|
|
|
|
if (!obj)
|
|
goto error;
|
|
|
|
key = _ms_node_eval (node->key, ctx);
|
|
|
|
if (!key)
|
|
goto error;
|
|
|
|
val = _ms_node_eval (node->val, ctx);
|
|
|
|
if (!val)
|
|
goto error;
|
|
|
|
if (MS_VALUE_TYPE (obj) == MS_VALUE_DICT)
|
|
{
|
|
if (MS_VALUE_TYPE (key) == MS_VALUE_STRING)
|
|
{
|
|
ms_value_dict_set_elm (obj, key->str, val);
|
|
goto out;
|
|
}
|
|
else
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"invalid dict key <%r>",
|
|
key);
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
if (!ms_value_get_int (key, &index))
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"invalid list index <%r>", key);
|
|
goto error;
|
|
}
|
|
|
|
if (index < 0)
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"index out of range");
|
|
goto error;
|
|
}
|
|
|
|
switch (MS_VALUE_TYPE (obj))
|
|
{
|
|
case MS_VALUE_LIST:
|
|
len = obj->list.n_elms;
|
|
break;
|
|
|
|
default:
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"invalid list assignment for <%r>",
|
|
obj);
|
|
goto error;
|
|
}
|
|
|
|
if ((guint) index >= len)
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"index out of range");
|
|
goto error;
|
|
}
|
|
|
|
switch (MS_VALUE_TYPE (obj))
|
|
{
|
|
case MS_VALUE_LIST:
|
|
ms_value_list_set_elm (obj, index, val);
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
out:
|
|
ms_value_unref (obj);
|
|
ms_value_unref (key);
|
|
return val;
|
|
|
|
error:
|
|
ms_value_unref (obj);
|
|
ms_node_unref (key);
|
|
ms_value_unref (val);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
MSNodeSetItem *
|
|
ms_node_set_item_new (MSNode *obj,
|
|
MSNode *key,
|
|
MSNode *val)
|
|
{
|
|
MSNodeSetItem *node;
|
|
|
|
g_return_val_if_fail (obj && key && val, NULL);
|
|
|
|
node = NODE_NEW (MSNodeSetItem,
|
|
MS_TYPE_NODE_SET_ITEM,
|
|
ms_node_set_item_eval,
|
|
ms_node_set_item_destroy);
|
|
|
|
node->obj = ms_node_ref (obj);
|
|
node->key = ms_node_ref (key);
|
|
node->val = ms_node_ref (val);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeReturn
|
|
*/
|
|
|
|
static void
|
|
ms_node_return_destroy (MSNode *node)
|
|
{
|
|
ms_node_unref (MS_NODE_RETURN(node)->val);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_return_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSNodeReturn *node = MS_NODE_RETURN (node_);
|
|
MSValue *ret;
|
|
|
|
if (node->val)
|
|
{
|
|
ret = _ms_node_eval (node->val, ctx);
|
|
|
|
if (!ret)
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
ret = ms_value_none ();
|
|
}
|
|
|
|
ms_context_set_return (ctx, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
MSNodeReturn *
|
|
ms_node_return_new (MSNode *val)
|
|
{
|
|
MSNodeReturn *node;
|
|
|
|
node = NODE_NEW (MSNodeReturn,
|
|
MS_TYPE_NODE_RETURN,
|
|
ms_node_return_eval,
|
|
ms_node_return_destroy);
|
|
|
|
node->val = ms_node_ref (val);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeBreak
|
|
*/
|
|
|
|
static MSValue *
|
|
ms_node_break_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSNodeBreak *node = MS_NODE_BREAK (node_);
|
|
|
|
switch (node->type)
|
|
{
|
|
case MS_BREAK_BREAK:
|
|
ms_context_set_break (ctx);
|
|
break;
|
|
case MS_BREAK_CONTINUE:
|
|
ms_context_set_continue (ctx);
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
return ms_value_none ();
|
|
}
|
|
|
|
|
|
MSNodeBreak *
|
|
ms_node_break_new (MSBreakType type)
|
|
{
|
|
MSNodeBreak *node;
|
|
|
|
node = NODE_NEW (MSNodeBreak,
|
|
MS_TYPE_NODE_BREAK,
|
|
ms_node_break_eval,
|
|
NULL);
|
|
|
|
node->type = type;
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeDictElm
|
|
*/
|
|
|
|
static void
|
|
ms_node_dict_elm_destroy (MSNode *node_)
|
|
{
|
|
ms_node_unref (MS_NODE_DICT_ELM(node_)->dict);
|
|
g_free (MS_NODE_DICT_ELM(node_)->key);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_dict_elm_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSValue *obj, *val = NULL;
|
|
MSNodeDictElm *node = MS_NODE_DICT_ELM (node_);
|
|
|
|
obj = _ms_node_eval (node->dict, ctx);
|
|
|
|
if (!obj)
|
|
return NULL;
|
|
|
|
if (MS_VALUE_TYPE (obj) == MS_VALUE_DICT)
|
|
val = ms_value_dict_get_elm (obj, node->key);
|
|
|
|
if (!val)
|
|
val = ms_value_get_method (obj, node->key);
|
|
|
|
ms_value_unref (obj);
|
|
|
|
if (!val)
|
|
return ms_context_format_error (ctx, MS_ERROR_VALUE,
|
|
"no key '%s'", node->key);
|
|
else
|
|
return val;
|
|
}
|
|
|
|
|
|
MSNodeDictElm *
|
|
ms_node_dict_elm_new (MSNode *dict,
|
|
const char *key)
|
|
{
|
|
MSNodeDictElm *node;
|
|
|
|
g_return_val_if_fail (dict != NULL, NULL);
|
|
g_return_val_if_fail (key != NULL, NULL);
|
|
|
|
node = NODE_NEW (MSNodeDictElm,
|
|
MS_TYPE_NODE_DICT_ELM,
|
|
ms_node_dict_elm_eval,
|
|
ms_node_dict_elm_destroy);
|
|
|
|
node->dict = ms_node_ref (dict);
|
|
node->key = g_strdup (key);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeDictAssign
|
|
*/
|
|
|
|
static void
|
|
ms_node_dict_assign_destroy (MSNode *node_)
|
|
{
|
|
ms_node_unref (MS_NODE_DICT_ASSIGN(node_)->dict);
|
|
g_free (MS_NODE_DICT_ASSIGN(node_)->key);
|
|
ms_node_unref (MS_NODE_DICT_ASSIGN(node_)->val);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_dict_assign_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSValue *obj = NULL, *val = NULL;
|
|
MSNodeDictAssign *node = MS_NODE_DICT_ASSIGN (node_);
|
|
|
|
obj = _ms_node_eval (node->dict, ctx);
|
|
|
|
if (!obj)
|
|
goto error;
|
|
|
|
val = _ms_node_eval (node->val, ctx);
|
|
|
|
if (!val)
|
|
goto error;
|
|
|
|
if (MS_VALUE_TYPE (obj) != MS_VALUE_DICT)
|
|
{
|
|
ms_context_format_error (ctx, MS_ERROR_TYPE,
|
|
"<%r> is not a dict object",
|
|
obj);
|
|
goto error;
|
|
}
|
|
|
|
ms_value_dict_set_elm (obj, node->key, val);
|
|
|
|
ms_value_unref (obj);
|
|
return val;
|
|
|
|
error:
|
|
ms_value_unref (obj);
|
|
ms_value_unref (val);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
MSNodeDictAssign *
|
|
ms_node_dict_assign_new (MSNode *dict,
|
|
const char *key,
|
|
MSNode *val)
|
|
{
|
|
MSNodeDictAssign *node;
|
|
|
|
g_return_val_if_fail (dict != NULL, NULL);
|
|
g_return_val_if_fail (key != NULL, NULL);
|
|
g_return_val_if_fail (val != NULL, NULL);
|
|
|
|
node = NODE_NEW (MSNodeDictAssign,
|
|
MS_TYPE_NODE_DICT_ASSIGN,
|
|
ms_node_dict_assign_eval,
|
|
ms_node_dict_assign_destroy);
|
|
|
|
node->dict = ms_node_ref (dict);
|
|
node->key = g_strdup (key);
|
|
node->val = ms_node_ref (val);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeDictEntry
|
|
*/
|
|
|
|
static void
|
|
ms_node_dict_entry_destroy (MSNode *node_)
|
|
{
|
|
ms_node_unref (MS_NODE_DICT_ENTRY(node_)->val);
|
|
g_free (MS_NODE_DICT_ENTRY(node_)->key);
|
|
}
|
|
|
|
|
|
MSNodeDictEntry *
|
|
ms_node_dict_entry_new (const char *key,
|
|
MSNode *val)
|
|
{
|
|
MSNodeDictEntry *node;
|
|
|
|
g_return_val_if_fail (key != NULL, NULL);
|
|
g_return_val_if_fail (val != NULL, NULL);
|
|
|
|
node = NODE_NEW (MSNodeDictEntry,
|
|
MS_TYPE_NODE_DICT_ENTRY,
|
|
NULL,
|
|
ms_node_dict_entry_destroy);
|
|
|
|
node->key = g_strdup (key);
|
|
node->val = ms_node_ref (val);
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
/****************************************************************************/
|
|
/* MSNodeDict
|
|
*/
|
|
|
|
static void
|
|
ms_node_dict_destroy (MSNode *node_)
|
|
{
|
|
ms_node_unref (MS_NODE_DICT(node_)->entries);
|
|
}
|
|
|
|
|
|
static MSValue *
|
|
ms_node_dict_eval (MSNode *node_,
|
|
MSContext *ctx)
|
|
{
|
|
MSValue *ret;
|
|
MSNodeDict *node = MS_NODE_DICT (node_);
|
|
|
|
ret = ms_value_dict ();
|
|
|
|
if (node->entries)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < node->entries->n_nodes; ++i)
|
|
{
|
|
MSNodeDictEntry *entry = MS_NODE_DICT_ENTRY (node->entries->nodes[i]);
|
|
MSValue *val = _ms_node_eval (entry->val, ctx);
|
|
|
|
if (!val)
|
|
{
|
|
ms_value_unref (val);
|
|
return NULL;
|
|
}
|
|
|
|
ms_value_dict_set_elm (ret, entry->key, val);
|
|
ms_value_unref (val);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
MSNodeDict *
|
|
ms_node_dict_new (MSNodeList *entries)
|
|
{
|
|
MSNodeDict *node;
|
|
|
|
g_return_val_if_fail (!entries || MS_IS_NODE_LIST (entries), NULL);
|
|
|
|
node = NODE_NEW (MSNodeDict,
|
|
MS_TYPE_NODE_DICT,
|
|
ms_node_dict_eval,
|
|
ms_node_dict_destroy);
|
|
|
|
node->entries = ms_node_ref (entries);
|
|
|
|
return node;
|
|
}
|