← 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/ftx/ftx.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/ftx/ftx.c
 
1
/* TinyScheme Extensions
 
2
 * (c) 2002 Visual Tools, S.A.
 
3
 * Manuel Heras-Gilsanz (manuel@heras-gilsanz.com)
 
4
 *
 
5
 * This software is subject to the terms stated in the
 
6
 * LICENSE file.
 
7
 */
 
8
 
 
9
#include "config.h"
 
10
 
 
11
#include <sys/stat.h>
 
12
#if HAVE_UNISTD_H
 
13
#include <unistd.h>
 
14
#endif
 
15
#include <time.h>
 
16
 
 
17
#include <glib.h>
 
18
 
 
19
#include "tinyscheme/scheme-private.h"
 
20
 
 
21
#undef cons
 
22
 
 
23
typedef enum
 
24
{
 
25
  FILE_TYPE_UNKNOWN = 0, FILE_TYPE_FILE, FILE_TYPE_DIR, FILE_TYPE_LINK
 
26
} FileType;
 
27
 
 
28
struct
 
29
named_constant {
 
30
    const char *name;
 
31
    FileType    value;
 
32
};
 
33
 
 
34
struct named_constant
 
35
file_type_constants[] = {
 
36
    { "FILE-TYPE-UNKNOWN", FILE_TYPE_UNKNOWN },
 
37
    { "FILE-TYPE-FILE",    FILE_TYPE_FILE },
 
38
    { "FILE-TYPE-DIR",     FILE_TYPE_DIR },
 
39
    { "FILE-TYPE-LINK",    FILE_TYPE_LINK },
 
40
    { NULL, 0 }
 
41
};
 
42
 
 
43
pointer foreign_fileexists(scheme *sc, pointer args);
 
44
pointer foreign_filetype(scheme *sc, pointer args);
 
45
pointer foreign_filesize(scheme *sc, pointer args);
 
46
pointer foreign_filedelete(scheme *sc, pointer args);
 
47
pointer foreign_diropenstream(scheme *sc, pointer args);
 
48
pointer foreign_dirreadentry(scheme *sc, pointer args);
 
49
pointer foreign_dirrewind(scheme *sc, pointer args);
 
50
pointer foreign_dirclosestream(scheme *sc, pointer args);
 
51
pointer foreign_time(scheme *sc, pointer args);
 
52
pointer foreign_gettimeofday(scheme *sc, pointer args);
 
53
pointer foreign_usleep(scheme *sc, pointer args);
 
54
void    init_ftx (scheme *sc);
 
55
 
 
56
 
 
57
pointer foreign_fileexists(scheme *sc, pointer args)
 
58
{
 
59
  pointer first_arg;
 
60
  char   *filename;
 
61
 
 
62
  if (args == sc->NIL)
 
63
    return sc->F;
 
64
 
 
65
  first_arg = sc->vptr->pair_car(args);
 
66
  if (!sc->vptr->is_string(first_arg))
 
67
    return sc->F;
 
68
 
 
69
  filename = sc->vptr->string_value(first_arg);
 
70
  filename = g_filename_from_utf8 (filename, -1, NULL, NULL, NULL);
 
71
  if (g_file_test(filename, G_FILE_TEST_EXISTS))
 
72
    return sc->T;
 
73
 
 
74
  return sc->F;
 
75
}
 
76
 
 
77
pointer foreign_filetype(scheme *sc, pointer args)
 
