← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to plug-ins/script-fu/siod-wrapper.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/script-fu/siod-wrapper.c
1
 
/* The GIMP -- an image manipulation program
2
 
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
 
 *
4
 
 * This program is free software; you can redistribute it and/or modify
5
 
 * it under the terms of the GNU General Public License as published by
6
 
 * the Free Software Foundation; either version 2 of the License, or
7
 
 * (at your option) any later version.
8
 
 *
9
 
 * This program is distributed in the hope that it will be useful,
10
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
 * GNU General Public License for more details.
13
 
 *
14
 
 * You should have received a copy of the GNU General Public License
15
 
 * along with this program; if not, write to the Free Software
16
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17
 
 */
18
 
 
19
 
#include "config.h"
20
 
 
21
 
#include <string.h> /* memcpy, strcpy, strlen */
22
 
 
23
 
#include <gtk/gtk.h>
24
 
 
25
 
#include "libgimp/gimp.h"
26
 
 
27
 
#include "siod/siod.h"
28
 
 
29
 
#include "script-fu-types.h"
30
 
 
31
 
#include "script-fu-console.h"
32
 
#include "script-fu-interface.h"
33
 
#include "script-fu-scripts.h"
34
 
#include "script-fu-server.h"
35
 
 
36
 
#include "siod-wrapper.h"
37
 
 
38
 
static int    siod_console_mode;
39
 
 
40
 
/* global variables declared by the scheme interpreter */
41
 
extern FILE * siod_output;
42
 
extern int    siod_verbose_level;
43
 
extern gchar  siod_err_msg[];
44
 
extern void * siod_output_routine;
45
 
extern LISP   repl_return_val;
46
 
 
47
 
 
48
 
/* defined in regex.c. not exported by regex.h */
49
 
extern void  init_regex   (void);
50
 
 
51
 
/* defined in siodp.h but this file cannot be imported... */
52
 
extern long  nlength (LISP obj);
53
 
extern LISP  leval_define (LISP args, LISP env);
54
 
 
55
 
 
56
 
/* wrapper functions */
57
 
FILE *
58
 
siod_get_output_file (void)
59
 
{
60
 
  return siod_output;
61
 
}
62
 
 
63
 
void
64
 
siod_set_output_file (FILE *file)
65
 
{
66
 
  siod_output = file;
67
 
}
68
 
 
69
 
void
70
 
siod_set_console_mode (int flag)
71
 
{
72
 
  siod_console_mode = flag;
73
 
}
74
 
 
75
 
int
76
 
siod_get_verbose_level (void)
77
 
{
78
 
  return siod_verbose_level;
79
 
}
80
 
 
81
 
 
82
 
void
83
 
siod_set_verbose_level (gint verbose_level)
84
 
{
85
 
  siod_verbose_level = verbose_level;
86
 
}
87
 
 
88
 
void
89
 
siod_print_welcome (void)
90
 
{
91
 
  print_welcome ();
92
 
}
93
 
 
94
 
gint
95
 
siod_interpret_string (const gchar *expr)
96
 
{
97
 
  return repl_c_string ((char *)expr, 0, 0, 1);
98
 
}
99
 
 
100
 
const char *
101
 
siod_get_error_msg (void)
102
 
{
103
 
  return siod_err_msg;
104
 
}
105
 
 
106
 
const gchar *
107
 
siod_get_success_msg (void)
108
 
{
109
 
  if (TYPEP (repl_return_val, tc_string))
110
 
    return get_c_string (repl_return_val);
111
 
  else
112
 
    return "Success";
113
 
}
114
 
 
115
 
void
116
 
siod_output_string (FILE        *fp,
117
 
                    const gchar *format,
118
 
                    ...)
119
 
{
120
 
  gchar   *buf;
121
 
  va_list  args;
122
 
 
123
 
  va_start (args, format);
124
 
  buf = g_strdup_vprintf (format, args);
125
 
  va_end (args);
126
 
 
127
 
  if (siod_console_mode && fp == stdout)
128
 
    {
129
 
      script_fu_output_to_console (buf);
130
 
    }
131
 
  else
132
 
    {
133
 
      fprintf (fp, buf);
134
 
      fflush (fp);
135
 
    }
136
 
 
137
 
  g_free (buf);
138
 
}
139
 
 
140
 
 
141
 
static void  init_constants   (void);
142
 
static void  init_procedures  (void);
143
 
 
144
 
static gboolean register_scripts = FALSE;
145
 
 
146
 
void
147
 
siod_init (gboolean local_register_scripts)
148
 
{
149
 
  char *siod_argv[] =
150
 
  {
151
 
    "siod",
152
 
    "-h100000:10",
153
 
    "-g0",
154
 
    "-o1000",
155
 
    "-s200000",
156
 
    "-n2048",
157
 
    "-v0",
158
 
  };
159
 
 
160
 
  register_scripts = local_register_scripts;
161
 
  siod_output_routine = siod_output_string;
162
 
 
163
 
  /* init the interpreter */
164
 
  process_cla (G_N_ELEMENTS (siod_argv), siod_argv, 1);
165
 
  init_storage ();
166
 
  init_subrs ();
167
 
  init_trace ();
168
 
  init_regex ();
169
 
 
170
 
  /* register in the interpreter the gimp functions and types. */
171
 
  init_procedures ();
172
 
  init_constants ();
173
 
 
174
 
}
175
 
 
176
 
static void  convert_string               (gchar    *str);
177
 
static gint  sputs_fcn                    (gchar    *st,
178
 
                                           gpointer  dest);
179
 
static LISP  lprin1s                      (LISP      exp,
180
 
                                           gchar    *dest);
181
 
static LISP  marshall_proc_db_call        (LISP      a);
182
 
static LISP  script_fu_register_call      (LISP      a);
183
 
static LISP  script_fu_menu_register_call (LISP      a);
184
 
static LISP  script_fu_quit_call          (LISP      a);
185
 
 
186
 
 
187
 
/*
188
 
 * Below can be found the functions responsible for registering the
189
 
 * gimp functions and types against the scheme interpreter.
190
 
 */
191
 
 
192
 
 
193
 
static void
194
 
init_procedures (void)
195
 
