nyje
/
medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

A bit better scripts

master
Yevgen Muntyan 2006-03-14 14:59:07 -06:00
parent 08b727aeb1
commit 9c6f71076e
15 changed files with 366 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
moo.kdevelop
View File

@ -268,16 +268,16 @@
</kdevdoctreeview>
<kdevfilecreate>
<filetypes>
<type icon="source" ext="g" create="template" name="GAP source" >
<type icon="source" ext="g" name="GAP source" create="template" >
<descr>A new empty GAP source file</descr>
</type>
<type icon="source_cpp" ext="cpp" create="template" name="C++ Source" >
<type icon="source_cpp" ext="cpp" name="C++ Source" create="template" >
<descr>A new empty C++ file.</descr>
</type>
<type icon="source_h" ext="h" create="template" name="C/C++ Header" >
<type icon="source_h" ext="h" name="C/C++ Header" create="template" >
<descr>A new empty header file for C/C++.</descr>
</type>
<type icon="source_c" ext="c" create="template" name="C Source" >
<type icon="source_c" ext="c" name="C Source" create="template" >
<descr>A new empty C file.</descr>
</type>
</filetypes>

43
moo/mooapp/mooapp.c
View File

@ -39,8 +39,12 @@
#define APP_VERSION "<uknown version>"
#endif
#define MOO_UI_XML_FILE "ui.xml"
#define MOO_UI_XML_FILE "ui.xml"
#ifdef __WIN32__
#define MOO_ACTIONS_FILE "actions.ini"
#else
#define MOO_ACTIONS_FILE "actions"
#endif
static MooApp *moo_app_instance = NULL;
static MooAppInput *moo_app_input = NULL;
@ -69,6 +73,8 @@ struct _MooAppPrivate {
gboolean use_editor;
gboolean use_terminal;
MooUserActionCtxFunc ctx_func;
char *tmpdir;
gboolean new_app;
@ -122,6 +128,8 @@ static void moo_app_set_description (MooApp *app,
static void start_io (MooApp *app);
static void execute_selection (MooEditWindow *window);
static MSContext *default_ctx_func (MooWindow *window);
static GObjectClass *moo_app_parent_class;
@ -391,6 +399,8 @@ moo_app_constructor (GType type,
object = moo_app_parent_class->constructor (type, n_params, params);
app = MOO_APP (object);
app->priv->ctx_func = default_ctx_func;
if (!app->priv->info->full_name)
app->priv->info->full_name = g_strdup (app->priv->info->short_name);
@ -573,6 +583,15 @@ moo_app_set_exit_code (MooApp *app,
}
void
moo_app_set_user_action_ctx_func (MooApp *app,
MooUserActionCtxFunc func)
{
g_return_if_fail (MOO_IS_APP (app));
app->priv->ctx_func = func ? func : default_ctx_func;
}
char *
moo_app_get_data_dir (MooApp *app,
MooAppDataType type)
@ -788,7 +807,7 @@ moo_app_python_run_string (MooApp *app,
g_return_val_if_fail (string != NULL, FALSE);
g_return_val_if_fail (moo_python_running (), FALSE);
res = moo_python_run_string (string);
res = moo_python_run_simple_string (string);
if (res)
{
@ -827,10 +846,10 @@ moo_app_load_user_actions (MooApp *app)
for (i = 0; i < n_dirs; i++)
{
char *file = g_build_filename (dirs[i], "actions", NULL);
char *file = g_build_filename (dirs[i], MOO_ACTIONS_FILE, NULL);
if (g_file_test (file, G_FILE_TEST_EXISTS))
moo_parse_user_actions (file);
moo_parse_user_actions (file, app->priv->ctx_func);
g_free (file);
}
@ -1657,3 +1676,17 @@ moo_app_data_type_get_type (void)
return type;
}
static MSContext *
default_ctx_func (MooWindow *window)
{
MSContext *ctx;
ctx = g_object_new (MS_TYPE_CONTEXT, "window", window, NULL);
if (MOO_IS_EDIT_WINDOW (window))
moo_edit_window_setup_context (MOO_EDIT_WINDOW (window), ctx);
return ctx;
}

4
moo/mooapp/mooapp.h
View File

@ -16,6 +16,7 @@
#include <mooterm/mootermwindow.h>
#include <mooedit/mooeditor.h>
#include <mooutils/moouseractions.h>
G_BEGIN_DECLS
@ -124,6 +125,9 @@ gboolean moo_app_send_msg (MooApp *app,
const char *data,
int len);
void moo_app_set_user_action_ctx_func (MooApp *app,
MooUserActionCtxFunc func);
void _moo_app_exec_cmd (MooApp *app,
char cmd,
const char *data,

49
moo/mooedit/mooeditwindow.c
View File

@ -2474,4 +2474,51 @@ out:
}
/* kate: space-indent: on; indent-width: 4; strip on; */
/*****************************************************************************/
/* MooScript
*/
#define VAR_DOC "doc"
#define DOC_ATTR_FILE "file"
static void
moo_edit_window_setup_python (MooEditWindow *window,
MSContext *ctx)
{
MooEdit *doc;
doc = ACTIVE_DOC (window);
ms_context_assign_py_object (ctx, VAR_DOC, doc);
}
void
moo_edit_window_setup_context (MooEditWindow *window,
MSContext *ctx)
{
MooEdit *doc;
MSValue *val;
g_return_if_fail (MOO_IS_EDIT_WINDOW (window));
g_return_if_fail (MS_IS_CONTEXT (ctx));
g_return_if_fail (ctx->window == MOO_WINDOW (window));
doc = ACTIVE_DOC (window);
if (doc)
{
val = ms_value_dict ();
ms_value_dict_set_string (val, DOC_ATTR_FILE,
moo_edit_get_filename (doc));
}
else
{
val = ms_value_none ();
}
ms_context_assign_variable (ctx, VAR_DOC, val);
ms_value_unref (val);
if (moo_python_running ())
moo_edit_window_setup_python (window, ctx);
}

5
moo/mooedit/mooeditwindow.h
View File

@ -18,6 +18,7 @@
#include <mooedit/mooedit.h>
#include <mooutils/moowindow.h>
#include <mooutils/moobigpaned.h>
#include <mooutils/mooscript/mooscript-context.h>
G_BEGIN_DECLS
@ -93,6 +94,10 @@ void moo_edit_window_job_finished (MooEditWindow *window,
gpointer job);
void moo_edit_window_setup_context (MooEditWindow *window,
MSContext *ctx);
G_END_DECLS
#endif /* __MOO_EDIT_WINDOW_H__ */

100
moo/moopython/mooplugin-python.c
View File

@ -42,7 +42,7 @@ static void moo_py_plugin_delete (MooPyPluginData *data);
static MooPyObject*
run_string (const char *str)
run_simple_string (const char *str)
{
PyObject *dict;
g_return_val_if_fail (str != NULL, NULL);
@ -51,6 +51,20 @@ run_string (const char *str)
}
static MooPyObject*
run_string (const char *str,
MooPyObject *locals,
MooPyObject *globals)
{
g_return_val_if_fail (str != NULL, NULL);
g_return_val_if_fail (locals != NULL, NULL);
g_return_val_if_fail (globals != NULL, NULL);
return (MooPyObject*) PyRun_String (str, Py_file_input,
(PyObject*) locals,
(PyObject*) globals);
}
static MooPyObject*
run_file (gpointer fp,
const char *filename)
@ -89,12 +103,94 @@ err_print (void)
}
static MooPyObject *
py_object_from_gobject (gpointer gobj)
{
g_return_val_if_fail (!gobj || G_IS_OBJECT (gobj), NULL);
if (gobj)
return (MooPyObject*) pygobject_new (gobj);
else
return (MooPyObject*) Py_INCREF (Py_None);
}
static MooPyObject *
dict_get_item (MooPyObject *dict,
const char *key)
{
g_return_val_if_fail (dict != NULL, NULL);
g_return_val_if_fail (key != NULL, NULL);
return (MooPyObject*) PyDict_GetItemString ((PyObject*) dict, (char*) key);
}
static gboolean
dict_set_item (MooPyObject *dict,
const char *key,
MooPyObject *val)
{
g_return_val_if_fail (dict != NULL, FALSE);
g_return_val_if_fail (key != NULL, FALSE);
g_return_val_if_fail (val != NULL, FALSE);
if (PyDict_SetItemString ((PyObject*) dict, (char*) key, (PyObject*) val))
{
PyErr_Print ();
return FALSE;
}
return TRUE;
}
static gboolean
dict_del_item (MooPyObject *dict,
const char *key)
{
g_return_val_if_fail (dict != NULL, FALSE);
g_return_val_if_fail (key != NULL, FALSE);
if (PyDict_DelItemString ((PyObject*) dict, (char*) key))
{
PyErr_Print ();
return FALSE;
}
return TRUE;
}
static MooPyObject *
get_script_dict (const char *name)
{
PyObject *dict, *builtins;
builtins = PyImport_ImportModule ((char*) "__builtin__");
g_return_val_if_fail (builtins != NULL, NULL);
dict = PyDict_New ();
PyDict_SetItemString (dict, (char*) "__builtins__", builtins);
if (name)
{
PyObject *py_name = PyString_FromString (name);
PyDict_SetItemString (dict, (char*) "__name__", py_name);
Py_XDECREF (py_name);
}
Py_XDECREF (builtins);
return (MooPyObject*) dict;
}
static gboolean
moo_python_api_init (void)
{
static MooPyAPI api = {
incref, decref, err_print,
run_string, run_file
run_simple_string, run_string, run_file,
py_object_from_gobject,
get_script_dict,
dict_get_item, dict_set_item, dict_del_item
};
g_return_val_if_fail (!moo_python_running(), FALSE);

48
moo/mooutils/moopython.h
View File

@ -18,20 +18,35 @@
G_BEGIN_DECLS
#define MOO_PY_API_VERSION 87
#define MOO_PY_API_VERSION 89
typedef struct _MooPyAPI MooPyAPI;
typedef struct _MooPyObject MooPyObject;
struct _MooPyAPI {
MooPyObject* (*incref) (MooPyObject *obj);
void (*decref) (MooPyObject *obj);
void (*err_print) (void);
MooPyObject* (*incref) (MooPyObject *obj);
void (*decref) (MooPyObject *obj);
void (*err_print) (void);
MooPyObject* (*run_string) (const char *str);
MooPyObject* (*run_file) (void *fp,
const char *filename);
MooPyObject* (*run_simple_string) (const char *str);
MooPyObject* (*run_string) (const char *str,
MooPyObject *locals,
MooPyObject *globals);
MooPyObject* (*run_file) (void *fp,
const char *filename);
MooPyObject* (*py_object_from_gobject) (gpointer gobj);
MooPyObject* (*get_script_dict) (const char *name);
MooPyObject* (*dict_get_item) (MooPyObject *dict,
const char *key);
gboolean (*dict_set_item) (MooPyObject *dict,
const char *key,
MooPyObject *val);
gboolean (*dict_del_item) (MooPyObject *dict,
const char *key);
};
@ -42,12 +57,21 @@ gboolean moo_python_init (guint version,
#define moo_python_running() (moo_py_api != NULL)
#define moo_Py_INCREF moo_py_api->incref
#define moo_Py_DECREF moo_py_api->decref
#define moo_PyErr_Print moo_py_api->err_print
#define moo_Py_INCREF moo_py_api->incref
#define moo_Py_DECREF moo_py_api->decref
#define moo_PyErr_Print moo_py_api->err_print
#define moo_python_run_string moo_py_api->run_string
#define moo_python_run_file moo_py_api->run_file
#define moo_python_run_simple_string moo_py_api->run_simple_string
#define moo_python_run_string moo_py_api->run_string
#define moo_python_run_file moo_py_api->run_file
#define moo_py_get_script_dict moo_py_api->get_script_dict
#define moo_py_dict_get_item moo_py_api->dict_get_item
#define moo_py_dict_set_item moo_py_api->dict_set_item
#define moo_py_dict_del_item moo_py_api->dict_del_item
#define moo_py_object_from_gobject moo_py_api->py_object_from_gobject
G_END_DECLS

22
moo/mooutils/mooscript/mooscript-builtin.c
View File

@ -101,27 +101,13 @@ python_func (MSValue *arg,
MSContext *ctx)
{
char *script;
MooPyObject *ret;
if (!moo_python_running())
return ms_context_format_error (ctx, MS_ERROR_RUNTIME,
"Python support not available");
MSValue *ret;
script = ms_value_print (arg);
ret = moo_python_run_string (script);
g_free (script);
ret = ms_context_run_python (ctx, script);
if (ret)
{
moo_Py_DECREF (ret);
return ms_value_none ();
}
else
{
moo_PyErr_Print ();
return ms_context_format_error (ctx, MS_ERROR_RUNTIME,
"python script raised exception");
}
g_free (script);
return ret;
}

72
moo/mooutils/mooscript/mooscript-context.c
View File

@ -135,6 +135,9 @@ 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);
@ -146,6 +149,7 @@ ms_context_finalize (GObject *object)
{
MSContext *ctx = MS_CONTEXT (object);
moo_Py_DECREF (ctx->py_dict);
g_hash_table_destroy (ctx->vars);
g_free (ctx->error_msg);
@ -377,7 +381,10 @@ ms_context_format_error (MSContext *ctx,
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);
ms_context_format_error_valist (ctx, error, format, args);
@ -532,3 +539,68 @@ ms_context_unset_continue (MSContext *ctx)
g_return_if_fail (ctx->continue_set);
ctx->continue_set = FALSE;
}
/************************************************************************/
/* 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 (ctx->py_dict != NULL);
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 (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");
}
}

12
moo/mooutils/mooscript/mooscript-context.h
View File

@ -16,6 +16,7 @@
#define __MOO_SCRIPT_CONTEXT_H__
#include "mooscript-func.h"
#include <mooutils/moopython.h>
G_BEGIN_DECLS
@ -51,6 +52,7 @@ typedef void (*MSPrintFunc) (const char *string,
struct _MSContext {
GObject object;
MooPyObject *py_dict;
GHashTable *vars;
MSError error;
char *error_msg;
@ -121,6 +123,16 @@ void ms_context_unset_break (MSContext *ctx);
void ms_context_unset_continue (MSContext *ctx);
MSValue *ms_context_run_python (MSContext *ctx,
const char *script);
void ms_context_assign_py_var (MSContext *ctx,
const char *var,
MooPyObject *obj);
void ms_context_assign_py_object (MSContext *ctx,
const char *var,
gpointer gobj);
G_END_DECLS
#endif /* __MOO_SCRIPT_CONTEXT_H__ */

21
moo/mooutils/mooscript/mooscript-node.c
View File

@ -978,26 +978,7 @@ static MSValue *
ms_node_python_eval (MSNode *node_,
MSContext *ctx)
{
MSNodePython *node = MS_NODE_PYTHON (node_);
MooPyObject *ret;
if (!moo_python_running())
return ms_context_format_error (ctx, MS_ERROR_RUNTIME,
"Python support not available");
ret = moo_python_run_string (node->script);
if (ret)
{
moo_Py_DECREF (ret);
return ms_value_none ();
}
else
{
moo_PyErr_Print ();
return ms_context_format_error (ctx, MS_ERROR_RUNTIME,
"python script raised exception");
}
return ms_context_run_python (ctx, MS_NODE_PYTHON(node_)->script);
}

15
moo/mooutils/mooscript/mooscript-value.c
View File

@ -218,6 +218,21 @@ ms_value_dict_set_elm (MSValue *dict,
ms_value_ref (val));
}
void
ms_value_dict_set_string (MSValue *dict,
const char *key,
const char *val)
{
MSValue *value;
g_return_if_fail (dict != NULL);
g_return_if_fail (key != NULL);
value = val ? ms_value_string (val) : ms_value_none ();
ms_value_dict_set_elm (dict, key, value);
ms_value_unref (value);
}
MSValue *
ms_value_ref (MSValue *val)

5
moo/mooutils/mooscript/mooscript-value.h
View File

@ -135,6 +135,11 @@ void ms_value_dict_set_elm (MSValue *dict,
MSValue *ms_value_dict_get_elm (MSValue *dict,
const char *key);
void ms_value_dict_set_string (MSValue *dict,
const char *key,
const char *val);
MSValue *ms_value_ref (MSValue *val);
void ms_value_unref (MSValue *val);

24
moo/mooutils/moouseractions.c
View File

@ -16,6 +16,7 @@
#include "mooutils/moocompat.h"
#include <string.h>
typedef MooUserActionCtxFunc CtxFunc;
typedef struct {
const char *filename;
@ -32,12 +33,14 @@ typedef struct {
char *label;
char *accel;
MSNode *script;
CtxFunc ctx_func;
} Action;
typedef struct {
MooAction base;
MooWindow *window;
MSNode *script;
CtxFunc ctx_func;
} MooUserAction;
typedef struct {
@ -86,7 +89,8 @@ static Action *
action_new (const char *name,
const char *label,
const char *accel,
const char *code)
const char *code,
CtxFunc ctx_func)
{
Action *action;
MSNode *script;
@ -107,6 +111,7 @@ action_new (const char *name,
action->label = label ? g_strdup (label) : g_strdup (name);
action->accel = parse_accel (accel);
action->script = script;
action->ctx_func = ctx_func;
return action;
}
@ -259,7 +264,8 @@ parser_add_code (Parser *parser,
static void
parser_end_code (Parser *parser)
parser_end_code (Parser *parser,
CtxFunc func)
{
Action *action;
@ -274,7 +280,8 @@ parser_end_code (Parser *parser)
// parser->action, parser->code->str);
action = action_new (parser->action, parser->label,
parser->accel, parser->code->str);
parser->accel, parser->code->str,
func);
if (!action)
goto out;
@ -367,7 +374,8 @@ splitlines (const char *string,
void
moo_parse_user_actions (const char *filename)
moo_parse_user_actions (const char *filename,
MooUserActionCtxFunc ctx_func)
{
GMappedFile *file;
GError *error = NULL;
@ -376,6 +384,7 @@ moo_parse_user_actions (const char *filename)
guint n_lines, i;
g_return_if_fail (filename != NULL);
g_return_if_fail (ctx_func != NULL);
file = g_mapped_file_new (filename, FALSE, &error);
@ -442,7 +451,7 @@ moo_parse_user_actions (const char *filename)
if ((!lines[i][0] || lines[i][0] == '\r') &&
(i == n_lines - 1 || starts_action (lines[i+1])))
{
parser_end_code (&parser);
parser_end_code (&parser, ctx_func);
break;
}
@ -450,7 +459,7 @@ moo_parse_user_actions (const char *filename)
}
if (i == n_lines)
parser_end_code (&parser);
parser_end_code (&parser, ctx_func);
}
parser.actions = g_slist_reverse (parser.actions);
@ -484,7 +493,7 @@ moo_user_action_activate (MooAction *_action)
MSValue *value;
MooUserAction *action = (MooUserAction*) _action;
ctx = g_object_new (MS_TYPE_CONTEXT, "window", action->window, NULL);
ctx = action->ctx_func (action->window);
value = ms_top_node_eval (action->script, ctx);
if (!value)
@ -520,6 +529,7 @@ create_action (MooWindow *window,
action->window = window;
action->script = ms_node_ref (data->script);
action->ctx_func = data->ctx_func;
return MOO_ACTION (action);
}

9
moo/mooutils/moouseractions.h
View File

@ -14,12 +14,17 @@
#ifndef __MOO_USER_ACTIONS_H__
#define __MOO_USER_ACTIONS_H__
#include "mooutils/moowindow.h"
#include <mooutils/mooscript/mooscript-context.h>
#include <mooutils/moowindow.h>
G_BEGIN_DECLS
void moo_parse_user_actions (const char *file);
typedef MSContext* (*MooUserActionCtxFunc) (MooWindow *window);
void moo_parse_user_actions (const char *file,
MooUserActionCtxFunc ctx_func);
G_END_DECLS