78
{
 
79
  pointer first_arg;
 
80
  char   *filename;
 
81
  int     retcode;
 
82
 
 
83
  if (args == sc->NIL)
 
84
    return sc->F;
 
85
 
 
86
  first_arg = sc->vptr->pair_car(args);
 
87
  if (!sc->vptr->is_string(first_arg))
 
88
    return sc->F;
 
89
 
 
90
  filename = sc->vptr->string_value(first_arg);
 
91
  filename = g_filename_from_utf8 (filename, -1, NULL, NULL, NULL);
 
92
 
 
93
  if (g_file_test(filename, G_FILE_TEST_IS_REGULAR))
 
94
    retcode = FILE_TYPE_FILE;
 
95
  else if (g_file_test(filename, G_FILE_TEST_IS_DIR))
 
96
    retcode = FILE_TYPE_DIR;
 
97
  else if (g_file_test(filename, G_FILE_TEST_IS_SYMLINK))
 
98
    retcode =  FILE_TYPE_LINK;
 
99
  else
 
100
    retcode = FILE_TYPE_UNKNOWN;
 
101
 
 
102
  return sc->vptr->mk_integer(sc, retcode);
 
103
}
 
104
 
 
105
pointer foreign_filesize(scheme *sc, pointer args)
 
106
{
 
107
  pointer first_arg;
 
108
  pointer ret;
 
109
  struct stat buf;
 
110
  char * filename;
 
111
  int retcode;
 
112
 
 
113
  if (args == sc->NIL)
 
114
    return sc->F;
 
115
 
 
116
  first_arg = sc->vptr->pair_car(args);
 
117
  if (!sc->vptr->is_string(first_arg))
 
118
    return sc->F;
 
119
 
 
120
  filename = sc->vptr->string_value(first_arg);
 
121
  filename = g_filename_from_utf8 (filename, -1, NULL, NULL, NULL);
 
122
  retcode = stat(filename, &buf);
 
123
  if (retcode == 0)
 
124
    ret = sc->vptr->mk_integer(sc,buf.st_size);
 
125
  else
 
126
    ret = sc->F;
 
127
  return ret;
 
128
}
 
129
 
 
130
pointer foreign_filedelete(scheme *sc, pointer args)
 
131
{
 
132
  pointer first_arg;
 
133
  pointer ret;
 
134
  char * filename;
 
135
  int retcode;
 
136
 
 
137
  if (args == sc->NIL)
 
138
    return sc->F;
 
139
 
 
140
  first_arg = sc->vptr->pair_car(args);
 
141
  if (!sc->vptr->is_string(first_arg)) {
 
142
    return sc->F;
 
143
  }
 
144
 
 
145
  filename = sc->vptr->string_value(first_arg);
 
146
  filename = g_filename_from_utf8 (filename, -1, NULL, NULL, NULL);
 
147
  retcode = unlink(filename);
 
148
  if (retcode == 0)
 
149
    ret = sc->T;
 
150
  else
 
151
    ret = sc->F;
 
152
  return ret;
 
153
}
 
154
 
 
155
pointer foreign_diropenstream(scheme *sc, pointer args)
 
156
{
 
157
  pointer first_arg;
 
158
  char   *dirpath;
 
159
  GDir   *dir;
 
160
 
 
161
  if (args == sc->NIL)
 
162
    return sc->F;
 
163
 
 
164
  first_arg = sc->vptr->pair_car(args);
 
165
  if (!sc->vptr->is_string(first_arg))
 
166
    return sc->F;
 
167
 
 
168
  dirpath = sc->vptr->string_value(first_arg);
 
169
  dirpath = g_filename_from_utf8 (dirpath, -1, NULL, NULL, NULL);
 
170
 
 
171
  dir = g_dir_open(dirpath, 0, NULL);
 
172
  if (dir == NULL)
 
173
    return sc->F;
 
174
 
 
175
  /* Stuffing a pointer in a long may not always be portable ~~~~~ */
 
176
  return (sc->vptr->mk_integer(sc, (long) dir));
 
177
}
 
178
 
 
179
pointer foreign_dirreadentry(scheme *sc, pointer args)
 