{
196
 
  gchar          **proc_list;
197
 
  gchar           *proc_name;
198
 
  gchar           *arg_name;
199
 
  gchar           *proc_blurb;
200
 
  gchar           *proc_help;
201
 
  gchar           *proc_author;
202
 
  gchar           *proc_copyright;
203
 
  gchar           *proc_date;
204
 
  GimpPDBProcType  proc_type;
205
 
  gint             nparams;
206
 
  gint             nreturn_vals;
207
 
  GimpParamDef    *params;
208
 
  GimpParamDef    *return_vals;
209
 
  gint             num_procs;
210
 
  gint             i;
211
 
 
212
 
  /*  register the database execution procedure  */
213
 
  init_lsubr ("gimp-proc-db-call",       marshall_proc_db_call);
214
 
  init_lsubr ("script-fu-register",      script_fu_register_call);
215
 
  init_lsubr ("script-fu-menu-register", script_fu_menu_register_call);
216
 
  init_lsubr ("script-fu-quit",          script_fu_quit_call);
217
 
 
218
 
  gimp_procedural_db_query (".*", ".*", ".*", ".*", ".*", ".*", ".*",
219
 
                            &num_procs, &proc_list);
220
 
 
221
 
  /*  Register each procedure as a scheme func  */
222
 
  for (i = 0; i < num_procs; i++)
223
 
    {
224
 
      proc_name = g_strdup (proc_list[i]);
225
 
 
226
 
      /*  lookup the procedure  */
227
 
      if (gimp_procedural_db_proc_info (proc_name,
228
 
                                        &proc_blurb,
229
 
                                        &proc_help,
230
 
                                        &proc_author,
231
 
                                        &proc_copyright,
232
 
                                        &proc_date,
233
 
                                        &proc_type,
234
 
                                        &nparams, &nreturn_vals,
235
 
                                        &params, &return_vals))
236
 
        {
237
 
          LISP args = NIL;
238
 
          LISP code = NIL;
239
 
          gint j;
240
 
 
241
 
          /*  convert the names to scheme-like naming conventions  */
242
 
          convert_string (proc_name);
243
 
 
244
 
          /*  create a new scheme func that calls gimp-proc-db-call  */
245
 
          for (j = 0; j < nparams; j++)
246
 
            {
247
 
              arg_name = g_strdup (params[j].name);
248
 
              convert_string (arg_name);
249
 
              args = cons (cintern (arg_name), args);
250
 
              code = cons (cintern (arg_name), code);
251
 
            }
252
 
 
253
 
          /*  reverse the list  */
254
 
          args = nreverse (args);
255
 
          code = nreverse (code);
256
 
 
257
 
          /*  set the scheme-based procedure name  */
258
 
          args = cons (cintern (proc_name), args);
259
 
 
260
 
          /*  set the acture pdb procedure name  */
261
 
          code = cons (cons (cintern ("quote"),
262
 
                             cons (cintern (proc_list[i]), NIL)),
263
 
                       code);
264
 
          code = cons (cintern ("gimp-proc-db-call"), code);
265
 
 
266
 
          leval_define (cons (args, cons (code, NIL)), NIL);
267
 
 
268
 
          /*  free the queried information  */
269
 
          g_free (proc_blurb);
270
 
          g_free (proc_help);
271
 
          g_free (proc_author);
272
 
          g_free (proc_copyright);
273
 
          g_free (proc_date);
274
 
          gimp_destroy_paramdefs (params, nparams);
275
 
          gimp_destroy_paramdefs (return_vals, nreturn_vals);
276
 
        }
277
 
    }
278
 
 
279
 
  g_free (proc_list);
280
 
}
281
 
 
282
 
static void
283
 
init_constants (void)
284
 
