? compile ? depcomp ? guile-gobject-uninstalled.pc ? guile-gobject.pc ? gnome/gobject/guile-gnome-gw-glib.c ? gnome/gobject/guile-gnome-gw-glib.h ? gnome/gobject/guile-gnome-gw-glib.html ? gnome/gobject/guile-gnome-gw-glib.log ? gnome/gobject/guile-gnome-gw-gobject.c ? gnome/gobject/guile-gnome-gw-gobject.h ? gnome/gobject/guile-gnome-gw-gobject.html ? gnome/gobject/guile-gnome-gw-standard.c ? gnome/gobject/guile-gnome-gw-standard.h ? gnome/gobject/guile-gnome-gw-standard.html ? gnome/gobject/gw-glib.scm ? gnome/gobject/gw-gobject.scm ? gnome/gobject/gw-standard.scm ? gnome/gtk/guile-gnome-gw-atk.c ? gnome/gtk/guile-gnome-gw-atk.h ? gnome/gtk/guile-gnome-gw-atk.html ? gnome/gtk/guile-gnome-gw-atk.log ? gnome/gtk/guile-gnome-gw-gdk.c ? gnome/gtk/guile-gnome-gw-gdk.h ? gnome/gtk/guile-gnome-gw-gdk.html ? gnome/gtk/guile-gnome-gw-gdk.log ? gnome/gtk/guile-gnome-gw-glib.log ? gnome/gtk/guile-gnome-gw-pango.c ? gnome/gtk/guile-gnome-gw-pango.h ? gnome/gtk/guile-gnome-gw-pango.html ? gnome/gtk/guile-gnome-gw-pango.log ? gnome/gtk/gw-atk.scm ? gnome/gtk/gw-gdk.scm ? gnome/gtk/gw-pango.scm Index: ChangeLog =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/ChangeLog,v retrieving revision 1.2 diff -u -p -u -r1.2 ChangeLog --- ChangeLog 25 Jun 2003 12:41:49 -0000 1.2 +++ ChangeLog 4 Aug 2003 12:01:18 -0000 @@ -1,3 +1,8 @@ +2003-08-02 Andreas Rottmann + + * h2def.py: Added --enums-without-gtype option, which will emit + the enum and flags defs without gtype-id. + 2003-05-30 Andy Wingo * gw-standard-spec.scm (, ): Index: h2def.py =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/h2def.py,v retrieving revision 1.1.1.1 diff -u -p -u -r1.1.1.1 h2def.py --- h2def.py 25 Jun 2003 12:30:28 -0000 1.1.1.1 +++ h2def.py 4 Aug 2003 12:01:19 -0000 @@ -186,7 +186,7 @@ def find_enum_defs(buf, enums=[]): pos = m.end() -def write_enum_defs(enums, output=None): +def write_enum_defs(enums, output=None, without_gtype=0): if type(output)==types.StringType: fp=open(output,'w') elif type(output)==types.FileType: @@ -210,7 +210,8 @@ def write_enum_defs(enums, output=None): if module: fp.write(' (in-module "' + module + '")\n') fp.write(' (c-name "' + cname + '")\n') - fp.write(' (gtype-id "' + typecode(cname) + '")\n') + if not without_gtype: + fp.write(' (gtype-id "' + typecode(cname) + '")\n') prefix = entries[0] for ent in entries: # shorten prefix til we get a match ... @@ -401,9 +402,11 @@ if __name__ == '__main__': onlyenums = 0 onlyobjdefs = 0 - + enums_without_gtype = 0 + opts, args = getopt.getopt(sys.argv[1:], 'v', - ['onlyenums', 'onlyobjdefs']) + ['onlyenums', 'onlyobjdefs', + 'enums-without-gtype']) for o, v in opts: if o == '-v': verbose = 1 @@ -411,7 +414,9 @@ if __name__ == '__main__': onlyenums = 1 if o == '--onlyobjdefs': onlyobjdefs = 1 - + if o == '--enums-without-gtype': + enums_without_gtype = 1 + if not args[0:1]: print 'Must specify at least one input file name' sys.exit(-1) @@ -425,12 +430,12 @@ if __name__ == '__main__': find_enum_defs(buf, enums) objdefs = sort_obj_defs(objdefs) if onlyenums: - write_enum_defs(enums,None) + write_enum_defs(enums,None, without_gtype = enums_without_gtype) elif onlyobjdefs: write_obj_defs(objdefs,None) else: write_obj_defs(objdefs,None) - write_enum_defs(enums,None) + write_enum_defs(enums,None, without_gtype = enums_without_gtype) for filename in args: write_def(filename,None) Index: gnome/defs/ChangeLog =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/gnome/defs/ChangeLog,v retrieving revision 1.2 diff -u -p -u -r1.2 ChangeLog --- gnome/defs/ChangeLog 25 Jun 2003 12:41:50 -0000 1.2 +++ gnome/defs/ChangeLog 4 Aug 2003 12:01:19 -0000 @@ -1,3 +1,15 @@ +2003-08-02 Andreas Rottmann + + * glib-override.defs: Removed some ignore-globs (*_ref, *_unref + and *_free), since g-wrap has no automatic reference-counting + or disposal of objects. + Ignore the GError-related functions, since the GError type is + exposed only via exceptions to the scheme level. + +2003-08-02 Andreas Rottmann + + * glib.defs: Added defs for giochannel.h and gfilutils.h. + 2003-05-25 Andy Wingo * gtk-overrides.defs: Ignore gtk_container_foreach -- to use this, Index: gnome/defs/glib-overrides.defs =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/gnome/defs/glib-overrides.defs,v retrieving revision 1.2 diff -u -p -u -r1.2 glib-overrides.defs --- gnome/defs/glib-overrides.defs 3 Jul 2003 15:16:02 -0000 1.2 +++ gnome/defs/glib-overrides.defs 4 Aug 2003 12:01:19 -0000 @@ -8,10 +8,7 @@ (parameters '("GMainLoop*" "loop"))) (ignore-glob "_*" - "*_ref" - "*_unref" "*_copy" - "*_free" "*_newv" "*_valist" "*_setv" @@ -22,9 +19,10 @@ "g_timeout_remove*" "g_idle_add*" "g_idle_remove*" + "g_error_*" "*win32*") (ignore "g_main_context_wait" - "g_error_new" - "g_set_error") + "g_set_error" + "g_clear_error") Index: gnome/defs/glib.defs =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/gnome/defs/glib.defs,v retrieving revision 1.2 diff -u -p -u -r1.2 glib.defs --- gnome/defs/glib.defs 1 Jul 2003 16:10:25 -0000 1.2 +++ gnome/defs/glib.defs 4 Aug 2003 12:01:19 -0000 @@ -560,4 +560,607 @@ ) ) +;; gfileutils.h [rotty] + +;; Enumerations and flags ... + +(define-enum FileError + (in-module "G") + (c-name "GFileError") + (values + '("exist" "G_FILE_ERROR_EXIST") + '("isdir" "G_FILE_ERROR_ISDIR") + '("acces" "G_FILE_ERROR_ACCES") + '("nametoolong" "G_FILE_ERROR_NAMETOOLONG") + '("noent" "G_FILE_ERROR_NOENT") + '("notdir" "G_FILE_ERROR_NOTDIR") + '("nxio" "G_FILE_ERROR_NXIO") + '("nodev" "G_FILE_ERROR_NODEV") + '("rofs" "G_FILE_ERROR_ROFS") + '("txtbsy" "G_FILE_ERROR_TXTBSY") + '("fault" "G_FILE_ERROR_FAULT") + '("loop" "G_FILE_ERROR_LOOP") + '("nospc" "G_FILE_ERROR_NOSPC") + '("nomem" "G_FILE_ERROR_NOMEM") + '("mfile" "G_FILE_ERROR_MFILE") + '("nfile" "G_FILE_ERROR_NFILE") + '("badf" "G_FILE_ERROR_BADF") + '("inval" "G_FILE_ERROR_INVAL") + '("pipe" "G_FILE_ERROR_PIPE") + '("again" "G_FILE_ERROR_AGAIN") + '("intr" "G_FILE_ERROR_INTR") + '("io" "G_FILE_ERROR_IO") + '("perm" "G_FILE_ERROR_PERM") + '("failed" "G_FILE_ERROR_FAILED") + ) +) + +(define-flags FileTest + (in-module "G") + (c-name "GFileTest") + (values + '("is-regular" "G_FILE_TEST_IS_REGULAR") + '("is-symlink" "G_FILE_TEST_IS_SYMLINK") + '("is-dir" "G_FILE_TEST_IS_DIR") + '("is-executable" "G_FILE_TEST_IS_EXECUTABLE") + '("exists" "G_FILE_TEST_EXISTS") + ) +) + + +;; From /usr/include/glib-2.0/glib/gfileutils.h + +; This one wasn't found by h2def.py +(define-function g_file_error_quark + (c-name "g_file_error_quark") + (return-type "GQuark") +) + +(define-function g_file_error_from_errno + (c-name "g_file_error_from_errno") + (return-type "GFileError") + (parameters + '("gint" "err_no") + ) +) + +(define-function g_file_test + (c-name "g_file_test") + (return-type "gboolean") + (parameters + '("const-gchar*" "filename") + '("GFileTest" "test") + ) +) + +(define-function g_file_get_contents + (c-name "g_file_get_contents") + (return-type "gboolean") + (parameters + '("const-gchar*" "filename") + '("gchar**" "contents") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-function g_mkstemp + (c-name "g_mkstemp") + (return-type "int") + (parameters + '("char*" "tmpl") + ) +) + +(define-function g_file_open_tmp + (c-name "g_file_open_tmp") + (return-type "int") + (parameters + '("const-char*" "tmpl") + '("char**" "name_used") + '("GError**" "error") + ) +) + +(define-function g_build_path + (c-name "g_build_path") + (return-type "gchar*") + (parameters + '("const-gchar*" "separator") + '("const-gchar*" "first_element") + ) + (varargs #t) +) + +(define-function g_build_filename + (c-name "g_build_filename") + (return-type "gchar*") + (parameters + '("const-gchar*" "first_element") + ) + (varargs #t) +) + + +;; giochannel.h [rotty] + +;; Enumerations and flags ... + +(define-enum IOError + (in-module "G") + (c-name "GIOError") + (values + '("none" "G_IO_ERROR_NONE") + '("again" "G_IO_ERROR_AGAIN") + '("inval" "G_IO_ERROR_INVAL") + '("unknown" "G_IO_ERROR_UNKNOWN") + ) +) + +(define-enum IOChannelError + (in-module "G") + (c-name "GIOChannelError") + (values + '("fbig" "G_IO_CHANNEL_ERROR_FBIG") + '("inval" "G_IO_CHANNEL_ERROR_INVAL") + '("io" "G_IO_CHANNEL_ERROR_IO") + '("isdir" "G_IO_CHANNEL_ERROR_ISDIR") + '("nospc" "G_IO_CHANNEL_ERROR_NOSPC") + '("nxio" "G_IO_CHANNEL_ERROR_NXIO") + '("overflow" "G_IO_CHANNEL_ERROR_OVERFLOW") + '("pipe" "G_IO_CHANNEL_ERROR_PIPE") + '("failed" "G_IO_CHANNEL_ERROR_FAILED") + ) +) + +(define-enum IOStatus + (in-module "G") + (c-name "GIOStatus") + (values + '("error" "G_IO_STATUS_ERROR") + '("normal" "G_IO_STATUS_NORMAL") + '("eof" "G_IO_STATUS_EOF") + '("again" "G_IO_STATUS_AGAIN") + ) +) + +(define-enum SeekType + (in-module "G") + (c-name "GSeekType") + (values + '("cur" "G_SEEK_CUR") + '("set" "G_SEEK_SET") + '("end" "G_SEEK_END") + ) +) + +(define-enum IOCondition + (in-module "G") + (c-name "GIOCondition") + (values + '("in" "G_IO_IN") + '("out" "G_IO_OUT") + '("pri" "G_IO_PRI") + '("err" "G_IO_ERR") + '("hup" "G_IO_HUP") + '("nval" "G_IO_NVAL") + ) +) + +(define-flags IOFlags + (in-module "G") + (c-name "GIOFlags") + (values + '("append" "G_IO_FLAG_APPEND") + '("nonblock" "G_IO_FLAG_NONBLOCK") + '("is-readable" "G_IO_FLAG_IS_READABLE") + '("is-writeable" "G_IO_FLAG_IS_WRITEABLE") + '("is-seekable" "G_IO_FLAG_IS_SEEKABLE") + '("mask" "G_IO_FLAG_MASK") + '("get-mask" "G_IO_FLAG_GET_MASK") + '("set-mask" "G_IO_FLAG_SET_MASK") + ) +) + + +;; From /usr/include/glib-2.0/glib/giochannel.h + +(define-method init + (of-object "GIOChannel") + (c-name "g_io_channel_init") + (return-type "none") +) + +(define-method ref + (of-object "GIOChannel") + (c-name "g_io_channel_ref") + (return-type "none") +) + +(define-method unref + (of-object "GIOChannel") + (c-name "g_io_channel_unref") + (return-type "none") +) + +(define-method read + (of-object "GIOChannel") + (c-name "g_io_channel_read") + (return-type "GIOError") + (parameters + '("gchar*" "buf") + '("gsize" "count") + '("gsize*" "bytes_read") + ) +) + +(define-method write + (of-object "GIOChannel") + (c-name "g_io_channel_write") + (return-type "GIOError") + (parameters + '("const-gchar*" "buf") + '("gsize" "count") + '("gsize*" "bytes_written") + ) +) + +(define-method seek + (of-object "GIOChannel") + (c-name "g_io_channel_seek") + (return-type "GIOError") + (parameters + '("gint64" "offset") + '("GSeekType" "type") + ) +) + +(define-method close + (of-object "GIOChannel") + (c-name "g_io_channel_close") + (return-type "none") +) + +(define-method shutdown + (of-object "GIOChannel") + (c-name "g_io_channel_shutdown") + (return-type "GIOStatus") + (parameters + '("gboolean" "flush") + '("GError**" "err") + ) +) + +(define-function g_io_add_watch_full + (c-name "g_io_add_watch_full") + (return-type "guint") + (parameters + '("GIOChannel*" "channel") + '("gint" "priority") + '("GIOCondition" "condition") + '("GIOFunc" "func") + '("gpointer" "user_data") + '("GDestroyNotify" "notify") + ) +) + +(define-function g_io_create_watch + (c-name "g_io_create_watch") + (return-type "GSource*") + (parameters + '("GIOChannel*" "channel") + '("GIOCondition" "condition") + ) +) + +(define-function g_io_add_watch + (c-name "g_io_add_watch") + (return-type "guint") + (parameters + '("GIOChannel*" "channel") + '("GIOCondition" "condition") + '("GIOFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method set_buffer_size + (of-object "GIOChannel") + (c-name "g_io_channel_set_buffer_size") + (return-type "none") + (parameters + '("gsize" "size") + ) +) + +(define-method get_buffer_size + (of-object "GIOChannel") + (c-name "g_io_channel_get_buffer_size") + (return-type "gsize") +) + +(define-method get_buffer_condition + (of-object "GIOChannel") + (c-name "g_io_channel_get_buffer_condition") + (return-type "GIOCondition") +) + +(define-method set_flags + (of-object "GIOChannel") + (c-name "g_io_channel_set_flags") + (return-type "GIOStatus") + (parameters + '("GIOFlags" "flags") + '("GError**" "error") + ) +) + +(define-method get_flags + (of-object "GIOChannel") + (c-name "g_io_channel_get_flags") + (return-type "GIOFlags") +) + +(define-method set_line_term + (of-object "GIOChannel") + (c-name "g_io_channel_set_line_term") + (return-type "none") + (parameters + '("const-gchar*" "line_term") + '("gint" "length") + ) +) + +(define-method get_line_term + (of-object "GIOChannel") + (c-name "g_io_channel_get_line_term") + (return-type "const-gchar*") + (parameters + '("gint*" "length") + ) +) + +(define-method set_buffered + (of-object "GIOChannel") + (c-name "g_io_channel_set_buffered") + (return-type "none") + (parameters + '("gboolean" "buffered") + ) +) + +(define-method get_buffered + (of-object "GIOChannel") + (c-name "g_io_channel_get_buffered") + (return-type "gboolean") +) + +(define-method set_encoding + (of-object "GIOChannel") + (c-name "g_io_channel_set_encoding") + (return-type "GIOStatus") + (parameters + '("const-gchar*" "encoding") + '("GError**" "error") + ) +) + +(define-method get_encoding + (of-object "GIOChannel") + (c-name "g_io_channel_get_encoding") + (return-type "const-gchar*") +) + +(define-method set_close_on_unref + (of-object "GIOChannel") + (c-name "g_io_channel_set_close_on_unref") + (return-type "none") + (parameters + '("gboolean" "do_close") + ) +) + +(define-method get_close_on_unref + (of-object "GIOChannel") + (c-name "g_io_channel_get_close_on_unref") + (return-type "gboolean") +) + +(define-method flush + (of-object "GIOChannel") + (c-name "g_io_channel_flush") + (return-type "GIOStatus") + (parameters + '("GError**" "error") + ) +) + +(define-method read_line + (of-object "GIOChannel") + (c-name "g_io_channel_read_line") + (return-type "GIOStatus") + (parameters + '("gchar**" "str_return") + '("gsize*" "length") + '("gsize*" "terminator_pos") + '("GError**" "error") + ) +) + +(define-method read_line_string + (of-object "GIOChannel") + (c-name "g_io_channel_read_line_string") + (return-type "GIOStatus") + (parameters + '("GString*" "buffer") + '("gsize*" "terminator_pos") + '("GError**" "error") + ) +) + +(define-method read_to_end + (of-object "GIOChannel") + (c-name "g_io_channel_read_to_end") + (return-type "GIOStatus") + (parameters + '("gchar**" "str_return") + '("gsize*" "length") + '("GError**" "error") + ) +) + +(define-method read_chars + (of-object "GIOChannel") + (c-name "g_io_channel_read_chars") + (return-type "GIOStatus") + (parameters + '("gchar*" "buf") + '("gsize" "count") + '("gsize*" "bytes_read") + '("GError**" "error") + ) +) + +(define-method read_unichar + (of-object "GIOChannel") + (c-name "g_io_channel_read_unichar") + (return-type "GIOStatus") + (parameters + '("gunichar*" "thechar") + '("GError**" "error") + ) +) + +(define-method write_chars + (of-object "GIOChannel") + (c-name "g_io_channel_write_chars") + (return-type "GIOStatus") + (parameters + '("const-gchar*" "buf") + '("gssize" "count") + '("gsize*" "bytes_written") + '("GError**" "error") + ) +) + +(define-method write_unichar + (of-object "GIOChannel") + (c-name "g_io_channel_write_unichar") + (return-type "GIOStatus") + (parameters + '("gunichar" "thechar") + '("GError**" "error") + ) +) + +(define-method seek_position + (of-object "GIOChannel") + (c-name "g_io_channel_seek_position") + (return-type "GIOStatus") + (parameters + '("gint64" "offset") + '("GSeekType" "type") + '("GError**" "error") + ) +) + +(define-function g_io_channel_new_file + (c-name "g_io_channel_new_file") + (return-type "GIOChannel*") + (parameters + '("const-gchar*" "filename") + '("const-gchar*" "mode") + '("GError**" "error") + ) +) + +(define-function g_io_channel_error_quark + (c-name "g_io_channel_error_quark") + (return-type "GQuark") +) + +(define-function g_io_channel_error_from_errno + (c-name "g_io_channel_error_from_errno") + (return-type "GIOChannelError") + (parameters + '("gint" "en") + ) +) + +(define-function g_io_channel_unix_new + (c-name "g_io_channel_unix_new") + (is-constructor-of "GIoChannelUnix") + (return-type "GIOChannel*") + (parameters + '("int" "fd") + ) +) + +(define-method unix_get_fd + (of-object "GIOChannel") + (c-name "g_io_channel_unix_get_fd") + (return-type "gint") +) + +(define-method win32_make_pollfd + (of-object "GIOChannel") + (c-name "g_io_channel_win32_make_pollfd") + (return-type "none") + (parameters + '("GIOCondition" "condition") + '("GPollFD*" "fd") + ) +) + +(define-function g_io_channel_win32_poll + (c-name "g_io_channel_win32_poll") + (return-type "gint") + (parameters + '("GPollFD*" "fds") + '("gint" "n_fds") + '("gint" "timeout_") + ) +) + +(define-function g_main_poll_win32_msg_add + (c-name "g_main_poll_win32_msg_add") + (return-type "none") + (parameters + '("gint" "priority") + '("GPollFD*" "fd") + '("guint" "hwnd") + ) +) + +(define-function g_io_channel_win32_new_messages + (c-name "g_io_channel_win32_new_messages") + (return-type "GIOChannel*") + (parameters + '("guint" "hwnd") + ) +) + +(define-function g_io_channel_win32_new_fd + (c-name "g_io_channel_win32_new_fd") + (return-type "GIOChannel*") + (parameters + '("gint" "fd") + ) +) + +(define-method win32_get_fd + (of-object "GIOChannel") + (c-name "g_io_channel_win32_get_fd") + (return-type "gint") +) + +(define-function g_io_channel_win32_new_socket + (c-name "g_io_channel_win32_new_socket") + (return-type "GIOChannel*") + (parameters + '("gint" "socket") + ) +) + + ;; (snip) Index: gnome/gobject/ChangeLog =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/gnome/gobject/ChangeLog,v retrieving revision 1.3 diff -u -p -u -r1.3 ChangeLog --- gnome/gobject/ChangeLog 1 Jul 2003 16:10:25 -0000 1.3 +++ gnome/gobject/ChangeLog 4 Aug 2003 12:01:20 -0000 @@ -1,3 +1,14 @@ +2003-08-04 Andreas Rottmann + + * gw-glib-spec.scm: Implemented GError wrapper. + +2003-08-02 Andreas Rottmann + + * defs-support.scm, gw-spec-utils.scm: Support for enums/flags + without gtype-id. + + * Makefile.am (GUILE_FLAGS): New variable. + 2003-06-21 Andy Wingo * gw-spec-utils.scm (gobject:gwrap-class): New function. Index: gnome/gobject/Makefile.am =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/gnome/gobject/Makefile.am,v retrieving revision 1.5 diff -u -p -u -r1.5 Makefile.am --- gnome/gobject/Makefile.am 23 Jul 2003 08:45:22 -0000 1.5 +++ gnome/gobject/Makefile.am 4 Aug 2003 12:01:20 -0000 @@ -112,6 +112,9 @@ SUFFIXES = .x .doc GUILE_SNARF_CFLAGS = $(DEFS) $(AM_CFLAGS) $(GUILE_CFLAGS) $(GOBJECT_CFLAGS) +# For overriding from the command line (e.g. --debug) +GUILE_FLAGS = + .c.x: guile-snarf $(GUILE_SNARF_CFLAGS) $< > $@ \ || { rm $@; false; } @@ -121,7 +124,7 @@ GUILE_SNARF_CFLAGS = $(DEFS) $(AM_CFLAGS guile_filter_doc_snarfage --filter-snarfage) > $@ || { rm $@; false; } gw-gobject.scm guile-gnome-gw-gobject.c guile-gnome-gw-gobject.h: gw-gobject-spec.scm - guile -c \ + guile $(GUILE_FLAGS) -c \ "(set! %load-path (cons \"${G_WRAP_MODULE_DIR}\" %load-path)) \ (set! %load-path (cons \"${top_srcdir}\" %load-path)) \ (primitive-load \"$(srcdir)/gw-gobject-spec.scm\") \ @@ -129,7 +132,7 @@ gw-gobject.scm guile-gnome-gw-gobject.c mv guile-gnome-gw-gobject.scm gw-gobject.scm gw-glib.scm guile-gnome-gw-glib.c guile-gnome-gw-glib.h: gw-glib-spec.scm - guile -c \ + guile $(GUILE_FLAGS) -c \ "(set! %load-path (cons \"${G_WRAP_MODULE_DIR}\" %load-path)) \ (set! %load-path (cons \"${top_srcdir}\" %load-path)) \ (primitive-load \"$(srcdir)/gw-glib-spec.scm\") \ Index: gnome/gobject/defs-support.scm =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/gnome/gobject/defs-support.scm,v retrieving revision 1.3 diff -u -p -u -r1.3 defs-support.scm --- gnome/gobject/defs-support.scm 1 Jul 2003 16:10:25 -0000 1.3 +++ gnome/gobject/defs-support.scm 4 Aug 2003 12:01:20 -0000 @@ -123,7 +123,10 @@ (lambda (gwrap-function args) (let* ((ctype #f) (gtype-id #f) - (wrapped-type #f)) + (wrapped-type #f) + (is-enum-or-flags (memv gwrap-function + (list gobject:gwrap-enum + gobject:gwrap-flags)))) (set! num-types (1+ num-types)) (for-each (lambda (arg) @@ -136,15 +139,27 @@ ((gtype-id) (set! gtype-id (cadr arg))) ((c-name) (set! ctype (cadr arg))))) args) - - (if (or (not gtype-id) (not ctype)) - (error "Type lacks a c-name or gtype-id:\n\n" args)) - - (set! wrapped-type (gwrap-function ws ctype gtype-id)) + + (if (not ctype) + (error "Type lacks a c-name:\n\n" args)) + + (if (and (not gtype-id) (not is-enum-or-flags)) + (error "Non-enum/flags-type lacks a gtype-id:\n\n" args)) + + (if (not gtype-id) + ;; Do the wrapping of enums/flags without a GType + (let ((values #f)) + (for-each + (lambda (arg) + (case (car arg) + ((values) (set! values (cdr arg))))) + args) + (set! wrapped-type (gwrap-function ws ctype gtype-id + values))) + (set! wrapped-type (gwrap-function ws ctype gtype-id))) + (register-type (gw:wrapset-get-name ws) - (if (memv gwrap-function (list - gobject:gwrap-flags - gobject:gwrap-enum)) + (if is-enum-or-flags ctype (string-append ctype "*")) (gw:type-get-name wrapped-type)) Index: gnome/gobject/gw-glib-spec.scm =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/gnome/gobject/gw-glib-spec.scm,v retrieving revision 1.4 diff -u -p -u -r1.4 gw-glib-spec.scm --- gnome/gobject/gw-glib-spec.scm 21 Jul 2003 15:42:23 -0000 1.4 +++ gnome/gobject/gw-glib-spec.scm 4 Aug 2003 12:01:20 -0000 @@ -494,9 +494,74 @@ glo) + ;; + (let* ((gerror (gw:wrap-type ws '))) + + (define (c-type-name-func typespec) + "GError *") + + (define (typespec-options-parser options-form wrapset) + (let ((remainder options-form)) + (set! remainder (delq 'caller-owned remainder)) + (if (null? remainder) + options-form + (throw 'gw:bad-typespec + "Bad options form - spurious options: " + remainder)))) + + (define (c-destructor c-var typespec status-var force?) + (list "g_clear_error(&" c-var ");\n")) + + (define (pre-call-arg-ccg param status-var) + (let* ((scm-name (gw:param-get-scm-name param)) + (c-name (gw:param-get-c-name param)) + (typespec (gw:param-get-typespec param))) + (list + c-name " = NULL;\n"))) + + (define (call-ccg result func-call-code status-var) + (list (gw:result-get-c-name result) " = " func-call-code ";\n")) + + (define (call-arg-ccg param) + (list "&" (gw:param-get-c-name param))) + + (define (post-call-arg-ccg param status-var) + (let* ((c-name (gw:param-get-c-name param)) + (scm-name (gw:param-get-scm-name param)) + (typespec (gw:param-get-typespec param))) + (list + "if (" c-name ") {\n" + " SCM scm_gerror = scm_list_3(scm_ulong2num(" c-name "->domain), scm_ulong2num(" c-name "->code), scm_makfrom0str(" c-name "->message));\n" + (c-destructor c-name typespec status-var #f) + " scm_throw(scm_str2symbol(\"g-error\"), scm_gerror);\n" + "}\n"))) + + (define (post-call-result-ccg result status-var) + (let* ((scm-name (gw:result-get-scm-name result)) + (c-name (gw:result-get-c-name result)) + (typespec (gw:result-get-typespec result))) + (list + (c->scm-ccg scm-name c-name typespec status-var) + (c-destructor c-name typespec status-var #f)))) + + (gw:type-set-c-type-name-func! gerror c-type-name-func) + (gw:type-set-typespec-options-parser! gerror typespec-options-parser) + + (gw:type-set-c-destructor! gerror c-destructor) + + (gw:type-set-pre-call-arg-ccg! gerror pre-call-arg-ccg) + (gw:type-set-call-arg-ccg! gerror call-arg-ccg) + (gw:type-set-call-ccg! gerror call-ccg) + (gw:type-set-post-call-arg-ccg! gerror post-call-arg-ccg) + (gw:type-set-post-call-result-ccg! gerror post-call-result-ccg) + (gw:type-set-param-visibility! gerror #f) + + gerror) + (register-type "guile-gnome-gw-glib" "GList*" 'glist-of) (register-type "guile-gnome-gw-glib" "GSList*" 'gslist-of) - + (register-type "guile-gnome-gw-glib" "GError**" ') + (load-defs ws "gnome/defs/glib.defs") ws) Index: gnome/gobject/gw-spec-utils.scm =================================================================== RCS file: /cvsroot/guile-gtk/guile-gobject/gnome/gobject/gw-spec-utils.scm,v retrieving revision 1.3 diff -u -p -u -r1.3 gw-spec-utils.scm --- gnome/gobject/gw-spec-utils.scm 1 Jul 2003 16:10:25 -0000 1.3 +++ gnome/gobject/gw-spec-utils.scm 4 Aug 2003 12:01:20 -0000 @@ -338,15 +338,32 @@ (define (c-destructor c-var typespec status-var force?) '()) - (format #f "Wrapping type ~A as a GFlags...\n" ctype) (gwrap-helper-with-class ws gtype-id ctype c-type-name-func scm->c-ccg c->scm-ccg c-destructor)) +(define (gw-wrap-flags ws ctype values) + (let* ((enum (gw:wrap-enumeration ws (string->symbol ctype) + ctype)) + (enum-c-sym + (gw:any-str->c-sym-str (symbol->string (gw:type-get-name enum)))) + (val-alist (map (lambda (l) + (cons (string->symbol (caadr l)) + (cadr (cadr l)))) + values))) + enum)) + + +(define (gobject:gwrap-flags ws ctype gtype-id . args) + (format #f "Wrapping type ~A as a GFlags...\n" ctype) + (if gtype-id + (gobject:wrap-flags ws ctype gtype-id) + (gw-wrap-flags ws ctype (car args)))) + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Wrap enums, just like flags. -(define (gobject:gwrap-enum ws ctype gtype-id) +(define (gobject:gwrap-enum ws ctype gtype-id . args) ;; enums are just guints... (define (c-type-name-func typespec) ctype) - + (define (scm->c-ccg c-var scm-var typespec status-var) (list "if (SCM_TYP16_PREDICATE (scm_tc16_gvalue, " scm-var ")\n" @@ -370,7 +387,19 @@ '()) (format #f "Wrapping type ~A as a GEnum...\n" ctype) - (gwrap-helper-with-class ws gtype-id ctype c-type-name-func scm->c-ccg c->scm-ccg c-destructor)) + (cond + (gtype-id + (gwrap-helper-with-class ws gtype-id ctype c-type-name-func scm->c-ccg c->scm-ccg c-destructor)) + (else + ;; Wrap enum without GType + (let ((values (car args)) + (enum (gw:wrap-enumeration ws (string->symbol ctype) ctype))) + (for-each + (lambda (l) + (gw:enum-add-value! enum (cadr (cadr l)) (string->symbol (caadr l)))) + values) + enum)))) + (define (gobject:gwrap-opaque-pointer ws ctype) (gw:wrap-as-wct ws (glib:type-cname->symbol ctype)