180
{
 
181
  pointer first_arg;
 
182
  GDir   *dir;
 
183
  gchar  *entry;
 
184
 
 
185
  if (args == sc->NIL)
 
186
    return sc->F;
 
187
 
 
188
  first_arg = sc->vptr->pair_car(args);
 
189
  if (!sc->vptr->is_integer(first_arg))
 
190
    return sc->F;
 
191
 
 
192
  dir = (GDir *) sc->vptr->ivalue(first_arg);
 
193
  if (dir == NULL)
 
194
    return sc->F;
 
195
 
 
196
  entry = (gchar *)g_dir_read_name(dir);
 
197
  if (entry == NULL)
 
198
    return sc->EOF_OBJ;
 
199
 
 
200
  entry = g_filename_to_utf8 (entry, -1, NULL, NULL, NULL);
 
201
  return (sc->vptr->mk_string(sc, entry));
 
202
}
 
203
 
 
204
pointer foreign_dirrewind(scheme *sc, pointer args)
 
205
{
 
206
  pointer first_arg;
 
207
  GDir   *dir;
 
208
 
 
209
  if (args == sc->NIL)
 
210
    return sc->F;
 
211
 
 
212
  first_arg = sc->vptr->pair_car(args);
 
213
  if (!sc->vptr->is_integer(first_arg))
 
214
    return sc->F;
 
215
 
 
216
  dir = (GDir *) sc->vptr->ivalue(first_arg);
 
217
  if (dir == NULL)
 
218
    return sc->F;
 
219
 
 
220
  g_dir_rewind(dir);
 
221
  return sc->T;
 
222
}
 
223
 
 
224
pointer foreign_dirclosestream(scheme *sc, pointer args)
 
225
{
 
226
  pointer first_arg;
 
227
  GDir   *dir;
 
228
 
 
229
  if (args == sc->NIL)
 
230
    return sc->F;
 
231
 
 
232
  first_arg = sc->vptr->pair_car(args);
 
233
  if (!sc->vptr->is_integer(first_arg))
 
234
    return sc->F;
 
235
 
 
236
  dir = (GDir *) sc->vptr->ivalue(first_arg);
 
237
  if (dir == NULL)
 
238
    return sc->F;
 
239
 
 
240
  g_dir_close(dir);
 
241
  return sc->T;
 
242
}
 
243
 
 
244
 
 
245
pointer foreign_time(scheme *sc, pointer args)
 
246
{
 
247
  time_t now;
 
248
  struct tm *now_tm;
 
249
  pointer ret;
 
250
 
 
251
  if (args != sc->NIL)
 
252
    return sc->F;
 
253
 
 
254
#if 1
 
255
  time(&now);
 
256
  now_tm = localtime(&now);
 
257
#else
 
258
GTime time;
 
259
GDate date;
 
260
 
 
261
  g_date_set_time(&date, &now);
 
262
  g_date_to_struct_tm(&now, &now_tm);
 
263
#endif
 
264
 
 
265
  ret = sc->vptr->cons(sc, sc->vptr->mk_integer(sc,(long) now_tm->tm_year),
 
266
         sc->vptr->cons(sc, sc->vptr->mk_integer(sc,(long) now_tm->tm_mon),
 
267
          sc->vptr->cons(sc, sc->vptr->mk_integer(sc,(long) now_tm->tm_mday),
 
268
           sc->vptr->cons(sc, sc->vptr->mk_integer(sc,(long) now_tm->tm_hour),
 
269
            sc->vptr->cons(sc, sc->vptr->mk_integer(sc,(long) now_tm->tm_min),
 
270
             sc->vptr->cons(sc, sc->vptr->mk_integer(sc,(long) now_tm->tm_sec),sc->NIL))))));
 
271
 
 
272
  return ret;
 
273
}
 
274
 
 
275
pointer foreign_gettimeofday(scheme *sc, pointer args)
 
276
{
 
277
  GTimeVal tv;
 
278
  pointer  ret;
 
279
 
 
280
  g_get_current_time(&tv);
 
281
 
 
282
  ret = sc->vptr->cons(sc, sc->vptr->mk_integer(sc,(long) tv.tv_sec),
 
283
         sc->vptr->cons(sc, sc->vptr->mk_integer(sc,(long) tv.tv_usec),
 
284
          sc->NIL));
 
285
 
 
286
  return ret;
 
287
}
 