{
285
 
  const gchar **enum_type_names;
286
 
  gint          n_enum_type_names;
287
 
  gint          i;
288
 
  GimpUnit      unit;
289
 
 
290
 
  setvar (cintern ("gimp-directory"),
291
 
          strcons (-1, (gchar *) gimp_directory ()), NIL);
292
 
 
293
 
  setvar (cintern ("gimp-data-directory"),
294
 
          strcons (-1, (gchar *) gimp_data_directory ()), NIL);
295
 
 
296
 
  setvar (cintern ("gimp-plug-in-directory"),
297
 
          strcons (-1, (gchar *) gimp_plug_in_directory ()), NIL);
298
 
 
299
 
  setvar (cintern ("gimp-locale-directory"),
300
 
          strcons (-1, (gchar *) gimp_locale_directory ()), NIL);
301
 
 
302
 
  setvar (cintern ("gimp-sysconf-directory"),
303
 
          strcons (-1, (gchar *) gimp_sysconf_directory ()), NIL);
304
 
 
305
 
  enum_type_names = gimp_enums_get_type_names (&n_enum_type_names);
306
 
 
307
 
  for (i = 0; i < n_enum_type_names; i++)
308
 
    {
309
 
      const gchar *enum_name  = enum_type_names[i];
310
 
      GType        enum_type  = g_type_from_name (enum_name);
311
 
      GEnumClass  *enum_class = g_type_class_ref (enum_type);
312
 
      GEnumValue  *value;
313
 
 
314
 
      for (value = enum_class->values; value->value_name; value++)
315
 
        {
316
 
          if (! strncmp ("GIMP_", value->value_name, 5))
317
 
            {
318
 
              gchar *scheme_name;
319
 
 
320
 
              scheme_name = g_strdup (value->value_name + 5);
321
 
              convert_string (scheme_name);
322
 
 
323
 
              setvar (rintern (scheme_name), flocons (value->value), NIL);
324
 
 
325
 
              g_free (scheme_name);
326
 
            }
327
 
        }
328
 
 
329
 
      g_type_class_unref (enum_class);
330
 
    }
331
 
 
332
 
  for (unit = GIMP_UNIT_PIXEL;
333
 
       unit < gimp_unit_get_number_of_built_in_units ();
334
 
       unit++)
335
 
    {
336
 
      gchar *tmp;
337
 
      gchar *scheme_name;
338
 
 
339
 
      tmp = g_ascii_strup (gimp_unit_get_singular (unit), -1);
340
 
      scheme_name = g_strconcat ("UNIT-", tmp, NULL);
341
 
      g_free (tmp);
342
 
 
343
 
      setvar (rintern (scheme_name), flocons (unit), NIL);
344
 
 
345
 
      g_free (scheme_name);
346
 
    }
347
 
 
348
 
  /* These are for backwards compatibility; they should be removed sometime */
349
 
  setvar (cintern ("gimp-dir"),
350
 
          strcons (-1, (gchar *) gimp_directory ()), NIL);
351
 
 
352
 
  setvar (cintern ("gimp-data-dir"),
353
 
          strcons (-1, (gchar *) gimp_data_directory ()), NIL);
354
 
 
355
 
  setvar (cintern ("gimp-plugin-dir"),
356
 
          strcons (-1, (gchar *) gimp_plug_in_directory ()), NIL);
357
 
 
358
 
  setvar (cintern ("NORMAL"),         flocons (GIMP_NORMAL_MODE),       NIL);
359
 
  setvar (cintern ("DISSOLVE"),       flocons (GIMP_DISSOLVE_MODE),     NIL);
360
 
  setvar (cintern ("BEHIND"),         flocons (GIMP_BEHIND_MODE),       NIL);
361
 
  setvar (cintern ("MULTIPLY"),       flocons (GIMP_MULTIPLY_MODE),     NIL);
362
 
  setvar (cintern ("SCREEN"),         flocons (GIMP_SCREEN_MODE),       NIL);
363
 
  setvar (cintern ("OVERLAY"),        flocons (GIMP_OVERLAY_MODE),      NIL);
364
 
  setvar (cintern ("DIFFERENCE"),     flocons (GIMP_DIFFERENCE_MODE),   NIL);
365
 
  setvar (cintern ("ADDITION"),       flocons (GIMP_ADDITION_MODE),     NIL);
366
 
  setvar (cintern ("SUBTRACT"),       flocons (GIMP_SUBTRACT_MODE),     NIL);
367
 
  setvar (cintern ("DARKEN-ONLY"),    flocons (GIMP_DARKEN_ONLY_MODE),  NIL);
368
 
  setvar (cintern ("LIGHTEN-ONLY"),   flocons (GIMP_LIGHTEN_ONLY_MODE), NIL);
369
 
  setvar (cintern ("HUE"),            flocons (GIMP_HUE_MODE),          NIL);
370
 
  setvar (cintern ("SATURATION"),     flocons (GIMP_SATURATION_MODE),   NIL);
371
 
  setvar (cintern ("COLOR"),          flocons (GIMP_COLOR_MODE),        NIL);
372
 
  setvar (cintern ("VALUE"),          flocons (GIMP_VALUE_MODE),        NIL);
373
 
  setvar (cintern ("DIVIDE"),         flocons (GIMP_DIVIDE_MODE),       NIL);
374
 
 
375
 
  setvar (cintern ("BLUR"),           flocons (GIMP_BLUR_CONVOLVE),     NIL);
376
 
  setvar (cintern ("SHARPEN"),        flocons (GIMP_SHARPEN_CONVOLVE),  NIL);
377
 
 
378
 
  setvar (cintern ("WHITE-MASK"),     flocons (GIMP_ADD_WHITE_MASK),    NIL);
379
 
  setvar (cintern ("BLACK-MASK"),     flocons (GIMP_ADD_BLACK_MASK),    NIL);
380
 
  setvar (cintern ("ALPHA-MASK"),     flocons (GIMP_ADD_ALPHA_MASK),    NIL);
381
 
 
382
 
  setvar (cintern ("ADD"),         flocons (GIMP_CHANNEL_OP_ADD),       NIL);
383
 
  setvar (cintern ("SUB"),         flocons (GIMP_CHANNEL_OP_SUBTRACT),  NIL);
384
 
  setvar (cintern ("REPLACE"),     flocons (GIMP_CHANNEL_OP_REPLACE),   NIL);
385
 
  setvar (cintern ("INTERSECT"),   flocons (GIMP_CHANNEL_OP_INTERSECT), NIL);
386
 
 
387
 
  setvar (cintern ("FG-BG-RGB"),   flocons (GIMP_FG_BG_RGB_MODE),       NIL);
388
 
  setvar (cintern ("FG-BG-HSV"),   flocons (GIMP_FG_BG_HSV_MODE),       NIL);
389
 
  setvar (cintern ("FG-TRANS"),    flocons (GIMP_FG_TRANSPARENT_MODE),  NIL);
390
 
  setvar (cintern ("CUSTOM"),      flocons (GIMP_CUSTOM_MODE),          NIL);
391
 
 
392
 
  setvar (cintern ("FG-IMAGE-FILL"),    flocons (GIMP_FOREGROUND_FILL),  NIL);
393
 
  setvar (cintern ("BG-IMAGE-FILL"),    flocons (GIMP_BACKGROUND_FILL),  NIL);
394
 
  setvar (cintern ("WHITE-IMAGE-FILL"), flocons (GIMP_WHITE_FILL),       NIL);
395
 
  setvar (cintern ("TRANS-IMAGE-FILL"), flocons (GIMP_TRANSPARENT_FILL), NIL);
396
 
 
397
 
  setvar (cintern ("APPLY"),     flocons (GIMP_MASK_APPLY),   NIL);
398
 
  setvar (cintern ("DISCARD"),   flocons (GIMP_MASK_DISCARD), NIL);
399
 
 
400
 
  setvar (cintern ("HARD"),      flocons (GIMP_BRUSH_HARD), NIL);
401
 
  setvar (cintern ("SOFT"),      flocons (GIMP_BRUSH_SOFT), NIL);
402
 
 
403
 
  setvar (cintern ("CONTINUOUS"),  flocons (GIMP_PAINT_CONSTANT),    NIL);
404
 
  setvar (cintern ("INCREMENTAL"), flocons (GIMP_PAINT_INCREMENTAL), NIL);
405
 
 
406
 
  setvar (cintern ("HORIZONTAL"), flocons (GIMP_ORIENTATION_HORIZONTAL), NIL);
407
 
  setvar (cintern ("VERTICAL"),   flocons (GIMP_ORIENTATION_VERTICAL),   NIL);
408
 
  setvar (cintern ("UNKNOWN"),    flocons (GIMP_ORIENTATION_UNKNOWN),    NIL);
409
 
 
410
 
  setvar (cintern ("LINEAR"),               flocons (GIMP_GRADIENT_LINEAR),               NIL);
411
 
  setvar (cintern ("BILINEAR"),             flocons (GIMP_GRADIENT_BILINEAR),             NIL);
412
 
  setvar (cintern ("RADIAL"),               flocons (GIMP_GRADIENT_RADIAL),               NIL);
413
 
  setvar (cintern ("SQUARE"),               flocons (GIMP_GRADIENT_SQUARE),               NIL);
414
 
  setvar (cintern ("CONICAL-SYMMETRIC"),    flocons (GIMP_GRADIENT_CONICAL_SYMMETRIC),    NIL);
415
 
  setvar (cintern ("CONICAL-ASYMMETRIC"),   flocons (GIMP_GRADIENT_CONICAL_ASYMMETRIC),   NIL);
416
 
  setvar (cintern ("SHAPEBURST-ANGULAR"),   flocons (GIMP_GRADIENT_SHAPEBURST_ANGULAR),   NIL);
417
 
  setvar (cintern ("SHAPEBURST-SPHERICAL"), flocons (GIMP_GRADIENT_SHAPEBURST_SPHERICAL), NIL);
418
 
  setvar (cintern ("SHAPEBURST-DIMPLED"),   flocons (GIMP_GRADIENT_SHAPEBURST_DIMPLED),   NIL);
419
 
  setvar (cintern ("SPIRAL-CLOCKWISE"),     flocons (GIMP_GRADIENT_SPIRAL_CLOCKWISE),     NIL);
420
 
  setvar (cintern ("SPIRAL-ANTICLOCKWISE"), flocons (GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE), NIL);
421
 
 
422
 
  setvar (cintern ("VALUE-LUT"), flocons (GIMP_HISTOGRAM_VALUE), NIL);
423
 
  setvar (cintern ("RED-LUT"),   flocons (GIMP_HISTOGRAM_RED),   NIL);
424
 
  setvar (cintern ("GREEN-LUT"), flocons (GIMP_HISTOGRAM_GREEN), NIL);
425
 
  setvar (cintern ("BLUE-LUT"),  flocons (GIMP_HISTOGRAM_BLUE),  NIL);
426
 
  setvar (cintern ("ALPHA-LUT"), flocons (GIMP_HISTOGRAM_ALPHA), NIL);
427
 
 
428
 
  /* Useful misc stuff */
429
 
  setvar (cintern ("TRUE"),           flocons (TRUE),  NIL);
430
 
  setvar (cintern ("FALSE"),          flocons (FALSE), NIL);
431
 
 
432
 
  /*  Script-fu types  */
433
 
  setvar (cintern ("SF-IMAGE"),       flocons (SF_IMAGE),      NIL);
434
 
  setvar (cintern ("SF-DRAWABLE"),    flocons (SF_DRAWABLE),   NIL);
435
 
  setvar (cintern ("SF-LAYER"),       flocons (SF_LAYER),      NIL);
436
 
  setvar (cintern ("SF-CHANNEL"),     flocons (SF_CHANNEL),    NIL);
437
 
  setvar (cintern ("SF-COLOR"),       flocons (SF_COLOR),      NIL);
438
 
  setvar (cintern ("SF-TOGGLE"),      flocons (SF_TOGGLE),     NIL);
439
 
  setvar (cintern ("SF-VALUE"),       flocons (SF_VALUE),      NIL);
440
 
  setvar (cintern ("SF-STRING"),      flocons (SF_STRING),     NIL);
441
 
  setvar (cintern ("SF-FILENAME"),    flocons (SF_FILENAME),   NIL);
442
 
  setvar (cintern ("SF-DIRNAME"),     flocons (SF_DIRNAME),    NIL);
443
 
  setvar (cintern ("SF-ADJUSTMENT"),  flocons (SF_ADJUSTMENT), NIL);
444
 
  setvar (cintern ("SF-FONT"),        flocons (SF_FONT),       NIL);
445
 
  setvar (cintern ("SF-PATTERN"),     flocons (SF_PATTERN),    NIL);
446
 
  setvar (cintern ("SF-BRUSH"),       flocons (SF_BRUSH),      NIL);
447
 
  setvar (cintern ("SF-GRADIENT"),    flocons (SF_GRADIENT),   NIL);
448
 
  setvar (cintern ("SF-OPTION"),      flocons (SF_OPTION),     NIL);
449
 
  setvar (cintern ("SF-PALETTE"),     flocons (SF_PALETTE),    NIL);
450
 
  setvar (cintern ("SF-TEXT"),        flocons (SF_TEXT),       NIL);
451
 
 
452
 
  /* for SF_ADJUSTMENT */
453
 
  setvar (cintern ("SF-SLIDER"),      flocons (SF_SLIDER),     NIL);
454
 
  setvar (cintern ("SF-SPINNER"),     flocons (SF_SPINNER),    NIL);
455
 
}
456
 
 
457
 
