int
libgncmod_report_system_gnc_module_init(int refcount)
{
/* load the engine (we depend on it) */
if (!gnc_module_load("gnucash/engine", 0))
{
return FALSE;
}
if (!gnc_module_load("gnucash/app-utils", 0))
{
return FALSE;
}
scm_init_sw_report_system_module();
scm_c_eval_string("(use-modules (gnucash report report-system))");
/* if this is the first time the module's being loaded, initialize
* the relative date system */
if (refcount == 0)
{
scm_c_eval_string("(gnc:reldate-initialize)");
}
return TRUE;
}
/********************************************************************
* update_report_list
*
* this procedure does the real work of displaying a sorted list of
* available custom reports
********************************************************************/
static void
update_report_list(GtkListStore *store, CustomReportDialog *crd)
{
SCM get_rpt_guids = scm_c_eval_string("gnc:custom-report-template-guids");
SCM template_menu_name = scm_c_eval_string("gnc:report-template-menu-name/report-guid");
SCM rpt_guids;
int i;
GtkTreeIter iter;
GtkTreeModel *model = GTK_TREE_MODEL (store);
gboolean valid_iter;
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), COL_NAME, GTK_SORT_ASCENDING);
crd->reportlist = scm_call_0(get_rpt_guids);
rpt_guids = crd->reportlist;
/* Empty current liststore */
valid_iter = gtk_tree_model_get_iter_first (model, &iter);
while (valid_iter)
{
GValue value = { 0, };
GncGUID *row_guid;
g_value_init ( &value, G_TYPE_POINTER);
gtk_tree_model_get_value (model, &iter, COL_NUM, &value);
row_guid = (GncGUID *) g_value_get_pointer (&value);
guid_free (row_guid);
g_value_unset (&value);
valid_iter = gtk_tree_model_iter_next (model, &iter);
}
gtk_list_store_clear(store);
if (scm_is_list(rpt_guids))
{
/* for all the report guids in the list, store them, with a reference,
in the gtkliststore */
for (i = 0; !scm_is_null(rpt_guids); i++)
{
GncGUID *guid = guid_malloc ();
gchar *guid_str = scm_to_utf8_string (SCM_CAR(rpt_guids));
gchar *name = gnc_scm_to_utf8_string (scm_call_2(template_menu_name, SCM_CAR(rpt_guids), SCM_BOOL_F));
if (string_to_guid (guid_str, guid))
{
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
COL_NAME, name,
COL_NUM, guid,
-1);
}
g_free (name);
g_free (guid_str);
rpt_guids = SCM_CDR(rpt_guids);
}
}
}
static void
inner_main_add_price_quotes(void *closure, int argc, char **argv)
{
SCM mod, add_quotes, scm_book, scm_result = SCM_BOOL_F;
QofSession *session = NULL;
scm_c_eval_string("(debug-set! stack 200000)");
mod = scm_c_resolve_module("gnucash price-quotes");
scm_set_current_module(mod);
load_gnucash_modules();
qof_event_suspend();
scm_c_eval_string("(gnc:price-quotes-install-sources)");
if (!gnc_quote_source_fq_installed())
{
g_print("%s", _("No quotes retrieved. Finance::Quote isn't "
"installed properly.\n"));
goto fail;
}
add_quotes = scm_c_eval_string("gnc:book-add-quotes");
session = gnc_get_current_session();
if (!session) goto fail;
qof_session_begin(session, add_quotes_file, FALSE, FALSE);
if (qof_session_get_error(session) != ERR_BACKEND_NO_ERR) goto fail;
qof_session_load(session, NULL);
if (qof_session_get_error(session) != ERR_BACKEND_NO_ERR) goto fail;
scm_book = gnc_book_to_scm(qof_session_get_book(session));
scm_result = scm_call_2(add_quotes, SCM_BOOL_F, scm_book);
qof_session_save(session, NULL);
if (qof_session_get_error(session) != ERR_BACKEND_NO_ERR) goto fail;
qof_session_destroy(session);
if (!scm_is_true(scm_result))
{
g_warning("Failed to add quotes to %s.", add_quotes_file);
goto fail;
}
qof_event_resume();
gnc_shutdown(0);
return;
fail:
if (session && qof_session_get_error(session) != ERR_BACKEND_NO_ERR)
g_warning("Session Error: %s", qof_session_get_error_message(session));
qof_event_resume();
gnc_shutdown(1);
}
int
libgncmodfoo_gnc_module_init(int refcount)
{
/* publish the wrapped Scheme bindings for libfoo */
scm_init_sw_foo_module();
scm_c_eval_string("(use-modules (sw_foo))");
/* use the Scheme "foo" module */
scm_c_eval_string("(use-modules (gnucash foo))");
return TRUE;
}
int
libgncmod_bar_gnc_module_init(int refcount)
{
/* publish the wrapped Scheme bindings for libbar */
scm_init_sw_bar_module();
scm_c_eval_string("(use-modules (sw_bar))");
/* use the Scheme "bar" module */
scm_c_eval_string("(use-modules (gnucash bar))");
return TRUE;
}
int
libgncmod_business_gnome_gnc_module_init(int refcount)
{
/* load app-utils: we depend on it -- and it depends on the engine */
if (!gnc_module_load ("gnucash/app-utils", 0))
{
return FALSE;
}
/* We also depend on gnome-utils and gnome-search modules */
if (!gnc_module_load ("gnucash/gnome-utils", 0))
{
return FALSE;
}
if (!gnc_module_load ("gnucash/gnome-search", 0))
{
return FALSE;
}
if (!gnc_module_load ("gnucash/report/report-gnome", 0))
{
return FALSE;
}
scm_c_eval_string("(use-modules (gnucash business-gnome))");
scm_c_eval_string("(use-modules (gnucash report business-reports))");
if (refcount == 0)
{
/* Register the Owner search type */
gnc_search_core_register_type (GNC_OWNER_MODULE_NAME,
(GNCSearchCoreNew) gnc_search_owner_new);
gnc_business_urls_initialize ();
gnc_business_options_gnome_initialize ();
gnc_plugin_manager_add_plugin (gnc_plugin_manager_get (),
gnc_plugin_business_new ());
gnc_hook_add_dangler(HOOK_BOOK_OPENED,
(GFunc)gnc_invoice_remind_bills_due_cb, NULL);
gnc_hook_add_dangler(HOOK_BOOK_OPENED,
(GFunc)gnc_invoice_remind_invoices_due_cb, NULL);
/* Add to preferences under Business */
/* The parameters are; glade file, items to add from glade file - last being the dialog, preference tab name */
gnc_preferences_add_page("business-prefs.glade", "liststore_printinvoice,days_in_adj,cust_days_in_adj,business_prefs",
_("Business"));
}
return TRUE;
}
/*
* This gets called if scm_apply throws an error.
*
* We use gh_scm2newstr to convert from Guile string to Scheme string. The
* GH interface is deprecated, but doing it in scm takes more code. We'll
* convert later if we have to.
*/
static SCM
gnm_guile_catcher (void *data, SCM tag, SCM throw_args)
{
char const *header = _("Guile error");
SCM smob;
SCM func;
SCM res;
char *guilestr = NULL;
char *msg;
GnmValue *v;
func = scm_c_eval_string ("gnm:error->string");
if (scm_procedure_p (func)) {
res = scm_apply (func, tag,
scm_cons (throw_args, scm_listofnull));
if (scm_string_p (res))
guilestr = gh_scm2newstr (res, NULL);
}
if (guilestr != NULL) {
char *buf = g_strdup_printf ("%s: %s", header, guilestr);
free (guilestr);
v = value_new_error (NULL, buf);
g_free (buf);
} else {
v = value_new_error (NULL, header);
}
smob = make_new_smob (v);
value_release (v);
return smob;
}
static void
lmod(char * mn)
{
char * form = g_strdup_printf("(use-modules %s)\n", mn);
scm_c_eval_string(form);
g_free(form);
}
static void
run_tests (void)
{
Query *q;
SCM val2str;
int i;
val2str = scm_c_eval_string ("gnc:value->string");
g_return_if_fail (scm_is_procedure (val2str));
for (i = 0; i < 1000; i++)
{
q = get_random_query ();
test_query (q, val2str);
qof_query_destroy (q);
fflush(stdout);
}
{
q = get_random_query ();
test_query (q, val2str);
qof_query_destroy (q);
fflush(stdout);
}
}
G_MODULE_EXPORT void
go_plugin_init (GOPlugin *p, GOCmdContext *cc)
{
char *name, *dir;
*ret_error = NULL;
scm_init_guile ();
/* Initialize just in case. */
eval_pos = NULL;
init_value_type ();
scm_c_define_gsubr ("gnumeric-funcall", 2, 0, 0, scm_gnumeric_funcall);
scm_c_define_gsubr ("register-function", 5, 0, 0, scm_register_function);
dir = gnm_sys_data_dir ("guile");
name = g_strconcat (dir, "gnumeric_startup.scm", NULL);
scm_apply (scm_c_eval_string ("(lambda (filename)"
" (if (access? filename R_OK)"
" (load filename)"
" (display (string-append \"could not read Guile plug-in init file\" filename \"\n\"))))"),
scm_cons (scm_makfrom0str (name), SCM_EOL),
SCM_EOL);
g_free (name);
g_free (dir);
/* Don't try to deactivate the plugin */
gnm_plugin_use_ref (PLUGIN);
}
int
libgncmod_qif_import_gnc_module_init(int refcount)
{
if (!gnc_module_load("gnucash/engine", 0))
{
return FALSE;
}
if (!gnc_module_load("gnucash/app-utils", 0))
{
return FALSE;
}
if (!gnc_module_load("gnucash/gnome-utils", 0))
{
return FALSE;
}
/* If the recount == 0 then register the qif-import-druid for the new-user
* dialog.
*/
if (refcount == 0)
{
gnc_new_user_dialog_register_qif_druid
((void (*)())gnc_ui_qif_import_druid_make);
}
scm_c_eval_string("(use-modules (gnucash import-export qif-import))");
gnc_plugin_qif_import_create_plugin();
return TRUE;
}
SCM
gfec_eval_string(const char *str, gfec_error_handler error_handler)
{
SCM result = SCM_UNDEFINED;
SCM func = scm_c_eval_string("gnc:eval-string-with-error-handling");
if (scm_is_procedure(func))
{
char *err_msg = NULL;
SCM call_result, error = SCM_UNDEFINED;
call_result = scm_call_1 (func, scm_from_utf8_string (str));
error = scm_list_ref (call_result, scm_from_uint (1));
if (scm_is_true (error))
err_msg = gnc_scm_to_utf8_string (error);
else
result = scm_list_ref (call_result, scm_from_uint (0));
if (err_msg != NULL)
{
if (error_handler)
error_handler (err_msg);
free(err_msg);
}
}
return result;
}
SCM
gfec_apply(SCM proc, SCM arglist, gfec_error_handler error_handler)
{
SCM result = SCM_UNDEFINED;
SCM func = scm_c_eval_string("gnc:apply-with-error-handling");
if (scm_is_procedure(func))
{
char *err_msg = NULL;
SCM call_result, error;
call_result = scm_call_2 (func, proc, arglist);
error = scm_list_ref (call_result, scm_from_uint (1));
if (scm_is_true (error))
err_msg = gnc_scm_to_utf8_string (error);
else
result = scm_list_ref (call_result, scm_from_uint (0));
if (err_msg != NULL)
{
if (error_handler)
error_handler (err_msg);
free(err_msg);
}
}
return result;
}
/* We assume that data is actually a char**. The way we return results
* from this function is to malloc a fresh string, and store it in
* this pointer. It is the caller's responsibility to do something
* smart with this freshly allocated storage. the caller can determine
* whether there was an error by initializing the char* passed in to
* NULL. If there is an error, the char string will not be NULL on
* return. */
static SCM
gfec_catcher(void *data, SCM tag, SCM throw_args)
{
SCM func;
SCM result;
const char *msg = NULL;
func = scm_c_eval_string("gnc:error->string");
if (scm_is_procedure(func))
{
result = scm_call_2(func, tag, throw_args);
if (scm_is_string(result))
{
char * str;
scm_dynwind_begin (0);
str = scm_to_locale_string (result);
msg = g_strdup (str);
scm_dynwind_free (str);
scm_dynwind_end ();
}
}
if (msg == NULL)
{
msg = "Error running guile function.";
}
*(char**)data = strdup(msg);
return SCM_UNDEFINED;
}
static SCM
gfec_string_helper(void *data)
{
char *string = data;
return scm_c_eval_string(string);
}
static void
gnc_plugin_business_reload_module (const gchar *name)
{
SCM file_scm;
file_scm = scm_makfrom0str (name);
scm_call_1(scm_c_eval_string("gnc:reload-module"), file_scm);
}
static void init_env(void) {
SCM smob;
char *ver;
SOURCE_HANDLE *handle;
init_log();
init_alsa_module();
ver = scm_to_locale_string(scm_version());
log_msg("Guile version %s\n", ver);
free(ver);
init_messaging(msg_port);
init_time();
init_json();
init_scheduler();
init_audiofile();
if (use_jack) init_jackport();
init_feeds();
init_recorder();
init_stream();
init_source_mod();
init_ladspa();
init_unitgen();
fader = (SOURCE_OBJ *)my_malloc(sizeof(SOURCE_OBJ), "main fader");
handle = (SOURCE_HANDLE *)my_gc_malloc(sizeof(SOURCE_HANDLE), "mains",
"mains");
handle->body = (void *)fader;
handle->src = fader;
init_source(fader);
mains_tag = scm_make_smob_type("mains", sizeof(SOURCE_OBJ));
SCM_NEWSMOB(smob, mains_tag, handle);
scm_c_define("mains", smob);
if (use_jack) {
scm_c_define("jack-client-name",
scm_from_locale_string(client_name));
scm_c_define_gsubr("patch-out", 2, 0, 0, patch_out);
scm_c_define_gsubr("unpatch-out", 2, 0, 0, unpatch_out);
}
scm_c_define_gsubr("quit", 0, 0, 0, qmx_quit);
scm_c_define_gsubr("db", 1, 0, 0, db20);
scm_c_define_gsubr("period-duty-cycle", 0, 0, 0, get_duty_cycle);
scm_permanent_object(console_display =
scm_c_eval_string(console_display_src));
scm_permanent_object(catch_display =
scm_c_eval_string(catch_display_src));
return;
}
static SCM body_proc(void *data) {
SCM obj;
char *linebuf = (char *)data;
obj = scm_c_eval_string(linebuf);
if (obj == SCM_UNSPECIFIED) return SCM_BOOL_T;
scm_call_1(console_display, obj);
scm_remember_upto_here_1(obj);
return SCM_BOOL_T;
}
static void
gnc_column_view_edit_close_cb(GNCOptionWin * win, gpointer user_data)
{
gnc_column_view_edit * r = user_data;
SCM set_editor = scm_c_eval_string("gnc:report-set-editor-widget!");
scm_call_2(set_editor, r->view, SCM_BOOL_F);
gnc_column_view_edit_destroy(r);
}
static void
gnc_column_view_edit_apply_cb(GNCOptionWin * w, gpointer user_data)
{
SCM dirty_report = scm_c_eval_string("gnc:report-set-dirty?!");
gnc_column_view_edit * win = user_data;
if (!win) return;
gnc_option_db_commit(win->odb);
scm_call_2(dirty_report, win->view, SCM_BOOL_T);
}
/***********************************************************
* gnc_ui_custom_report_edit_name
*
* open the custom report dialog and highlight the given
* report's name for editing.
***********************************************************/
void
gnc_ui_custom_report_edit_name (GncMainWindow * window, SCM scm_guid)
{
SCM is_custom_report;
CustomReportDialog *crd = gnc_ui_custom_report_internal (window);
GtkTreeModel *model;
GtkTreeIter iter;
GncGUID *guid;
gchar *guid_str;
gboolean valid_iter;
is_custom_report = scm_c_eval_string ("gnc:report-template-is-custom/template-guid?");
if (scm_is_false (scm_call_1 (is_custom_report, scm_guid)))
return;
guid = guid_malloc ();
guid_str = scm_to_utf8_string (scm_guid);
if (!string_to_guid (guid_str, guid))
goto cleanup;
/* Look up the row for the requested guid */
model = gtk_tree_view_get_model (GTK_TREE_VIEW (crd->reportview));
valid_iter = gtk_tree_model_get_iter_first (model, &iter);
while (valid_iter)
{
GValue value = { 0, };
GncGUID *row_guid;
gtk_tree_model_get_value (model, &iter, COL_NUM, &value);
row_guid = (GncGUID *) g_value_get_pointer (&value);
if (guid_equal (guid, row_guid))
{
/* We found the row for the requested guid
* Now let's set the report's name cell in edit mode
* so the user can edit the name.
*/
GtkTreePath *path;
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (crd->reportview));
gtk_tree_selection_select_iter (selection, &iter);
path = gtk_tree_model_get_path (model, &iter);
g_object_set(G_OBJECT(crd->namerenderer), "editable", TRUE, NULL);
gtk_tree_view_set_cursor_on_cell (GTK_TREE_VIEW (crd->reportview),
path, crd->namecol,
crd->namerenderer, TRUE);
break;
}
g_value_unset (&value);
valid_iter = gtk_tree_model_iter_next (model, &iter);
}
cleanup:
guid_free (guid);
}
/*********************************************************************
* custom_report_delete
*
* this will delete the report, update the reports list and leave the
* dialog active for additional usage.
*********************************************************************/
static void
custom_report_delete (SCM guid, CustomReportDialog *crd)
{
SCM template_menu_name = scm_c_eval_string("gnc:report-template-menu-name/report-guid");
gchar *report_name;
if (scm_is_null (guid))
return;
report_name = gnc_scm_to_utf8_string(scm_call_2(template_menu_name, guid, SCM_BOOL_F));
/* we must confirm the user wants to delete their precious custom report! */
if (gnc_verify_dialog( GTK_WINDOW (crd->dialog), FALSE, _("Are you sure you want to delete %s?"), report_name))
{
SCM del_report = scm_c_eval_string("gnc:delete-report");
scm_call_1(del_report, guid);
update_report_list(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(crd->reportview))),
crd);
}
g_free (report_name);
}
static void
start_guile(void* closure, int argc, char **argv)
{
scm_c_define_gsubr("get-scene-mgr", 0, 0, 0, script_ogre_get_scene_mgr);
scm_c_define_gsubr("get-root-scene-node", 0, 0, 0, script_ogre_get_root_scene_node);
scm_c_define_gsubr("create-light", 1, 0, 0, script_ogre_create_light);
scm_c_define_gsubr("create-entity", 2, 0, 0, script_ogre_create_entity);
scm_c_define_gsubr("create-child-scene-node", 2, 0, 0, script_ogre_create_child_scene_node);
scm_c_define_gsubr("attach-object", 2, 0, 0, script_ogre_attach_object);
scm_c_define_gsubr("set-position", 4, 0, 0, script_ogre_set_position);
//scm_c_eval_string("(debug-set! stack 0)");
//scm_c_eval_string("(use-modules (srfi srfi-1))");
scm_c_define_gsubr("move", 4, 0, 0, script_move);
init_gio();
scm_c_eval_string("(load \"src_scm/db.scm\")");
scm_c_eval_string("(load \"src_scm/graphics.scm\")");
//scm_c_eval_string("(load \"src_scm/blend_format.scm\")");
scm_c_eval_string("(load \"src_scm/ogre.scm\")");
printf("\nSkomakare game engine...");
/* TODO: replace this using scm_c_eval_string(). */
/*while (1) {
char* input = readline("\n$ ");
//uint len = mylen(input);
//printf("%i\n", len);
//input[len-1] = '\0';
//input = realloc(input, mylen(input) + 1);
if (0 == strcmp(input, "q"))
break;
printf("%s", input);
scm_c_eval_string(input));
//printf("%s", scm_to_locale_string(scm_c_eval_string(input)));
}*/
scm_shell(argc, argv);
}
static void
gnc_style_sheet_select_dialog_fill(StyleSheetDialog * ss)
{
SCM stylesheets = scm_c_eval_string("(gnc:get-html-style-sheets)");
SCM sheet_info;
/* pack it full of content */
for (; !scm_is_null(stylesheets); stylesheets = SCM_CDR(stylesheets))
{
sheet_info = SCM_CAR(stylesheets);
gnc_style_sheet_select_dialog_add_one(ss, sheet_info, FALSE);
}
}
static void
dirty_same_stylesheet(gpointer key, gpointer val, gpointer data)
{
SCM dirty_ss = data;
SCM rep_ss = NULL;
SCM report = val;
SCM func = NULL;
func = scm_c_eval_string("gnc:report-stylesheet");
if (scm_is_procedure(func))
rep_ss = scm_call_1(func, report);
else
return;
if (scm_is_true(scm_eq_p(rep_ss, dirty_ss)))
{
func = scm_c_eval_string("gnc:report-set-dirty?!");
/* This makes _me_ feel dirty! */
if (scm_is_procedure(func))
scm_call_2(func, report, SCM_BOOL_T);
}
}
void
init ()
{
g_type_init ();
scm_c_eval_string ("(use-modules (gnome-2) (gnome gobject))");
repository_init ();
types_init ();
registered_type_init ();
object_init ();
function_init ();
callable_init ();
argument_init ();
}
SCM
gnc_scm_lookup(const char *module, const char *symbol)
{
#if defined(SCM_GUILE_MAJOR_VERSION) && \
(SCM_GUILE_MAJOR_VERSION > 0) && (SCM_GUILE_MINOR_VERSION > 4)
SCM scm_module = scm_c_resolve_module(module);
SCM value = scm_c_module_lookup(scm_module, symbol);
return value;
#else
gchar *in_guard_str;
gchar *thunk_str;
SCM in_guard;
SCM thunk;
SCM out_guard;
SCM result;
in_guard_str =
g_strdup_printf("(lambda () (set-current-module (resolve-module (%s))))",
module);
thunk_str = g_strdup_printf("(lambda () (eval '%s))", symbol);
in_guard = scm_c_eval_string(in_guard_str);
thunk = scm_c_eval_string(thunk_str);
out_guard = scm_c_eval_string("(let ((cm (current-module)))"
" (lambda () (set-current-module cm)))");
result = scm_dynamic_wind(in_guard, thunk, out_guard);
g_free(in_guard_str);
g_free(thunk_str);
return result;
#endif
}
/****************************************************************
* gnc_ui_qif_account_picker_new_cb
*
* This handler is invoked when the user wishes to create a new
* account.
****************************************************************/
void
gnc_ui_qif_account_picker_new_cb(GtkButton * w, gpointer user_data)
{
QIFAccountPickerDialog * wind = user_data;
SCM name_setter = scm_c_eval_string("qif-map-entry:set-gnc-name!");
const gchar *name;
int response;
gchar *fullname;
GtkWidget *dlg, *entry;
/* Create a dialog to get the new account name. */
dlg = gtk_message_dialog_new(GTK_WINDOW(wind->dialog),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_OK_CANCEL,
"%s", _("Enter a name for the account"));
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
entry = gtk_entry_new();
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
gtk_entry_set_max_length(GTK_ENTRY(entry), 250);
gtk_widget_show(entry);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dlg)->vbox), entry);
/* Run the dialog to get the new account name. */
response = gtk_dialog_run(GTK_DIALOG(dlg));
name = gtk_entry_get_text(GTK_ENTRY(entry));
/* Did the user enter a name and click OK? */
if (response == GTK_RESPONSE_OK && name && *name)
{
/* If an account is selected, this will be a new subaccount. */
if (wind->selected_name && *(wind->selected_name))
/* We have the short name; determine the full name. */
fullname = g_strjoin(gnc_get_account_separator_string(),
wind->selected_name, name, (char *)NULL);
else
fullname = g_strdup(name);
/* Save the full name and update the map entry. */
g_free(wind->selected_name);
wind->selected_name = fullname;
scm_call_2(name_setter, wind->map_entry, scm_from_utf8_string(fullname));
}
gtk_widget_destroy(dlg);
/* Refresh the tree display and give it the focus. */
build_acct_tree(wind, wind->qif_wind);
gtk_widget_grab_focus(GTK_WIDGET(wind->treeview));
}
static void
test_scm_local_eval ()
{
SCM result;
scm_c_use_module ("ice-9 local-eval");
result = scm_local_eval
(scm_list_3 (scm_from_latin1_symbol ("+"),
scm_from_latin1_symbol ("x"),
scm_from_latin1_symbol ("y")),
scm_c_eval_string ("(let ((x 1) (y 2)) (the-environment))"));
assert (scm_is_true (scm_equal_p (result,
scm_from_signed_integer (3))));
}
/********************************************************************\
* gnc_copy_split_scm_onto_split *
* copies a scheme representation of a split onto an actual split.*
* *
* Args: split_scm - the scheme representation of a split *
* split - the split to copy onto *
* Returns: Nothing *
\********************************************************************/
void
gnc_copy_split_scm_onto_split(SCM split_scm, Split *split,
QofBook * book)
{
static swig_type_info *split_type = NULL;
SCM result;
SCM func;
SCM arg;
if (split_scm == SCM_UNDEFINED)
return;
if (split == NULL)
return;
g_return_if_fail (book);
func = scm_c_eval_string("gnc:split-scm?");
if (!scm_is_procedure(func))
return;
result = scm_call_1(func, split_scm);
if (!scm_is_true(result))
return;
func = scm_c_eval_string("gnc:split-scm-onto-split");
if (!scm_is_procedure(func))
return;
if (!split_type)
split_type = SWIG_TypeQuery("_p_Split");
arg = SWIG_NewPointerObj(split, split_type, 0);
scm_call_3(func, split_scm, arg, gnc_book_to_scm (book));
}