288
 
 
289
pointer foreign_usleep(scheme *sc, pointer args)
 
290
{
 
291
  pointer first_arg;
 
292
  long usec;
 
293
 
 
294
  if (args == sc->NIL)
 
295
    return sc->F;
 
296
 
 
297
  first_arg = sc->vptr->pair_car(args);
 
298
  if (!sc->vptr->is_integer(first_arg))
 
299
    return sc->F;
 
300
 
 
301
  usec = sc->vptr->ivalue(first_arg);
 
302
  g_usleep(usec);
 
303
 
 
304
  return sc->T;
 
305
}
 
306
 
 
307
/* This function gets called when TinyScheme is loading the extension */
 
308
void init_ftx (scheme *sc)
 
309
{
 
310
  int i;
 
311
 
 
312
  sc->vptr->scheme_define(sc, sc->global_env,
 
313
                               sc->vptr->mk_symbol(sc,"time"),
 
314
                               sc->vptr->mk_foreign_func(sc, foreign_time));
 
315
  sc->vptr->scheme_define(sc, sc->global_env,
 
316
                               sc->vptr->mk_symbol(sc,"gettimeofday"),
 
317
                               sc->vptr->mk_foreign_func(sc, foreign_gettimeofday));
 
318
  sc->vptr->scheme_define(sc, sc->global_env,
 
319
                               sc->vptr->mk_symbol(sc,"usleep"),
 
320
                               sc->vptr->mk_foreign_func(sc, foreign_usleep));
 
321
 
 
322
  sc->vptr->scheme_define(sc, sc->global_env,
 
323
                               sc->vptr->mk_symbol(sc,"file-exists?"),
 
324
                               sc->vptr->mk_foreign_func(sc, foreign_fileexists));
 
325
  sc->vptr->scheme_define(sc, sc->global_env,
 
326
                               sc->vptr->mk_symbol(sc,"file-type"),
 
327
                               sc->vptr->mk_foreign_func(sc, foreign_filetype));
 
328
  sc->vptr->scheme_define(sc, sc->global_env,
 
329
                               sc->vptr->mk_symbol(sc,"file-size"),
 
330
                               sc->vptr->mk_foreign_func(sc, foreign_filesize));
 
331
  sc->vptr->scheme_define(sc, sc->global_env,
 
332
                               sc->vptr->mk_symbol(sc,"file-delete"),
 
333
                               sc->vptr->mk_foreign_func(sc, foreign_filedelete));
 
334
  sc->vptr->scheme_define(sc, sc->global_env,
 
335
                               sc->vptr->mk_symbol(sc,"dir-open-stream"),
 
336
                               sc->vptr->mk_foreign_func(sc, foreign_diropenstream));
 
337
  sc->vptr->scheme_define(sc, sc->global_env,
 
338
                               sc->vptr->mk_symbol(sc,"dir-read-entry"),
 
339
                               sc->vptr->mk_foreign_func(sc, foreign_dirreadentry));
 
340
  sc->vptr->scheme_define(sc, sc->global_env,
 
341
                               sc->vptr->mk_symbol(sc,"dir-rewind"),
 
342
                               sc->vptr->mk_foreign_func(sc, foreign_dirrewind));
 
343
  sc->vptr->scheme_define(sc, sc->global_env,
 
344
                               sc->vptr->mk_symbol(sc,"dir-close-stream"),
 
345
                               sc->vptr->mk_foreign_func(sc, foreign_dirclosestream));
 
346
 
 
347
  for (i = 0; file_type_constants[i].name != NULL; ++i)
 
348
  {
 
349
      sc->vptr->scheme_define(sc, sc->global_env,
 
350
            sc->vptr->mk_symbol(sc, file_type_constants[i].name),
 
351
            sc->vptr->mk_integer(sc, file_type_constants[i].value));
 
352
  }
 
353
}