static void
458
 
convert_string (gchar *str)
459
 
{
460
 
  while (*str)
461
 
    {
462
 
      if (*str == '_') *str = '-';
463
 
      str++;
464
 
    }
465
 
}
466
 
 
467
 
static gboolean
468
 
sputs_fcn (gchar    *st,
469
 
           gpointer  dest)
470
 
{
471
 
  strcpy (*((gchar**)dest), st);
472
 
  *((gchar**)dest) += strlen (st);
473
 
 
474
 
  return TRUE;
475
 
}
476
 
 
477
 
static LISP
478
 
lprin1s (LISP   exp,
479
 
         gchar *dest)
480
 
{
481
 
  struct gen_printio s;
482
 
 
483
 
  s.putc_fcn    = NULL;
484
 
  s.puts_fcn    = sputs_fcn;
485
 
  s.cb_argument = &dest;
486
 
 
487
 
  lprin1g (exp, &s);
488
 
 
489
 
  return (NIL);
490
 
}
491
 
 
492
 
 
493
 
static LISP
494
 
marshall_proc_db_call (LISP a)
495
 
{
496
 
  GimpParam       *args;
497
 
  GimpParam       *values = NULL;
498
 
  gint             nvalues;
499
 
  gchar           *proc_name;
500
 
  gchar           *proc_blurb;
501
 
  gchar           *proc_help;
502
 
  gchar           *proc_author;
503
 
  gchar           *proc_copyright;
504
 
  gchar           *proc_date;
505
 
  GimpPDBProcType  proc_type;
506
 
  gint             nparams;
507
 
  gint             nreturn_vals;
508
 
  GimpParamDef    *params;
509
 
  GimpParamDef    *return_vals;
510
 
  gchar            error_str[256];
511
 
  gint             i;
512
 
  gint             success = TRUE;
513
 
  LISP             intermediate_val;
514
 
  LISP             return_val = NIL;
515
 
  gchar           *string;
516
 
  gint             string_len;
517
 
  LISP             a_saved;
518
 
 
519
 
  /* Save a in case it is needed for an error message. */
520
 
  a_saved = a;
521
 
 
522
 
  /*  Make sure there are arguments  */
523
 
  if (a == NIL)
524
 
    return my_err ("Procedure database argument marshaller was called with no arguments. "
525
 
                   "The procedure to be executed and the arguments it requires "
526
 
                   "(possibly none) must be specified.", NIL);
527
 
 
528
 
  /*  Derive the pdb procedure name from the argument
529
 
      or first argument of a list  */
530
 
  if (TYPEP (a, tc_cons))
531
 
    proc_name = g_strdup (get_c_string (car (a)));
532
 
  else
533
 
    proc_name = g_strdup (get_c_string (a));
534
 
 
535
 
  /*  report the current command  */
536
 
  script_fu_interface_report_cc (proc_name);
537
 
 
538
 
  /*  Attempt to fetch the procedure from the database  */
539
 
  if (! gimp_procedural_db_proc_info (proc_name,
540
 
                                      &proc_blurb,
541
 
                                      &proc_help,
542
 
                                      &proc_author,
543
 
                                      &proc_copyright,
544
 
                                      &proc_date,
545
 
                                      &proc_type,
546
 
                                      &nparams, &nreturn_vals,
547
 
                                      &params, &return_vals))
548
 
    {
549
 
      convert_string (proc_name);
550
 
      g_snprintf (error_str, sizeof (error_str),
551
 
                  "Invalid procedure name %s specified", proc_name);
552
 
      return my_err (error_str, NIL);
553
 
    }
554
 
 
555
 
  /* Free the name and the description which are of no use here.  */
556
 
  for (i = 0; i < nparams; i++)
557
 
    {
558
 
      g_free (params[i].name);
559
 
      g_free (params[i].description);
560
 
    }
561
 
  for (i = 0; i < nreturn_vals; i++)
562
 
    {
563
 
      g_free (return_vals[i].name);
564
 
      g_free (return_vals[i].description);
565
 
    }
566
 
 
567
 
  /*  Check the supplied number of arguments  */
568
 
  if ((nlength (a) - 1) != nparams)
569
 
    {
570
 
      convert_string (proc_name);
571
 
      g_snprintf (error_str, sizeof (error_str),
572
 
                  "Invalid arguments supplied to %s -- "
573
 
                  "(# args: %ld, expecting: %d)",
574
 
                  proc_name, (nlength (a) - 1), nparams);
575
 
      return my_err (error_str, NIL);
576
 
    }
577
 
 
578
 
  /*  Marshall the supplied arguments  */
579
 
  if (nparams)
580
 
    args = g_new (GimpParam, nparams);
581
 
  else
582
 
    args = NULL;
583
 
 
584
 
  a = cdr (a);
585
 
  for (i = 0; i < nparams; i++)
586
 
    {
587
 
      switch (params[i].type)
588
 
        {
589
 
        case GIMP_PDB_INT32:
590
 
          if (!TYPEP (car (a), tc_flonum))
591
 
            success = FALSE;
592
 
          if (success)
593
 
            {
594
 
              args[i].type         = GIMP_PDB_INT32;
595
 
              args[i].data.d_int32 = get_c_long (car (a));
596
 
            }
597
 
          break;
598
 
 
599
 
        case GIMP_PDB_INT16:
600
 
          if (!TYPEP (car (a), tc_flonum))
601
 
            success = FALSE;
602
 
          if (success)
603
 
            {
604
 
              args[i].type         = GIMP_PDB_INT16;
605
 
              args[i].data.d_int16 = (gint16) get_c_long (car (a));
606
 
            }
607
 
          break;
608
 
 
609
 
        case GIMP_PDB_INT8:
610
 
          if (!TYPEP (car (a), tc_flonum))
611
 
            success = FALSE;
612
 
          if (success)
613
 
            {
614
 
              args[i].type        = GIMP_PDB_INT8;
615
 
              args[i].data.d_int8 = (gint8) get_c_long (car (a));
616
 
            }
617
 
          break;
618
 
 
619
 
        case GIMP_PDB_FLOAT:
620
 
          if (!TYPEP (car (a), tc_flonum))
621
 
            success = FALSE;
622
 
          if (success)
623
 
            {
624
 
              args[i].type         = GIMP_PDB_FLOAT;
625
 
              args[i].data.d_float = get_c_double (car (a));
626
 
            }
627
 
          break;
628
 
 
629
 
        case GIMP_PDB_STRING:
630
 
          if (!TYPEP (car (a), tc_string))
631
 
            success = FALSE;
632
 
          if (success)
633
 
            {
634
 
              args[i].type          = GIMP_PDB_STRING;
635
 
              args[i].data.d_string = get_c_string (car (a));
636
 
            }
637
 
          break;
638
 
 
639
 
        case GIMP_PDB_INT32ARRAY:
640
 
          if (!TYPEP (car (a), tc_long_array))
641
 
            success = FALSE;
642
 
          if (success)
643
 
            {
644
 
              gint n_elements = args[i - 1].data.d_int32;
645
 
              LISP list       = car (a);
646
 
 
647
 
              if ((n_elements < 0) || (n_elements > nlength (list)))
648
 
                {
649
 
                  convert_string (proc_name);
650
 
                  g_snprintf (error_str, sizeof (error_str),
651
 
                              "INT32 array (argument %d) for function %s has "
652
 
                              "incorrect length (got %ld, expected %d)",
653
 
                              i + 1, proc_name, nlength (list), n_elements);
654
 
                  return my_err (error_str, NIL);
655
 
                }
656
 
 
657
 
              args[i].type              = GIMP_PDB_INT32ARRAY;
658
 
              args[i].data.d_int32array = (gint32 *)
659
 
                list->storage_as.long_array.data;
660
 
            }
661
 
          break;
662
 
 
663
 
        case GIMP_PDB_INT16ARRAY:
664
 
          if (!TYPEP (car (a), tc_long_array))
665
 
            success = FALSE;
666
 
          if (success)
667
 
            {
668
 
              gint n_elements = args[i - 1].data.d_int32;
669
 
              LISP list       = car (a);
670
 
 
671
 
              if ((n_elements < 0) || (n_elements > nlength (list)))
672
 
                {
673
 
                  convert_string (proc_name);
674
 
                  g_snprintf (error_str, sizeof (error_str),
675
 
                              "INT16 array (argument %d) for function %s has "
676
 
                              "incorrect length (got %ld, expected %d)",
677
 
                              i + 1, proc_name, nlength (list), n_elements);
678
 
                  return my_err (error_str, NIL);
679
 
                }
680
 
 
681
 
              args[i].type              = GIMP_PDB_INT16ARRAY;
682
 
              args[i].data.d_int16array = (gint16 *)
683
 
                list->storage_as.long_array.data;
684
 
            }
685
 
          break;
686
 
 
687
 
        case GIMP_PDB_INT8ARRAY:
688
 
          if (!TYPEP (car (a), tc_byte_array))
689
 
            success = FALSE;
690
 
          if (success)
691
 
            {
692
 
              gint n_elements = args[i - 1].data.d_int32;
693
 
              LISP list       = car (a);
694
 
 
695
 
              if ((n_elements < 0) || (n_elements > nlength (list)))
696
 
                {
697
 
                  convert_string (proc_name);
698
 
                  g_snprintf (error_str, sizeof (error_str),
699
 
                              "INT8 array (argument %d) for function %s has "
700
 
                              "incorrect length (got %ld, expected %d)",
701
 
                              i + 1, proc_name, nlength (list), n_elements);
702
 
                  return my_err (error_str, NIL);
703
 
                }
704
 
 
705
 
              args[i].type             = GIMP_PDB_INT8ARRAY;
706
 
              args[i].data.d_int8array = (gint8 *) list->storage_as.string.data;
707
 
            }
708
 
          break;
709
 
 
710
 
        case GIMP_PDB_FLOATARRAY:
711
 
          if (!TYPEP (car (a), tc_double_array))
712
 
            success = FALSE;
713
 
          if (success)
714
 
            {
715
 
              gint n_elements = args[i - 1].data.d_int32;
716
 
              LISP list       = car (a);
717
 
 
718
 
              if ((n_elements < 0) || (n_elements > nlength (list)))
719
 
                {
720
 
                  convert_string (proc_name);
721
 
                  g_snprintf (error_str, sizeof (error_str),
722
 
                              "FLOAT array (argument %d) for function %s has "
723
 
                              "incorrect length (got %ld, expected %d)",
724
 
                              i + 1, proc_name, nlength (list), n_elements);
725
 
                  return my_err (error_str, NIL);
726
 
                }
727
 
 
728
 
              args[i].type              = GIMP_PDB_FLOATARRAY;
729
 
              args[i].data.d_floatarray = list->storage_as.double_array.data;
730
 
            }
731
 
          break;
732
 
 
733
 
        case GIMP_PDB_STRINGARRAY:
734
 
          if (!TYPEP (car (a), tc_cons))
735
 
            success = FALSE;
736
 
          if (success)
737
 
            {
738
 
              gint    n_elements = args[i - 1].data.d_int32;
739
 
              LISP    list       = car (a);
740
 
              gint    j;
741
 
 
742
 
              if ((n_elements < 0) || (n_elements > nlength (list)))
743
 
                {
744
 
                  convert_string (proc_name);
745
 
                  g_snprintf (error_str, sizeof (error_str),
746
 
                              "String array (argument %d) for function %s has "
747
 
                              "incorrect length (got %ld, expected %d)",
748
 
                              i + 1, proc_name, nlength (list), n_elements);
749
 
                  return my_err (error_str, NIL);
750
 
                }
751
 
 
752
 
              args[i].type               = GIMP_PDB_STRINGARRAY;
753
 
              args[i].data.d_stringarray = g_new0 (gchar *, n_elements);
754
 
 
755
 
              for (j = 0; j < n_elements; j++)
756
 
                {
757
 
                  args[i].data.d_stringarray[j] = get_c_string (car (list));
758
 
                  list = cdr (list);
759
 
                }
760
 
            }
761
 
          break;
762
 
 
763
 
        case GIMP_PDB_COLOR:
764
 
          if (!TYPEP (car (a), tc_cons))
765
 
            success = FALSE;
766
 
          if (success)
767
 
            {
768
 
              LISP   color_list;
769
 
              guchar r, g, b;
770
 
 
771
 
              args[i].type = GIMP_PDB_COLOR;
772
 
              color_list = car (a);
773
 
              r = CLAMP (get_c_long (car (color_list)), 0, 255);
774
 
              color_list = cdr (color_list);
775
 
              g = CLAMP (get_c_long (car (color_list)), 0, 255);
776
 
              color_list = cdr (color_list);
777
 
              b = CLAMP (get_c_long (car (color_list)), 0, 255);
778
 
 
779
 
              gimp_rgba_set_uchar (&args[i].data.d_color, r, g, b, 255);
780
 
            }
781
 
          break;
782
 
 
783
 
        case GIMP_PDB_REGION:
784
 
          return my_err ("Regions are currently unsupported as arguments",
785
 
                         car (a));
786
 
          break;
787
 
 
788
 
        case GIMP_PDB_DISPLAY:
789
 
          if (!TYPEP (car (a), tc_flonum))
790
 
            success = FALSE;
791
 
          if (success)
792
 
            {
793
 
              args[i].type = GIMP_PDB_DISPLAY;
794
 
              args[i].data.d_int32 = get_c_long (car (a));
795
 
            }
796
 
          break;
797
 
 
798
 
        case GIMP_PDB_IMAGE:
799
 
          if (!TYPEP (car (a), tc_flonum))
800
 
            success = FALSE;
801
 
          if (success)
802
 
            {
803
 
              args[i].type = GIMP_PDB_IMAGE;
804
 
              args[i].data.d_int32 = get_c_long (car (a));
805
 
            }
806
 
          break;
807
 
 
808
 
        case GIMP_PDB_LAYER:
809
 
          if (!TYPEP (car (a), tc_flonum))
810
 
            success = FALSE;
811
 
          if (success)
812
 
            {
813
 
              args[i].type = GIMP_PDB_LAYER;
814
 
              args[i].data.d_int32 = get_c_long (car (a));
815
 
            }
816
 
          break;
817
 
 
818
 
        case GIMP_PDB_CHANNEL:
819
 
          if (!TYPEP (car (a), tc_flonum))
820
 
            success = FALSE;
821
 
          if (success)
822
 
            {
823
 
              args[i].type = GIMP_PDB_CHANNEL;
824
 
              args[i].data.d_int32 = get_c_long (car (a));
825
 
            }
826
 
          break;
827
 
 
828
 
        case GIMP_PDB_DRAWABLE:
829
 
          if (!TYPEP (car (a), tc_flonum))
830
 
            success = FALSE;
831
 
          if (success)
832
 
            {
833
 
              args[i].type = GIMP_PDB_DRAWABLE;
834
 
              args[i].data.d_int32 = get_c_long (car (a));
835
 
            }
836
 
          break;
837
 
 
838
 
        case GIMP_PDB_SELECTION:
839
 
          if (!TYPEP (car (a), tc_flonum))
840
 
            success = FALSE;
841
 
          if (success)
842
 
            {
843
 
              args[i].type = GIMP_PDB_SELECTION;
844
 
              args[i].data.d_int32 = get_c_long (car (a));
845
 
            }
846
 
          break;
847
 
 
848
 
        case GIMP_PDB_BOUNDARY:
849
 
          return my_err ("Boundaries are currently unsupported as arguments",
850
 
                         car (a));
851
 
          break;
852
 
 
853
 
        case GIMP_PDB_PATH:
854
 
          return my_err ("Paths are currently unsupported as arguments",
855
 
                         car (a));
856
 
          break;
857
 
 
858
 
        case GIMP_PDB_PARASITE:
859
 
          if (!TYPEP (car (a), tc_cons))
860
 
            success = FALSE;
861
 
          if (success)
862
 
            {
863
 
              args[i].type = GIMP_PDB_PARASITE;
864
 
 
865
 
              /* parasite->name */
866
 
              intermediate_val = car (a);
867
 
 
868
 
              if (!TYPEP (car (intermediate_val), tc_string))
869
 
                {
870
 
                  success = FALSE;
871
 
                  break;
872
 
                }
873
 
 
874
 
              args[i].data.d_parasite.name =
875
 
                get_c_string (car (intermediate_val));
876
 
 
877
 
              /* parasite->flags */
878
 
              intermediate_val = cdr (intermediate_val);
879
 
 
880
 
              if (!TYPEP (car (intermediate_val), tc_flonum))
881
 
                {
882
 
                  success = FALSE;
883
 
                  break;
884
 
                }
885
 
 
886
 
              args[i].data.d_parasite.flags =
887
 
                get_c_long (car (intermediate_val));
888
 
 
889
 
              /* parasite->size */
890
 
              intermediate_val = cdr (intermediate_val);
891
 
 
892
 
              if (!TYPEP (car (intermediate_val), tc_string) &&
893
 
                  !TYPEP (car (intermediate_val), tc_byte_array))
894
 
                {
895
 
                  success = FALSE;
896
 
                  break;
897
 
                }
898
 
 
899
 
              args[i].data.d_parasite.size =
900
 
                (car (intermediate_val))->storage_as.string.dim;
901
 
 
902
 
              /* parasite->data */
903
 
              args[i].data.d_parasite.data =
904
 
                (car (intermediate_val))->storage_as.string.data;
905
 
            }
906
 
          break;
907
 
 
908
 
        case GIMP_PDB_STATUS:
909
 
          return my_err ("Status is for return types, not arguments", car (a));
910
 
          break;
911
 
 
912
 
        default:
913
 
          convert_string (proc_name);
914
 
          g_snprintf (error_str, sizeof (error_str),
915
 
                      "Argument %d for %s is an unknown type",
916
 
                      i + 1, proc_name);
917
 
          return my_err (error_str, NIL);
918
 
        }
919
 
 
920
 
      if (!success)
921
 
        break;
922
 
 
923
 
      a = cdr (a);
924
 
    }
925
 
 
926
 
  if (success)
927
 
    {
928
 
      values = gimp_run_procedure2 (proc_name, &nvalues, nparams, args);
929
 
    }
930
 
  else
931
 
    {
932
 
      g_snprintf (error_str, sizeof (error_str),
933
 
                  "Invalid type for argument %d to %s", i + 1, proc_name);
934
 
      return my_err (error_str, NIL);
935
 
    }
936
 
 
937
 
  /*  Check the return status  */
938
 
  if (! values)
939
 
    {
940
 
      strcpy (error_str,
941
 
              "Procedural database execution did not return a status:\n    ");
942
 
      lprin1s (a_saved, error_str + strlen (error_str));
943
 
 
944
 
      return my_err (error_str, NIL);
945
 
    }
946
 
 
947
 
  switch (values[0].data.d_status)
948
 
    {
949
 
    case GIMP_PDB_EXECUTION_ERROR:
950
 
      strcpy (error_str,
951
 
              "Procedural database execution failed:\n    ");
952
 
      lprin1s (a_saved, error_str + strlen (error_str));
953
 
      return my_err (error_str, NIL);
954
 
      break;
955
 
 
956
 
    case GIMP_PDB_CALLING_ERROR:
957
 
      strcpy (error_str,
958
 
              "Procedural database execution failed on invalid input arguments:\n    ");
959
 
      lprin1s (a_saved, error_str + strlen (error_str));
960
 
      return my_err (error_str, NIL);
961
 
      break;
962
 
 
963
 
    case GIMP_PDB_SUCCESS:
964
 
      return_val = NIL;
965
 
 
966
 
      for (i = 0; i < nvalues - 1; i++)
967
 
        {
968
 
          switch (return_vals[i].type)
969
 
            {
970
 
            case GIMP_PDB_INT32:
971
 
              return_val = cons (flocons (values[i + 1].data.d_int32),
972
 
                                 return_val);
973
 
              break;
974
 
 
975
 
            case GIMP_PDB_INT16:
976
 
              return_val = cons (flocons (values[i + 1].data.d_int32),
977
 
                                 return_val);
978
 
              break;
979
 
 
980
 
            case GIMP_PDB_INT8:
981
 
              return_val = cons (flocons (values[i + 1].data.d_int32),
982
 
                                 return_val);
983
 
              break;
984
 
 
985
 
            case GIMP_PDB_FLOAT:
986
 
              return_val = cons (flocons (values[i + 1].data.d_float),
987
 
                                 return_val);
988
 
              break;
989
 
 
990
 
            case GIMP_PDB_STRING:
991
 
              string = values[i + 1].data.d_string;
992
 
              if (! string)
993
 
                string = "";
994
 
              string_len = strlen (string);
995
 
              return_val = cons (strcons (string_len, string), return_val);
996
 
              break;
997
 
 
998
 
            case GIMP_PDB_INT32ARRAY:
999
 
              {
1000
 
                LISP array;
1001
 
                gint j;
1002
 
 
1003
 
                array = arcons (tc_long_array, values[i].data.d_int32, 0);
1004
 
                for (j = 0; j < values[i].data.d_int32; j++)
1005
 
                  {
1006
 
                    array->storage_as.long_array.data[j] =
1007
 
                      values[i + 1].data.d_int32array[j];
1008
 
                  }
1009
 
                return_val = cons (array, return_val);
1010
 
              }
1011
 
              break;
1012
 
 
1013
 
            case GIMP_PDB_INT16ARRAY:
1014
 
              {
1015
 
                LISP array;
1016
 
                gint j;
1017
 
 
1018
 
                array = arcons (tc_long_array, values[i].data.d_int32, 0);
1019
 
                for (j = 0; j < values[i].data.d_int32; j++)
1020
 
                  {
1021
 
                    array->storage_as.long_array.data[j] =
1022
 
                      values[i + 1].data.d_int16array[j];
1023
 
                  }
1024
 
                return_val = cons (array, return_val);
1025
 
              }
1026
 
              break;
1027
 
 
1028
 
            case GIMP_PDB_INT8ARRAY:
1029
 
              {
1030
 
                LISP array;
1031
 
                gint j;
1032
 
 
1033
 
                array = arcons (tc_byte_array, values[i].data.d_int32, 0);
1034
 
                for (j = 0; j < values[i].data.d_int32; j++)
1035
 
                  {
1036
 
                    array->storage_as.string.data[j] =
1037
 
                      values[i + 1].data.d_int8array[j];
1038
 
                  }
1039
 
                return_val = cons (array, return_val);
1040
 
              }
1041
 
              break;
1042
 
 
1043
 
            case GIMP_PDB_FLOATARRAY:
1044
 
              {
1045
 
                LISP array;
1046
 
                gint j;
1047
 
 
1048
 
                array = arcons (tc_double_array, values[i].data.d_int32, 0);
1049
 
                for (j = 0; j < values[i].data.d_int32; j++)
1050
 
                  {
1051
 
                    array->storage_as.double_array.data[j] =
1052
 
                      values[i + 1].data.d_floatarray[j];
1053
 
                  }
1054
 
                return_val = cons (array, return_val);
1055
 
              }
1056
 
              break;
1057
 
 
1058
 
            case GIMP_PDB_STRINGARRAY:
1059
 
              {
1060
 
                LISP array = NIL;
1061
 
                gint j;
1062
 
 
1063
 
                for (j = 0; j < values[i].data.d_int32; j++)
1064
 
                  {
1065
 
                    string = (values[i + 1].data.d_stringarray)[j];
1066
 
 
1067
 
                    if (string)
1068
 
                      {
1069
 
                        string_len = strlen (string);
1070
 
                        array = cons (strcons (string_len, string), array);
1071
 
                      }
1072
 
                    else
1073
 
                      {
1074
 
                        array = cons (strcons (0, ""), array);
1075
 
                      }
1076
 
                  }
1077
 
 
1078
 
                return_val = cons (nreverse (array), return_val);
1079
 
              }
1080
 
              break;
1081
 
 
1082
 
            case GIMP_PDB_COLOR:
1083
 
              {
1084
 
                guchar r, g, b;
1085
 
 
1086
 
                gimp_rgb_get_uchar (&values[i + 1].data.d_color, &r, &g, &b);
1087
 
 
1088
 
                intermediate_val = cons (flocons (r),
1089
 
                                         cons (flocons (g),
1090
 
                                               cons (flocons (b),
1091
 
                                                     NIL)));
1092
 
                return_val = cons (intermediate_val, return_val);
1093
 
                break;
1094
 
              }
1095
 
 
1096
 
            case GIMP_PDB_REGION:
1097
 
              return my_err ("Regions are currently unsupported as return values", NIL);
1098
 
              break;
1099
 
 
1100
 
            case GIMP_PDB_DISPLAY:
1101
 
              return_val = cons (flocons (values[i + 1].data.d_int32),
1102
 
                                 return_val);
1103
 
              break;
1104
 
 
1105
 
            case GIMP_PDB_IMAGE:
1106
 
              return_val = cons (flocons (values[i + 1].data.d_int32),
1107
 
                                 return_val);
1108
 
              break;
1109
 
 
1110
 
            case GIMP_PDB_LAYER:
1111
 
              return_val = cons (flocons (values[i + 1].data.d_int32),
1112
 
                                 return_val);
1113
 
              break;
1114
 
 
1115
 
            case GIMP_PDB_CHANNEL:
1116
 
              return_val = cons (flocons (values[i + 1].data.d_int32),
1117
 
                                 return_val);
1118
 
              break;
1119
 
 
1120
 
            case GIMP_PDB_DRAWABLE:
1121
 
              return_val = cons (flocons (values[i + 1].data.d_int32),
1122
 
                                 return_val);
1123
 
              break;
1124
 
 
1125
 
            case GIMP_PDB_SELECTION:
1126
 
              return_val = cons (flocons (values[i + 1].data.d_int32),
1127
 
                                 return_val);
1128
 
              break;
1129
 
 
1130
 
            case GIMP_PDB_BOUNDARY:
1131
 
              return my_err ("Boundaries are currently unsupported as return values", NIL);
1132
 
              break;
1133
 
 
1134
 
            case GIMP_PDB_PATH:
1135
 
              return my_err ("Paths are currently unsupported as return values", NIL);
1136
 
              break;
1137
 
 
1138
 
            case GIMP_PDB_PARASITE:
1139
 
              {
1140
 
                LISP name, flags, data;
1141
 
 
1142
 
                if (values[i + 1].data.d_parasite.name == NULL)
1143
 
                  {
1144
 
                    return_val = my_err("Error: null parasite", NIL);
1145
 
                  }
1146
 
                else
1147
 
                  {
1148
 
                    string_len = strlen (values[i + 1].data.d_parasite.name);
1149
 
                    name    = strcons (string_len,
1150
 
                                       values[i + 1].data.d_parasite.name);
1151
 
 
1152
 
                    flags   = flocons (values[i + 1].data.d_parasite.flags);
1153
 
                    data    = arcons (tc_byte_array,
1154
 
                                      values[i + 1].data.d_parasite.size, 0);
1155
 
                    memcpy(data->storage_as.string.data,
1156
 
                           values[i + 1].data.d_parasite.data,
1157
 
                           values[i + 1].data.d_parasite.size);
1158
 
 
1159
 
                    intermediate_val = cons (name,
1160
 
                                             cons(flags, cons(data, NIL)));
1161
 
                    return_val = cons (intermediate_val, return_val);
1162
 
                  }
1163
 
              }
1164
 
              break;
1165
 
 
1166
 
            case GIMP_PDB_STATUS:
1167
 
              return my_err ("Procedural database execution returned multiple status values", NIL);
1168
 
              break;
1169
 
 
1170
 
            default:
1171
 
              return my_err ("Unknown return type", NIL);
1172
 
            }
1173
 
        }
1174
 
      break;
1175
 
 
1176
 
    case GIMP_PDB_PASS_THROUGH:
1177
 
    case GIMP_PDB_CANCEL:   /*  should we do something here?  */
1178
 
      break;
1179
 
    }
1180
 
 
1181
 
  /*  free the proc name  */
1182
 
  g_free (proc_name);
1183
 
 
1184
 
  /*  free up the executed procedure return values  */
1185
 
  gimp_destroy_params (values, nvalues);
1186
 
 
1187
 
  /*  free up arguments and values  */
1188
 
  g_free (args);
1189
 
 
1190
 
  /*  free the query information  */
1191
 
  g_free (proc_blurb);
1192
 
  g_free (proc_help);
1193
 
  g_free (proc_author);
1194
 
  g_free (proc_copyright);
1195
 
  g_free (proc_date);
1196
 
  g_free (params);
1197
 
  g_free (return_vals);
1198
 
 
1199
 
  /*  reverse the return values  */
1200
 
  return_val = nreverse (return_val);
1201
 
 
1202
 
  /*  if we're in server mode, listen for additional commands for 10 ms  */
1203
 
  if (script_fu_server_get_mode ())
1204
 
    script_fu_server_listen (10);
1205
 
 
1206
 
#ifdef GDK_WINDOWING_WIN32
1207
 
  /* This seems to help a lot on Windoze. */
1208
 
  while (gtk_events_pending ())
1209
 
    gtk_main_iteration ();
1210
 
#endif
1211
 
 
1212
 
  return return_val;
1213
 
}
1214
 
 
1215
 
static LISP
1216
 
script_fu_register_call (LISP a)
1217
 
{
1218
 
  if (register_scripts)
1219
 
    return script_fu_add_script (a);
1220
 
  else
1221
 
    return NIL;
1222
 
}
1223
 
 
1224
 
static LISP
1225
 
script_fu_menu_register_call (LISP a)
1226
 
{
1227
 
  if (register_scripts)
1228
 
    return script_fu_add_menu (a);
1229
 
  else
1230
 
    return NIL;
1231
 
}
1232
 
 
1233
 
static LISP
1234
 
script_fu_quit_call (LISP a)
1235
 
{
1236
 
  script_fu_server_quit ();
1237
 
 
1238
 
  return NIL;
1239
 
}