glib2 0.20.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/ChangeLog +3023 -0
- data/README +28 -0
- data/Rakefile +87 -0
- data/extconf.rb +61 -0
- data/sample/bookmarkfile.rb +66 -0
- data/sample/completion.rb +45 -0
- data/sample/idle.rb +41 -0
- data/sample/iochannel.rb +44 -0
- data/sample/keyfile.rb +62 -0
- data/sample/shell.rb +36 -0
- data/sample/spawn.rb +25 -0
- data/sample/timeout.rb +28 -0
- data/sample/timeout2.rb +35 -0
- data/sample/timer.rb +40 -0
- data/sample/type-register.rb +103 -0
- data/sample/type-register2.rb +104 -0
- data/sample/utils.rb +54 -0
- data/src/glib-enum-types.c +1032 -0
- data/src/glib-enum-types.h +140 -0
- data/src/lib/glib-mkenums.rb +199 -0
- data/src/lib/glib2.rb +220 -0
- data/src/lib/mkmf-gnome2.rb +390 -0
- data/src/lib/pkg-config.rb +137 -0
- data/src/rbgcompat.h +30 -0
- data/src/rbglib.c +320 -0
- data/src/rbglib.h +96 -0
- data/src/rbglib_bookmarkfile.c +595 -0
- data/src/rbglib_completion.c +192 -0
- data/src/rbglib_convert.c +195 -0
- data/src/rbglib_error.c +95 -0
- data/src/rbglib_fileutils.c +83 -0
- data/src/rbglib_i18n.c +44 -0
- data/src/rbglib_int64.c +157 -0
- data/src/rbglib_iochannel.c +883 -0
- data/src/rbglib_keyfile.c +846 -0
- data/src/rbglib_maincontext.c +917 -0
- data/src/rbglib_mainloop.c +87 -0
- data/src/rbglib_messages.c +150 -0
- data/src/rbglib_pollfd.c +111 -0
- data/src/rbglib_shell.c +68 -0
- data/src/rbglib_source.c +190 -0
- data/src/rbglib_spawn.c +345 -0
- data/src/rbglib_threads.c +51 -0
- data/src/rbglib_timer.c +127 -0
- data/src/rbglib_unicode.c +611 -0
- data/src/rbglib_utils.c +386 -0
- data/src/rbglib_win32.c +136 -0
- data/src/rbgobj_boxed.c +251 -0
- data/src/rbgobj_closure.c +337 -0
- data/src/rbgobj_convert.c +167 -0
- data/src/rbgobj_enums.c +961 -0
- data/src/rbgobj_fundamental.c +30 -0
- data/src/rbgobj_object.c +892 -0
- data/src/rbgobj_param.c +390 -0
- data/src/rbgobj_paramspecs.c +305 -0
- data/src/rbgobj_signal.c +963 -0
- data/src/rbgobj_strv.c +61 -0
- data/src/rbgobj_type.c +851 -0
- data/src/rbgobj_typeinstance.c +121 -0
- data/src/rbgobj_typeinterface.c +148 -0
- data/src/rbgobj_typemodule.c +66 -0
- data/src/rbgobj_typeplugin.c +49 -0
- data/src/rbgobj_value.c +313 -0
- data/src/rbgobj_valuearray.c +59 -0
- data/src/rbgobj_valuetypes.c +298 -0
- data/src/rbgobject.c +406 -0
- data/src/rbgobject.h +265 -0
- data/src/rbgprivate.h +88 -0
- data/src/rbgutil.c +222 -0
- data/src/rbgutil.h +82 -0
- data/src/rbgutil_callback.c +231 -0
- data/test/glib-test-init.rb +6 -0
- data/test/glib-test-utils.rb +12 -0
- data/test/run-test.rb +25 -0
- data/test/test_enum.rb +99 -0
- data/test/test_file_utils.rb +15 -0
- data/test/test_glib2.rb +120 -0
- data/test/test_iochannel.rb +275 -0
- data/test/test_key_file.rb +38 -0
- data/test/test_mkenums.rb +25 -0
- data/test/test_signal.rb +20 -0
- data/test/test_timeout.rb +28 -0
- data/test/test_unicode.rb +369 -0
- data/test/test_utils.rb +37 -0
- data/test/test_win32.rb +13 -0
- metadata +165 -0
@@ -0,0 +1,83 @@
|
|
1
|
+
/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
|
2
|
+
/**********************************************************************
|
3
|
+
|
4
|
+
rbglib_fileutils.c -
|
5
|
+
|
6
|
+
$Author: mutoh $
|
7
|
+
$Date: 2004/09/17 15:09:07 $
|
8
|
+
|
9
|
+
Copyright (C) 2004 Masao Mutoh
|
10
|
+
|
11
|
+
**********************************************************************/
|
12
|
+
|
13
|
+
#include "rbgprivate.h"
|
14
|
+
#include "rbglib.h"
|
15
|
+
|
16
|
+
/* Use Ruby standard libraries.
|
17
|
+
enum GFileTest;
|
18
|
+
GFileError g_file_error_from_errno (gint err_no);
|
19
|
+
gboolean g_file_get_contents (const gchar *filename,
|
20
|
+
gchar **contents,
|
21
|
+
gsize *length,
|
22
|
+
GError **error);
|
23
|
+
gboolean g_file_test (const gchar *filename,
|
24
|
+
GFileTest test);
|
25
|
+
gint g_mkstemp (gchar *tmpl);
|
26
|
+
gint g_file_open_tmp (const gchar *tmpl,
|
27
|
+
gchar **name_used,
|
28
|
+
GError **error);
|
29
|
+
gchar* g_file_read_link (const gchar *filename,
|
30
|
+
GError **error);
|
31
|
+
|
32
|
+
struct GDir;
|
33
|
+
GDir* g_dir_open (const gchar *path,
|
34
|
+
guint flags,
|
35
|
+
GError **error);
|
36
|
+
G_CONST_RETURN gchar* g_dir_read_name (GDir *dir);
|
37
|
+
void g_dir_rewind (GDir *dir);
|
38
|
+
void g_dir_close (GDir *dir);
|
39
|
+
*/
|
40
|
+
|
41
|
+
#if GLIB_CHECK_VERSION(2, 16, 0)
|
42
|
+
static VALUE
|
43
|
+
rbglib_m_format_size_for_display(VALUE self, VALUE size)
|
44
|
+
{
|
45
|
+
return CSTR2RVAL_FREE(g_format_size_for_display(NUM2INT(size)));
|
46
|
+
}
|
47
|
+
#endif
|
48
|
+
|
49
|
+
void
|
50
|
+
Init_glib_fileutils()
|
51
|
+
{
|
52
|
+
VALUE cFileError = G_DEF_ERROR2(G_FILE_ERROR, "FileError", mGLib, rb_eIOError);
|
53
|
+
|
54
|
+
rb_define_const(cFileError, "EXIST", INT2NUM(G_FILE_ERROR_EXIST));
|
55
|
+
rb_define_const(cFileError, "ISDIR", INT2NUM(G_FILE_ERROR_ISDIR));
|
56
|
+
rb_define_const(cFileError, "ACCES", INT2NUM(G_FILE_ERROR_ACCES));
|
57
|
+
rb_define_const(cFileError, "NAMETOOLONG", INT2NUM(G_FILE_ERROR_NAMETOOLONG));
|
58
|
+
rb_define_const(cFileError, "NOENT", INT2NUM(G_FILE_ERROR_NOENT));
|
59
|
+
rb_define_const(cFileError, "NOTDIR", INT2NUM(G_FILE_ERROR_NOTDIR));
|
60
|
+
rb_define_const(cFileError, "NXIO", INT2NUM(G_FILE_ERROR_NXIO));
|
61
|
+
rb_define_const(cFileError, "NODEV", INT2NUM(G_FILE_ERROR_NODEV));
|
62
|
+
rb_define_const(cFileError, "ROFS", INT2NUM(G_FILE_ERROR_ROFS));
|
63
|
+
rb_define_const(cFileError, "TXTBSY", INT2NUM(G_FILE_ERROR_TXTBSY));
|
64
|
+
rb_define_const(cFileError, "FAULT", INT2NUM(G_FILE_ERROR_FAULT));
|
65
|
+
rb_define_const(cFileError, "LOOP", INT2NUM(G_FILE_ERROR_LOOP));
|
66
|
+
rb_define_const(cFileError, "NOSPC", INT2NUM(G_FILE_ERROR_NOSPC));
|
67
|
+
rb_define_const(cFileError, "NOMEM", INT2NUM(G_FILE_ERROR_NOMEM));
|
68
|
+
rb_define_const(cFileError, "MFILE", INT2NUM(G_FILE_ERROR_MFILE));
|
69
|
+
rb_define_const(cFileError, "NFILE", INT2NUM(G_FILE_ERROR_NFILE));
|
70
|
+
rb_define_const(cFileError, "BADF", INT2NUM(G_FILE_ERROR_BADF));
|
71
|
+
rb_define_const(cFileError, "INVAL", INT2NUM(G_FILE_ERROR_INVAL));
|
72
|
+
rb_define_const(cFileError, "PIPE", INT2NUM(G_FILE_ERROR_PIPE));
|
73
|
+
rb_define_const(cFileError, "AGAIN", INT2NUM(G_FILE_ERROR_AGAIN));
|
74
|
+
rb_define_const(cFileError, "INTR", INT2NUM(G_FILE_ERROR_INTR));
|
75
|
+
rb_define_const(cFileError, "IO", INT2NUM(G_FILE_ERROR_IO));
|
76
|
+
rb_define_const(cFileError, "PERM", INT2NUM(G_FILE_ERROR_PERM));
|
77
|
+
rb_define_const(cFileError, "FAILED", INT2NUM(G_FILE_ERROR_FAILED));
|
78
|
+
|
79
|
+
#if GLIB_CHECK_VERSION(2, 16, 0)
|
80
|
+
rb_define_module_function(mGLib, "format_size_for_display",
|
81
|
+
rbglib_m_format_size_for_display, 1);
|
82
|
+
#endif
|
83
|
+
}
|
data/src/rbglib_i18n.c
ADDED
@@ -0,0 +1,44 @@
|
|
1
|
+
/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
|
2
|
+
/**********************************************************************
|
3
|
+
|
4
|
+
rbglib_i18n.c -
|
5
|
+
|
6
|
+
$Author: ktou $
|
7
|
+
$Date: 2006/02/08 14:54:51 $
|
8
|
+
|
9
|
+
Copyright (C) 2006 Kouhei Sutou
|
10
|
+
|
11
|
+
**********************************************************************/
|
12
|
+
|
13
|
+
#include "rbgprivate.h"
|
14
|
+
#include "rbglib.h"
|
15
|
+
#undef _
|
16
|
+
#include <glib/gi18n.h>
|
17
|
+
|
18
|
+
#if GLIB_CHECK_VERSION(2,6,0)
|
19
|
+
static VALUE
|
20
|
+
rbglib_m_language_names(self)
|
21
|
+
VALUE self;
|
22
|
+
{
|
23
|
+
const gchar * const *languages;
|
24
|
+
const gchar *language;
|
25
|
+
VALUE rb_languages = rb_ary_new();
|
26
|
+
|
27
|
+
languages = g_get_language_names();
|
28
|
+
for (language = *languages; *languages; language = *(++languages)) {
|
29
|
+
rb_ary_push(rb_languages, CSTR2RVAL(language));
|
30
|
+
}
|
31
|
+
|
32
|
+
return rb_languages;
|
33
|
+
}
|
34
|
+
#endif
|
35
|
+
|
36
|
+
void
|
37
|
+
Init_glib_i18n()
|
38
|
+
{
|
39
|
+
/* glib/gi18n.h */
|
40
|
+
#if GLIB_CHECK_VERSION(2,6,0)
|
41
|
+
rb_define_module_function(mGLib, "language_names",
|
42
|
+
rbglib_m_language_names, 0);
|
43
|
+
#endif
|
44
|
+
}
|
data/src/rbglib_int64.c
ADDED
@@ -0,0 +1,157 @@
|
|
1
|
+
/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
|
2
|
+
/**********************************************************************
|
3
|
+
|
4
|
+
utils_int64.c -
|
5
|
+
|
6
|
+
$Author: isambart $
|
7
|
+
$Date: 2007/08/14 10:35:04 $
|
8
|
+
|
9
|
+
Copyright (C) 2003 Masahiro Sakai
|
10
|
+
Copyright (C) 2002 Masahiro Sakai
|
11
|
+
Kenichi Komiya
|
12
|
+
|
13
|
+
**********************************************************************/
|
14
|
+
|
15
|
+
#include <glib/gtypes.h>
|
16
|
+
#include "rbglib.h"
|
17
|
+
|
18
|
+
static ID id_and;
|
19
|
+
static ID id_rshift;
|
20
|
+
static ID id_lshift;
|
21
|
+
static ID id_lt;
|
22
|
+
static ID id_plus;
|
23
|
+
static ID id_uminus;
|
24
|
+
static ID id_abs;
|
25
|
+
static VALUE max_PRUint32;
|
26
|
+
|
27
|
+
typedef guint64 PRUint64;
|
28
|
+
typedef gint64 PRInt64;
|
29
|
+
|
30
|
+
#define LL_ZERO G_GINT64_CONSTANT(0)
|
31
|
+
#define LL_UI2L(lhs,rhs) ((lhs)=(rhs))
|
32
|
+
#define LL_L2UI(lhs,rhs) ((lhs)=(guint32)(rhs))
|
33
|
+
#define LL_SHL(lhs,v1,v2) ((lhs)=(v1)<<(v2))
|
34
|
+
#define LL_SHR(lhs,v1,v2) ((lhs)=(v1)>>(v2))
|
35
|
+
#define LL_ADD(lhs,v1,v2) ((lhs)=(v1)+(v2))
|
36
|
+
#define LL_NEG(lhs,rhs) ((lhs)=-(rhs))
|
37
|
+
#define LL_CMP(v1,op,v2) ((v1) op (v2))
|
38
|
+
|
39
|
+
/**********************************************************************/
|
40
|
+
/*
|
41
|
+
following is ripped from rbXPCOM-0.0.3
|
42
|
+
http://www.ruby-lang.org/en/raa-list.rhtml?name=rbXPCOM
|
43
|
+
Copyright (C) 2001 Kenichi Komiya <kom@mail1.accsnet.ne.jp>
|
44
|
+
*/
|
45
|
+
|
46
|
+
static PRUint64
|
47
|
+
RubyTo64BitInt(VALUE aRuby)
|
48
|
+
{
|
49
|
+
VALUE bitMask = max_PRUint32;
|
50
|
+
VALUE lo = rb_funcall(aRuby, id_and, 1, bitMask);
|
51
|
+
VALUE hi = rb_funcall(aRuby, id_rshift, 1, INT2FIX(32));
|
52
|
+
PRUint64 result, hi64, lo64;
|
53
|
+
LL_UI2L(hi64, NUM2UINT(hi));
|
54
|
+
LL_UI2L(lo64, NUM2UINT(lo));
|
55
|
+
LL_SHL(result, hi64, 32);
|
56
|
+
LL_ADD(result, result, lo64);
|
57
|
+
return result;
|
58
|
+
}
|
59
|
+
|
60
|
+
|
61
|
+
static inline PRUint64
|
62
|
+
RubyToPRUint64(VALUE aRuby)
|
63
|
+
{
|
64
|
+
return RubyTo64BitInt(aRuby);
|
65
|
+
}
|
66
|
+
|
67
|
+
|
68
|
+
static PRInt64
|
69
|
+
RubyToPRInt64(VALUE aRuby)
|
70
|
+
{
|
71
|
+
if(RVAL2CBOOL(rb_funcall(aRuby, id_lt, 1, INT2FIX(0))))
|
72
|
+
{
|
73
|
+
VALUE absRuby = rb_funcall(aRuby, id_abs, 0);
|
74
|
+
PRInt64 result;
|
75
|
+
LL_NEG(result, RubyTo64BitInt(absRuby));
|
76
|
+
return result;
|
77
|
+
} else
|
78
|
+
return (PRInt64)RubyTo64BitInt(aRuby);
|
79
|
+
|
80
|
+
}
|
81
|
+
|
82
|
+
static VALUE
|
83
|
+
RubyFrom64BitInt(PRUint64 aNative)
|
84
|
+
{
|
85
|
+
PRUint64 lo64, hi64;
|
86
|
+
LL_L2UI(lo64, aNative);
|
87
|
+
LL_SHR(hi64, aNative, 32);
|
88
|
+
{
|
89
|
+
VALUE lo = UINT2NUM(lo64);
|
90
|
+
VALUE hi = UINT2NUM(hi64);
|
91
|
+
VALUE hiRuby = rb_funcall(hi, id_lshift, 1, INT2FIX(32));
|
92
|
+
return rb_funcall(hiRuby, id_plus, 1, lo);
|
93
|
+
}
|
94
|
+
}
|
95
|
+
|
96
|
+
static inline VALUE
|
97
|
+
PRUint64ToRuby(PRUint64 aNative)
|
98
|
+
{
|
99
|
+
return RubyFrom64BitInt(aNative);
|
100
|
+
}
|
101
|
+
|
102
|
+
static VALUE
|
103
|
+
PRInt64ToRuby(PRInt64 aNative)
|
104
|
+
{
|
105
|
+
if(LL_CMP(aNative, <, LL_ZERO))
|
106
|
+
{
|
107
|
+
PRUint64 abs64;
|
108
|
+
LL_NEG(abs64, aNative);
|
109
|
+
return rb_funcall(RubyFrom64BitInt(abs64), id_uminus, 0);
|
110
|
+
}
|
111
|
+
else
|
112
|
+
return RubyFrom64BitInt((PRUint64)aNative);
|
113
|
+
}
|
114
|
+
|
115
|
+
/* end of ripping */
|
116
|
+
/**********************************************************************/
|
117
|
+
|
118
|
+
VALUE
|
119
|
+
rbglib_int64_to_num(guint64 val)
|
120
|
+
{
|
121
|
+
return PRInt64ToRuby(val);
|
122
|
+
}
|
123
|
+
|
124
|
+
VALUE
|
125
|
+
rbglib_uint64_to_num(guint64 val)
|
126
|
+
{
|
127
|
+
return PRUint64ToRuby(val);
|
128
|
+
}
|
129
|
+
|
130
|
+
gint64
|
131
|
+
rbglib_num_to_int64(VALUE val)
|
132
|
+
{
|
133
|
+
return RubyToPRInt64(val);
|
134
|
+
}
|
135
|
+
|
136
|
+
guint64
|
137
|
+
rbglib_num_to_uint64(VALUE val)
|
138
|
+
{
|
139
|
+
return RubyToPRUint64(val);
|
140
|
+
}
|
141
|
+
|
142
|
+
/**********************************************************************/
|
143
|
+
|
144
|
+
void
|
145
|
+
Init_glib_int64()
|
146
|
+
{
|
147
|
+
id_and = rb_intern("&");
|
148
|
+
id_rshift = rb_intern(">>");
|
149
|
+
id_lshift = rb_intern("<<");
|
150
|
+
id_lt = rb_intern("<");
|
151
|
+
id_plus = rb_intern("+");
|
152
|
+
id_uminus = rb_intern("-@");
|
153
|
+
id_abs = rb_intern("abs");
|
154
|
+
|
155
|
+
rb_global_variable(&max_PRUint32);
|
156
|
+
max_PRUint32 = UINT2NUM(0xffffffffL);
|
157
|
+
}
|
@@ -0,0 +1,883 @@
|
|
1
|
+
/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
|
2
|
+
/************************************************
|
3
|
+
|
4
|
+
rbglib_iochannel.c -
|
5
|
+
|
6
|
+
$Author: ggc $
|
7
|
+
$Date: 2007/07/13 16:07:28 $
|
8
|
+
|
9
|
+
Copyright (C) 2005 Masao Mutoh
|
10
|
+
************************************************/
|
11
|
+
|
12
|
+
#include "rbgprivate.h"
|
13
|
+
|
14
|
+
static ID id_call;
|
15
|
+
|
16
|
+
#define _SELF(s) ((GIOChannel*)RVAL2BOXED(s, G_TYPE_IO_CHANNEL))
|
17
|
+
|
18
|
+
static void
|
19
|
+
ioc_error(status, err)
|
20
|
+
GIOStatus status;
|
21
|
+
GError* err;
|
22
|
+
{
|
23
|
+
if (err != NULL) RAISE_GERROR(err);
|
24
|
+
|
25
|
+
if (status == G_IO_STATUS_EOF){
|
26
|
+
rb_raise(rb_eEOFError, "End of file reached");
|
27
|
+
} else if (status == G_IO_STATUS_AGAIN){
|
28
|
+
rb_raise(rb_eRuntimeError, "G_IO_STATUS_AGAIN");
|
29
|
+
} else if (status == G_IO_STATUS_NORMAL){
|
30
|
+
/* Do nothing */
|
31
|
+
} else {
|
32
|
+
rb_raise(rb_eRuntimeError, "An error occured. status = %d\n", status);
|
33
|
+
}
|
34
|
+
}
|
35
|
+
|
36
|
+
static VALUE
|
37
|
+
ioc_initialize(argc, argv, self)
|
38
|
+
gint argc;
|
39
|
+
VALUE* argv;
|
40
|
+
VALUE self;
|
41
|
+
{
|
42
|
+
VALUE arg1, arg2;
|
43
|
+
|
44
|
+
GIOChannel* io = NULL;
|
45
|
+
rb_secure(4);
|
46
|
+
rb_scan_args(argc, argv, "11", &arg1, &arg2);
|
47
|
+
|
48
|
+
if (TYPE(arg1) != T_STRING){
|
49
|
+
#ifdef G_OS_UNIX
|
50
|
+
if (TYPE(arg1) == T_FIXNUM){
|
51
|
+
io = g_io_channel_unix_new(NUM2INT(arg1));
|
52
|
+
} else {
|
53
|
+
io = g_io_channel_unix_new(NUM2INT(rb_funcall(arg1, rb_intern("to_i"), 0)));
|
54
|
+
}
|
55
|
+
#else
|
56
|
+
rb_raise(rb_eRuntimeError, "GLib::IOChannel.new(fd) is supported on UNIX environment only");
|
57
|
+
#endif
|
58
|
+
} else {
|
59
|
+
GError* err = NULL;
|
60
|
+
io = g_io_channel_new_file(RVAL2CSTR(arg1),
|
61
|
+
NIL_P(arg2) ? "r" : RVAL2CSTR(arg2), &err);
|
62
|
+
|
63
|
+
if (err != NULL) RAISE_GERROR(err);
|
64
|
+
}
|
65
|
+
|
66
|
+
G_INITIALIZE(self, io);
|
67
|
+
|
68
|
+
return Qnil;
|
69
|
+
}
|
70
|
+
|
71
|
+
static VALUE
|
72
|
+
ioc_close(self)
|
73
|
+
VALUE self;
|
74
|
+
{
|
75
|
+
GError* err = NULL;
|
76
|
+
GIOStatus status = g_io_channel_shutdown(_SELF(self), TRUE, &err);
|
77
|
+
|
78
|
+
ioc_error(status, err);
|
79
|
+
return self;
|
80
|
+
}
|
81
|
+
|
82
|
+
static VALUE
|
83
|
+
ioc_s_open(argc, argv, self)
|
84
|
+
gint argc;
|
85
|
+
VALUE* argv;
|
86
|
+
VALUE self;
|
87
|
+
{
|
88
|
+
VALUE arg1, arg2;
|
89
|
+
VALUE rio;
|
90
|
+
GIOChannel* io = NULL;
|
91
|
+
|
92
|
+
rb_scan_args(argc, argv, "11", &arg1, &arg2);
|
93
|
+
|
94
|
+
if (TYPE(arg1) == T_FIXNUM){
|
95
|
+
#ifdef G_OS_UNIX
|
96
|
+
io = g_io_channel_unix_new(NUM2INT(arg1));
|
97
|
+
#else
|
98
|
+
rb_raise(rb_eRuntimeError, "GLib::IOChannel.new(fd) is supported on UNIX environment only");
|
99
|
+
#endif
|
100
|
+
} else {
|
101
|
+
GError* err = NULL;
|
102
|
+
io = g_io_channel_new_file(RVAL2CSTR(arg1),
|
103
|
+
NIL_P(arg2) ? "r" : RVAL2CSTR(arg2), &err);
|
104
|
+
|
105
|
+
if (err != NULL) RAISE_GERROR(err);
|
106
|
+
}
|
107
|
+
|
108
|
+
rio = BOXED2RVAL(io, G_TYPE_IO_CHANNEL);
|
109
|
+
|
110
|
+
if (rb_block_given_p()) {
|
111
|
+
return rb_ensure(rb_yield, rio, ioc_close, rio);
|
112
|
+
}
|
113
|
+
return rio;
|
114
|
+
}
|
115
|
+
|
116
|
+
static VALUE
|
117
|
+
ioc_get_fd(self)
|
118
|
+
VALUE self;
|
119
|
+
{
|
120
|
+
#ifdef G_OS_UNIX
|
121
|
+
return INT2NUM(g_io_channel_unix_get_fd(_SELF(self)));
|
122
|
+
#else
|
123
|
+
rb_warn("GLib::IOChannel#fd is supported on UNIX environment only.");
|
124
|
+
return Qnil;
|
125
|
+
#endif
|
126
|
+
}
|
127
|
+
|
128
|
+
/* Don't need this
|
129
|
+
void g_io_channel_init (GIOChannel *channel);
|
130
|
+
*/
|
131
|
+
|
132
|
+
|
133
|
+
static VALUE
|
134
|
+
ioc_read_chars(argc, argv, self)
|
135
|
+
gint argc;
|
136
|
+
VALUE* argv;
|
137
|
+
VALUE self;
|
138
|
+
{
|
139
|
+
VALUE count, ret;
|
140
|
+
gchar* buf;
|
141
|
+
gsize bytes_read;
|
142
|
+
GError* err = NULL;
|
143
|
+
GIOStatus status;
|
144
|
+
|
145
|
+
rb_scan_args(argc, argv, "01", &count);
|
146
|
+
|
147
|
+
if (NIL_P(count)){
|
148
|
+
gsize length;
|
149
|
+
status = g_io_channel_read_to_end(_SELF(self), &buf,
|
150
|
+
&length, &err);
|
151
|
+
|
152
|
+
if (status == G_IO_STATUS_EOF){
|
153
|
+
ret = CSTR2RVAL("");
|
154
|
+
} else {
|
155
|
+
ioc_error(status, err);
|
156
|
+
}
|
157
|
+
ret = buf ? rb_str_new(buf, length) : CSTR2RVAL("");
|
158
|
+
g_free(buf);
|
159
|
+
} else {
|
160
|
+
buf = ALLOCA_N(gchar, count);
|
161
|
+
memset(buf, '\0', count);
|
162
|
+
|
163
|
+
status = g_io_channel_read_chars(_SELF(self), buf, NUM2UINT(count),
|
164
|
+
&bytes_read, &err);
|
165
|
+
if (status == G_IO_STATUS_EOF){
|
166
|
+
ret = CSTR2RVAL("");
|
167
|
+
} else {
|
168
|
+
ioc_error(status, err);
|
169
|
+
}
|
170
|
+
ret = buf ? CSTR2RVAL(buf) : CSTR2RVAL("");
|
171
|
+
}
|
172
|
+
return ret;
|
173
|
+
}
|
174
|
+
|
175
|
+
static VALUE
|
176
|
+
ioc_read_unichar(self)
|
177
|
+
VALUE self;
|
178
|
+
{
|
179
|
+
gunichar thechar;
|
180
|
+
GError* err = NULL;
|
181
|
+
GIOStatus status = g_io_channel_read_unichar(_SELF(self), &thechar, &err);
|
182
|
+
|
183
|
+
ioc_error(status, err);
|
184
|
+
|
185
|
+
return UINT2NUM(thechar);
|
186
|
+
}
|
187
|
+
|
188
|
+
static VALUE
|
189
|
+
ioc_getuc(self)
|
190
|
+
VALUE self;
|
191
|
+
{
|
192
|
+
gunichar thechar;
|
193
|
+
GError* err = NULL;
|
194
|
+
VALUE ret;
|
195
|
+
GIOStatus status = g_io_channel_read_unichar(_SELF(self), &thechar, &err);
|
196
|
+
|
197
|
+
if (status == G_IO_STATUS_EOF){
|
198
|
+
ret = Qnil;
|
199
|
+
} else {
|
200
|
+
ioc_error(status, err);
|
201
|
+
ret = UINT2NUM(thechar);
|
202
|
+
}
|
203
|
+
|
204
|
+
return ret;
|
205
|
+
}
|
206
|
+
|
207
|
+
static VALUE
|
208
|
+
ioc_each_char(self)
|
209
|
+
VALUE self;
|
210
|
+
{
|
211
|
+
if (!rb_block_given_p()) {
|
212
|
+
rb_raise(rb_eArgError, "called without a block");
|
213
|
+
}
|
214
|
+
|
215
|
+
while (TRUE){
|
216
|
+
gunichar thechar;
|
217
|
+
GError* err = NULL;
|
218
|
+
GIOStatus status = g_io_channel_read_unichar(_SELF(self), &thechar, &err);
|
219
|
+
if (status == G_IO_STATUS_EOF){
|
220
|
+
break;
|
221
|
+
} else {
|
222
|
+
ioc_error(status, err);
|
223
|
+
rb_yield(UINT2NUM(thechar));
|
224
|
+
}
|
225
|
+
}
|
226
|
+
return self;
|
227
|
+
}
|
228
|
+
|
229
|
+
static VALUE
|
230
|
+
ioc_read_line(argc, argv, self)
|
231
|
+
gint argc;
|
232
|
+
VALUE* argv;
|
233
|
+
VALUE self;
|
234
|
+
{
|
235
|
+
gchar* str;
|
236
|
+
VALUE line_term, ret;
|
237
|
+
GIOStatus status;
|
238
|
+
GError* err = NULL;
|
239
|
+
|
240
|
+
const gchar* old_line_term = NULL;
|
241
|
+
gint old_line_term_len;
|
242
|
+
|
243
|
+
rb_scan_args(argc, argv, "01", &line_term);
|
244
|
+
|
245
|
+
if (! NIL_P(line_term)){
|
246
|
+
StringValue(line_term);
|
247
|
+
old_line_term = g_io_channel_get_line_term(_SELF(self), &old_line_term_len);
|
248
|
+
|
249
|
+
g_io_channel_set_line_term(_SELF(self), RVAL2CSTR(line_term),
|
250
|
+
RSTRING_LEN(line_term));
|
251
|
+
}
|
252
|
+
|
253
|
+
status = g_io_channel_read_line(_SELF(self), &str, NULL, NULL, &err);
|
254
|
+
|
255
|
+
if (! NIL_P(line_term)){
|
256
|
+
g_io_channel_set_line_term(_SELF(self), old_line_term, old_line_term_len);
|
257
|
+
}
|
258
|
+
|
259
|
+
ioc_error(status, err);
|
260
|
+
|
261
|
+
ret = str ? CSTR2RVAL(str) : CSTR2RVAL("");
|
262
|
+
g_free(str);
|
263
|
+
|
264
|
+
return ret;
|
265
|
+
}
|
266
|
+
|
267
|
+
static VALUE
|
268
|
+
ioc_gets(argc, argv, self)
|
269
|
+
gint argc;
|
270
|
+
VALUE* argv;
|
271
|
+
VALUE self;
|
272
|
+
{
|
273
|
+
gchar* str;
|
274
|
+
VALUE line_term, ret;
|
275
|
+
GIOStatus status;
|
276
|
+
GError* err = NULL;
|
277
|
+
|
278
|
+
const gchar* old_line_term = NULL;
|
279
|
+
gint old_line_term_len;
|
280
|
+
|
281
|
+
rb_scan_args(argc, argv, "01", &line_term);
|
282
|
+
|
283
|
+
if (! NIL_P(line_term)){
|
284
|
+
StringValue(line_term);
|
285
|
+
|
286
|
+
old_line_term = g_io_channel_get_line_term(_SELF(self), &old_line_term_len);
|
287
|
+
g_io_channel_set_line_term(_SELF(self), RVAL2CSTR(line_term),
|
288
|
+
RSTRING_LEN(line_term));
|
289
|
+
}
|
290
|
+
|
291
|
+
status = g_io_channel_read_line(_SELF(self), &str, NULL, NULL, &err);
|
292
|
+
|
293
|
+
if (! NIL_P(line_term)){
|
294
|
+
g_io_channel_set_line_term(_SELF(self), old_line_term, old_line_term_len);
|
295
|
+
}
|
296
|
+
|
297
|
+
if (status == G_IO_STATUS_EOF){
|
298
|
+
ret = Qnil;
|
299
|
+
} else {
|
300
|
+
ioc_error(status, err);
|
301
|
+
ret = str ? CSTR2RVAL(str) : CSTR2RVAL("");
|
302
|
+
}
|
303
|
+
g_free(str);
|
304
|
+
|
305
|
+
return ret;
|
306
|
+
}
|
307
|
+
|
308
|
+
/* Internal use only */
|
309
|
+
static VALUE
|
310
|
+
ioc_set_line_term(args)
|
311
|
+
VALUE args;
|
312
|
+
{
|
313
|
+
VALUE self = RARRAY_PTR(args)[0];
|
314
|
+
VALUE doit = RARRAY_PTR(args)[1];
|
315
|
+
VALUE line_term = RARRAY_PTR(args)[2];
|
316
|
+
|
317
|
+
if (doit == Qtrue){
|
318
|
+
StringValue(line_term);
|
319
|
+
g_io_channel_set_line_term(_SELF(self), RVAL2CSTR(line_term),
|
320
|
+
RSTRING_LEN(line_term));
|
321
|
+
}
|
322
|
+
return self;
|
323
|
+
}
|
324
|
+
|
325
|
+
static VALUE
|
326
|
+
ioc_each_line(argc, argv, self)
|
327
|
+
gint argc;
|
328
|
+
VALUE* argv;
|
329
|
+
VALUE self;
|
330
|
+
{
|
331
|
+
gchar* str;
|
332
|
+
VALUE line_term;
|
333
|
+
GIOStatus status;
|
334
|
+
GError* err = NULL;
|
335
|
+
|
336
|
+
const gchar* old_line_term = NULL;
|
337
|
+
gint old_line_term_len;
|
338
|
+
|
339
|
+
if (!rb_block_given_p()) {
|
340
|
+
rb_raise(rb_eArgError, "called without a block");
|
341
|
+
}
|
342
|
+
|
343
|
+
rb_scan_args(argc, argv, "01", &line_term);
|
344
|
+
|
345
|
+
if (! NIL_P(line_term)){
|
346
|
+
StringValue(line_term);
|
347
|
+
|
348
|
+
old_line_term = g_io_channel_get_line_term(_SELF(self), &old_line_term_len);
|
349
|
+
g_io_channel_set_line_term(_SELF(self), RVAL2CSTR(line_term),
|
350
|
+
RSTRING_LEN(line_term));
|
351
|
+
}
|
352
|
+
|
353
|
+
while (TRUE){
|
354
|
+
status = g_io_channel_read_line(_SELF(self), &str, NULL, NULL, &err);
|
355
|
+
if (status == G_IO_STATUS_EOF){
|
356
|
+
break;
|
357
|
+
} else {
|
358
|
+
VALUE rstr;
|
359
|
+
ioc_error(status, err);
|
360
|
+
rstr = str ? CSTR2RVAL(str) : CSTR2RVAL("");
|
361
|
+
g_free(str);
|
362
|
+
rb_ensure(rb_yield, rstr, ioc_set_line_term,
|
363
|
+
rb_ary_new3(3, self,
|
364
|
+
NIL_P(line_term) ? Qfalse : Qtrue,
|
365
|
+
old_line_term ? rb_str_new(old_line_term, old_line_term_len) : Qnil));
|
366
|
+
}
|
367
|
+
}
|
368
|
+
return self;
|
369
|
+
}
|
370
|
+
|
371
|
+
|
372
|
+
/* Don't need this.
|
373
|
+
GIOStatus g_io_channel_read_line_string (GIOChannel *channel,
|
374
|
+
GString *buffer,
|
375
|
+
gsize *terminator_pos,
|
376
|
+
GError **error);
|
377
|
+
*/
|
378
|
+
|
379
|
+
/* Use GLib::IOChannel#read instead.
|
380
|
+
static VALUE
|
381
|
+
ioc_read_to_end(self)
|
382
|
+
VALUE self;
|
383
|
+
{
|
384
|
+
gchar* str;
|
385
|
+
gsize length;
|
386
|
+
VALUE ret;
|
387
|
+
GError* err = NULL;
|
388
|
+
|
389
|
+
GIOStatus status = g_io_channel_read_to_end(_SELF(self), &str,
|
390
|
+
&length, &err);
|
391
|
+
|
392
|
+
ioc_error(status, err);
|
393
|
+
|
394
|
+
ret = str ? rb_str_new(str, length) : CSTR2RVAL("");
|
395
|
+
g_free(str);
|
396
|
+
|
397
|
+
return ret;
|
398
|
+
}
|
399
|
+
*/
|
400
|
+
|
401
|
+
static VALUE
|
402
|
+
ioc_write_chars(self, buf)
|
403
|
+
VALUE self, buf;
|
404
|
+
{
|
405
|
+
gssize count;
|
406
|
+
gsize bytes_written;
|
407
|
+
GIOStatus status;
|
408
|
+
GError* err = NULL;
|
409
|
+
|
410
|
+
rb_secure(4);
|
411
|
+
buf = rb_obj_as_string(buf);
|
412
|
+
|
413
|
+
StringValue(buf);
|
414
|
+
|
415
|
+
count = RSTRING_LEN(buf);
|
416
|
+
|
417
|
+
status = g_io_channel_write_chars(_SELF(self), RVAL2CSTR(buf), count, &bytes_written, &err);
|
418
|
+
|
419
|
+
ioc_error(status, err);
|
420
|
+
return self;
|
421
|
+
}
|
422
|
+
|
423
|
+
static ID id_unpack;
|
424
|
+
|
425
|
+
static VALUE
|
426
|
+
ioc_write_unichar(self, thechar)
|
427
|
+
VALUE self, thechar;
|
428
|
+
{
|
429
|
+
GError* err = NULL;
|
430
|
+
GIOStatus status;
|
431
|
+
gunichar unichar;
|
432
|
+
|
433
|
+
rb_secure(4);
|
434
|
+
if (TYPE(thechar) == T_FIXNUM) {
|
435
|
+
unichar = NUM2UINT(thechar);
|
436
|
+
} else {
|
437
|
+
VALUE ary = rb_funcall(thechar, id_unpack, 1, CSTR2RVAL("U"));
|
438
|
+
unichar = NUM2UINT(RARRAY_PTR(ary)[0]);
|
439
|
+
}
|
440
|
+
|
441
|
+
status = g_io_channel_write_unichar(_SELF(self), unichar, &err);
|
442
|
+
|
443
|
+
ioc_error(status, err);
|
444
|
+
|
445
|
+
return self;
|
446
|
+
}
|
447
|
+
|
448
|
+
static VALUE
|
449
|
+
ioc_flush(self)
|
450
|
+
VALUE self;
|
451
|
+
{
|
452
|
+
GError* err = NULL;
|
453
|
+
GIOStatus status = g_io_channel_flush(_SELF(self), &err);
|
454
|
+
ioc_error(status, err);
|
455
|
+
return self;
|
456
|
+
}
|
457
|
+
|
458
|
+
static VALUE
|
459
|
+
ioc_seek(argc, argv, self)
|
460
|
+
gint argc;
|
461
|
+
VALUE* argv;
|
462
|
+
VALUE self;
|
463
|
+
{
|
464
|
+
VALUE ofs, type;
|
465
|
+
GIOStatus status;
|
466
|
+
GError* err = NULL;
|
467
|
+
GSeekType gtype = G_SEEK_SET;
|
468
|
+
|
469
|
+
rb_scan_args(argc, argv, "11", &ofs, &type);
|
470
|
+
|
471
|
+
if (!NIL_P(type))
|
472
|
+
gtype = NUM2INT(type);
|
473
|
+
|
474
|
+
status = g_io_channel_seek_position(_SELF(self), NUM2INT(ofs),
|
475
|
+
gtype, &err);
|
476
|
+
ioc_error(status, err);
|
477
|
+
return self;
|
478
|
+
}
|
479
|
+
|
480
|
+
static VALUE
|
481
|
+
ioc_seek_pos(self, pos)
|
482
|
+
VALUE self, pos;
|
483
|
+
{
|
484
|
+
GError* err = NULL;
|
485
|
+
GIOStatus status = g_io_channel_seek_position(_SELF(self), NUM2INT(pos),
|
486
|
+
G_SEEK_SET, &err);
|
487
|
+
ioc_error(status, err);
|
488
|
+
return self;
|
489
|
+
}
|
490
|
+
|
491
|
+
static VALUE
|
492
|
+
ioc_shutdown(argc, argv, self)
|
493
|
+
gint argc;
|
494
|
+
VALUE* argv;
|
495
|
+
VALUE self;
|
496
|
+
{
|
497
|
+
VALUE flush;
|
498
|
+
GError* err = NULL;
|
499
|
+
gboolean gflush = TRUE;
|
500
|
+
GIOStatus status;
|
501
|
+
|
502
|
+
rb_scan_args(argc, argv, "01", &flush);
|
503
|
+
|
504
|
+
if (!NIL_P(flush)){
|
505
|
+
gflush = RVAL2CBOOL(flush);
|
506
|
+
}
|
507
|
+
|
508
|
+
status = g_io_channel_shutdown(_SELF(self), gflush, &err);
|
509
|
+
ioc_error(status, err);
|
510
|
+
|
511
|
+
return self;
|
512
|
+
}
|
513
|
+
|
514
|
+
static VALUE
|
515
|
+
ioc_create_watch(self, condition)
|
516
|
+
VALUE self, condition;
|
517
|
+
{
|
518
|
+
return BOXED2RVAL(g_io_create_watch(_SELF(self), NUM2INT(condition)),
|
519
|
+
G_TYPE_SOURCE);
|
520
|
+
}
|
521
|
+
|
522
|
+
static gboolean
|
523
|
+
io_func(source, condition, func)
|
524
|
+
GIOChannel* source;
|
525
|
+
GIOCondition condition;
|
526
|
+
gpointer func;
|
527
|
+
{
|
528
|
+
return RVAL2CBOOL(rb_funcall((VALUE)func, id_call, 2,
|
529
|
+
BOXED2RVAL(source, G_TYPE_IO_CHANNEL),
|
530
|
+
INT2NUM(condition)));
|
531
|
+
}
|
532
|
+
|
533
|
+
static VALUE
|
534
|
+
ioc_add_watch(self, condition)
|
535
|
+
VALUE self, condition;
|
536
|
+
{
|
537
|
+
VALUE func = rb_block_proc();
|
538
|
+
G_RELATIVE(self, func);
|
539
|
+
return UINT2NUM(g_io_add_watch(_SELF(self), NUM2INT(condition),
|
540
|
+
(GIOFunc)io_func, (gpointer)func));
|
541
|
+
}
|
542
|
+
|
543
|
+
/* Don't need this
|
544
|
+
guint g_io_add_watch_full (GIOChannel *channel,
|
545
|
+
gint priority,
|
546
|
+
GIOCondition condition,
|
547
|
+
GIOFunc func,
|
548
|
+
gpointer user_data,
|
549
|
+
GDestroyNotify notify);
|
550
|
+
*/
|
551
|
+
|
552
|
+
static VALUE
|
553
|
+
ioc_get_buffer_size(self)
|
554
|
+
VALUE self;
|
555
|
+
{
|
556
|
+
return UINT2NUM(g_io_channel_get_buffer_size(_SELF(self)));
|
557
|
+
}
|
558
|
+
|
559
|
+
static VALUE
|
560
|
+
ioc_set_buffer_size(self, buffer_size)
|
561
|
+
VALUE self, buffer_size;
|
562
|
+
{
|
563
|
+
g_io_channel_set_buffer_size(_SELF(self), NUM2UINT(buffer_size));
|
564
|
+
return self;
|
565
|
+
}
|
566
|
+
|
567
|
+
static VALUE
|
568
|
+
ioc_get_buffer_condition(self)
|
569
|
+
VALUE self;
|
570
|
+
{
|
571
|
+
return INT2NUM(g_io_channel_get_buffer_condition(_SELF(self)));
|
572
|
+
}
|
573
|
+
|
574
|
+
static VALUE
|
575
|
+
ioc_get_flags(self)
|
576
|
+
VALUE self;
|
577
|
+
{
|
578
|
+
return INT2NUM(g_io_channel_get_flags(_SELF(self)));
|
579
|
+
}
|
580
|
+
|
581
|
+
static VALUE
|
582
|
+
ioc_set_flags(self, flags)
|
583
|
+
VALUE self, flags;
|
584
|
+
{
|
585
|
+
GError* err = NULL;
|
586
|
+
GIOStatus status = g_io_channel_set_flags(_SELF(self),
|
587
|
+
NUM2INT(flags), &err);
|
588
|
+
ioc_error(status, err);
|
589
|
+
return self;
|
590
|
+
}
|
591
|
+
|
592
|
+
/* Use them with GLib::IOChannel#gets, #readline, #readlines
|
593
|
+
static VALUE
|
594
|
+
ioc_get_line_term(self)
|
595
|
+
VALUE self;
|
596
|
+
{
|
597
|
+
gint length;
|
598
|
+
const gchar* ret = g_io_channel_get_line_term(_SELF(self), &length);
|
599
|
+
if (ret) {
|
600
|
+
if (length < 0) {
|
601
|
+
return CSTR2RVAL(ret);
|
602
|
+
} else {
|
603
|
+
return rb_str_new(ret, length);
|
604
|
+
}
|
605
|
+
}
|
606
|
+
return Qnil;
|
607
|
+
}
|
608
|
+
|
609
|
+
static VALUE
|
610
|
+
ioc_set_line_term(self, line_term)
|
611
|
+
VALUE self, line_term;
|
612
|
+
{
|
613
|
+
StringValue(line_term);
|
614
|
+
g_io_channel_set_line_term(_SELF(self), RVAL2CSTR(line_term),
|
615
|
+
RSTRING_LEN(line_term));
|
616
|
+
return self;
|
617
|
+
}
|
618
|
+
*/
|
619
|
+
|
620
|
+
static VALUE
|
621
|
+
ioc_get_buffered(self)
|
622
|
+
VALUE self;
|
623
|
+
{
|
624
|
+
return CBOOL2RVAL(g_io_channel_get_buffered(_SELF(self)));
|
625
|
+
}
|
626
|
+
|
627
|
+
static VALUE
|
628
|
+
ioc_set_buffered(self, buffered)
|
629
|
+
VALUE self, buffered;
|
630
|
+
{
|
631
|
+
g_io_channel_set_buffered(_SELF(self), RVAL2CBOOL(buffered));
|
632
|
+
return self;
|
633
|
+
}
|
634
|
+
|
635
|
+
static VALUE
|
636
|
+
ioc_get_encoding(self)
|
637
|
+
VALUE self;
|
638
|
+
{
|
639
|
+
return CSTR2RVAL(g_io_channel_get_encoding(_SELF(self)));
|
640
|
+
}
|
641
|
+
|
642
|
+
static VALUE
|
643
|
+
ioc_set_encoding(self, encoding)
|
644
|
+
VALUE self, encoding;
|
645
|
+
{
|
646
|
+
GError* err = NULL;
|
647
|
+
GIOStatus status = g_io_channel_set_encoding(_SELF(self),
|
648
|
+
encoding ? RVAL2CSTR(encoding) : NULL, &err);
|
649
|
+
ioc_error(status, err);
|
650
|
+
return self;
|
651
|
+
}
|
652
|
+
|
653
|
+
/* Don't we need them ?
|
654
|
+
gboolean g_io_channel_get_close_on_unref (GIOChannel *channel);
|
655
|
+
void g_io_channel_set_close_on_unref (GIOChannel *channel,
|
656
|
+
gboolean do_close);
|
657
|
+
*/
|
658
|
+
|
659
|
+
/* Deprecated
|
660
|
+
GIOError g_io_channel_read (GIOChannel *channel,
|
661
|
+
gchar *buf,
|
662
|
+
gsize count,
|
663
|
+
gsize *bytes_read);
|
664
|
+
enum GIOError;
|
665
|
+
GIOError g_io_channel_write (GIOChannel *channel,
|
666
|
+
const gchar *buf,
|
667
|
+
gsize count,
|
668
|
+
gsize *bytes_written);
|
669
|
+
GIOError g_io_channel_seek (GIOChannel *channel,
|
670
|
+
gint64 offset,
|
671
|
+
GSeekType type);
|
672
|
+
void g_io_channel_close (GIOChannel *channel);
|
673
|
+
*/
|
674
|
+
|
675
|
+
static VALUE
|
676
|
+
ioc_error_s_from_errno(self, errno_)
|
677
|
+
VALUE self, errno_;
|
678
|
+
{
|
679
|
+
return INT2NUM(g_io_channel_error_from_errno(NUM2INT(errno_)));
|
680
|
+
}
|
681
|
+
|
682
|
+
/*
|
683
|
+
* Stolen some convenient methods from io.c
|
684
|
+
*/
|
685
|
+
static VALUE
|
686
|
+
ioc_printf(argc, argv, self)
|
687
|
+
int argc;
|
688
|
+
VALUE* argv;
|
689
|
+
VALUE self;
|
690
|
+
{
|
691
|
+
ioc_write_chars(self, rb_f_sprintf(argc, argv));
|
692
|
+
return Qnil;
|
693
|
+
}
|
694
|
+
|
695
|
+
static VALUE ioc_puts(int argc, VALUE* argv, VALUE self);
|
696
|
+
|
697
|
+
static VALUE
|
698
|
+
ioc_puts_ary(ary, out, recur)
|
699
|
+
VALUE ary, out;
|
700
|
+
{
|
701
|
+
VALUE tmp;
|
702
|
+
long i;
|
703
|
+
|
704
|
+
for (i=0; i<RARRAY_LEN(ary); i++) {
|
705
|
+
tmp = RARRAY_PTR(ary)[i];
|
706
|
+
if (recur) {
|
707
|
+
tmp = rb_str_new2("[...]");
|
708
|
+
}
|
709
|
+
rb_io_puts(1, &tmp, out);
|
710
|
+
}
|
711
|
+
return Qnil;
|
712
|
+
}
|
713
|
+
|
714
|
+
static VALUE
|
715
|
+
ioc_puts(argc, argv, self)
|
716
|
+
int argc;
|
717
|
+
VALUE *argv;
|
718
|
+
VALUE self;
|
719
|
+
{
|
720
|
+
int i;
|
721
|
+
VALUE line;
|
722
|
+
|
723
|
+
/* if no argument given, print newline. */
|
724
|
+
if (argc == 0) {
|
725
|
+
ioc_write_chars(self, rb_default_rs);
|
726
|
+
return Qnil;
|
727
|
+
}
|
728
|
+
for (i=0; i<argc; i++) {
|
729
|
+
if (NIL_P(argv[i])) {
|
730
|
+
line = rb_str_new2("nil");
|
731
|
+
}
|
732
|
+
else {
|
733
|
+
#if HAVE_RB_CHECK_ARRAY_TYPE
|
734
|
+
line = rb_check_array_type(argv[i]);
|
735
|
+
#else
|
736
|
+
line = rb_check_convert_type(argv[i], T_ARRAY, "Array", "to_ary");
|
737
|
+
#endif
|
738
|
+
if (!NIL_P(line)) {
|
739
|
+
#if HAVE_RB_EXEC_RECURSIVE
|
740
|
+
rb_exec_recursive(ioc_puts_ary, line, self);
|
741
|
+
#else
|
742
|
+
rb_protect_inspect(ioc_puts_ary, line, self);
|
743
|
+
#endif
|
744
|
+
continue;
|
745
|
+
}
|
746
|
+
line = rb_obj_as_string(argv[i]);
|
747
|
+
}
|
748
|
+
ioc_write_chars(self, line);
|
749
|
+
if (RSTRING_LEN(line) == 0 ||
|
750
|
+
RSTRING_PTR(line)[RSTRING_LEN(line)-1] != '\n') {
|
751
|
+
ioc_write_chars(self, rb_default_rs);
|
752
|
+
}
|
753
|
+
}
|
754
|
+
|
755
|
+
return Qnil;
|
756
|
+
}
|
757
|
+
|
758
|
+
static VALUE
|
759
|
+
ioc_print(argc, argv, out)
|
760
|
+
int argc;
|
761
|
+
VALUE *argv;
|
762
|
+
VALUE out;
|
763
|
+
{
|
764
|
+
int i;
|
765
|
+
VALUE line;
|
766
|
+
|
767
|
+
/* if no argument given, print `$_' */
|
768
|
+
if (argc == 0) {
|
769
|
+
argc = 1;
|
770
|
+
line = rb_lastline_get();
|
771
|
+
argv = &line;
|
772
|
+
}
|
773
|
+
for (i=0; i<argc; i++) {
|
774
|
+
if (!NIL_P(rb_output_fs) && i>0) {
|
775
|
+
ioc_write_chars(out, rb_output_fs);
|
776
|
+
}
|
777
|
+
switch (TYPE(argv[i])) {
|
778
|
+
case T_NIL:
|
779
|
+
ioc_write_chars(out, rb_str_new2("nil"));
|
780
|
+
break;
|
781
|
+
default:
|
782
|
+
ioc_write_chars(out, argv[i]);
|
783
|
+
break;
|
784
|
+
}
|
785
|
+
}
|
786
|
+
if (!NIL_P(rb_output_rs)) {
|
787
|
+
ioc_write_chars(out, rb_output_rs);
|
788
|
+
}
|
789
|
+
|
790
|
+
return Qnil;
|
791
|
+
}
|
792
|
+
|
793
|
+
|
794
|
+
void
|
795
|
+
Init_glib_io_channel()
|
796
|
+
{
|
797
|
+
VALUE io = G_DEF_CLASS(G_TYPE_IO_CHANNEL, "IOChannel", mGLib);
|
798
|
+
VALUE ioc_error = G_DEF_ERROR2(G_IO_CHANNEL_ERROR, "IOChannelError", mGLib, rb_eIOError);
|
799
|
+
|
800
|
+
rb_include_module(io, rb_mEnumerable);
|
801
|
+
|
802
|
+
id_call = rb_intern("call");
|
803
|
+
id_unpack = rb_intern("unpack");
|
804
|
+
|
805
|
+
|
806
|
+
rb_define_method(io, "initialize", ioc_initialize, -1);
|
807
|
+
rb_define_singleton_method(io, "open", ioc_s_open, -1);
|
808
|
+
rb_define_method(io, "fileno", ioc_get_fd, 0); /* ref: IO#fileno */
|
809
|
+
rb_define_alias(io, "to_i", "fileno"); /* ref: IO#to_i */
|
810
|
+
rb_define_method(io, "read", ioc_read_chars, -1); /* ref: IO#read(count = nil) */
|
811
|
+
rb_define_method(io, "readchar", ioc_read_unichar, 0); /* ref: IO#readchar but this return an UTF-8 char */
|
812
|
+
rb_define_method(io, "getc", ioc_getuc, 0); /* ref: IO#getc but this return an UTF-8 char */
|
813
|
+
rb_define_method(io, "readline", ioc_read_line, -1); /* ref: IO#readline(rs = nil) */
|
814
|
+
rb_define_method(io, "gets", ioc_gets, -1); /* ref: IO#gets(rs = nil) */
|
815
|
+
rb_define_method(io, "each", ioc_each_line, -1); /* ref: IO#each(rs = nil){|line|...} */
|
816
|
+
rb_define_alias(io, "each_line", "each"); /* ref: IO#each_line(rs = nil){|line|...} */
|
817
|
+
rb_define_method(io, "each_char", ioc_each_char, 0); /* ref: IO#each_byte{|line|...} */
|
818
|
+
rb_define_method(io, "write", ioc_write_chars, 1); /* ref: IO#write(str) */
|
819
|
+
rb_define_method(io, "printf", ioc_printf, -1); /* ref: IO#printf(...) */
|
820
|
+
rb_define_method(io, "print", ioc_print, -1); /* ref: IO#print(...) */
|
821
|
+
rb_define_method(io, "puts", ioc_puts, -1); /* ref: IO#puts(...) */
|
822
|
+
rb_define_method(io, "putc", ioc_write_unichar, 1); /* ref: IO#putc(ch) but this accept an UTF-8 code */
|
823
|
+
rb_define_method(io, "flush", ioc_flush, 0); /* ref: IO#flush */
|
824
|
+
rb_define_method(io, "seek", ioc_seek, -1); /* ref: IO#seek */
|
825
|
+
rb_define_method(io, "set_pos", ioc_seek_pos, 1); /* ref: IO#pos= */
|
826
|
+
rb_define_method(io, "close", ioc_shutdown, -1); /* ref: IO#close */
|
827
|
+
rb_define_method(io, "create_watch", ioc_create_watch, 1);
|
828
|
+
rb_define_method(io, "add_watch", ioc_add_watch, 1);
|
829
|
+
rb_define_method(io, "buffer_size", ioc_get_buffer_size, 0);
|
830
|
+
rb_define_method(io, "set_buffer_size", ioc_set_buffer_size, 1);
|
831
|
+
rb_define_method(io, "buffer_condition", ioc_get_buffer_condition, 0);
|
832
|
+
rb_define_method(io, "flags", ioc_get_flags, 0);
|
833
|
+
rb_define_method(io, "set_flags", ioc_set_flags, 1);
|
834
|
+
rb_define_method(io, "buffered", ioc_get_buffered, 0);
|
835
|
+
rb_define_method(io, "set_buffered", ioc_set_buffered, 1);
|
836
|
+
rb_define_method(io, "encoding", ioc_get_encoding, 0);
|
837
|
+
rb_define_method(io, "set_encoding", ioc_set_encoding, 1);
|
838
|
+
|
839
|
+
G_DEF_SETTERS(io);
|
840
|
+
|
841
|
+
/* GSeekType */
|
842
|
+
rb_define_const(io, "SEEK_CUR", INT2NUM(G_SEEK_CUR));
|
843
|
+
rb_define_const(io, "SEEK_SET", INT2NUM(G_SEEK_SET));
|
844
|
+
rb_define_const(io, "SEEK_END", INT2NUM(G_SEEK_END));
|
845
|
+
|
846
|
+
/* GIOStatus */
|
847
|
+
rb_define_const(io, "STATUS_ERROR", INT2NUM(G_IO_STATUS_ERROR));
|
848
|
+
rb_define_const(io, "STATUS_NORMAL", INT2NUM(G_IO_STATUS_NORMAL));
|
849
|
+
rb_define_const(io, "STATUS_EOF", INT2NUM(G_IO_STATUS_EOF));
|
850
|
+
rb_define_const(io, "STATUS_AGAIN", INT2NUM(G_IO_STATUS_AGAIN));
|
851
|
+
|
852
|
+
/* GIOCondition */
|
853
|
+
rb_define_const(io, "IN", INT2NUM(G_IO_IN));
|
854
|
+
rb_define_const(io, "OUT", INT2NUM(G_IO_OUT));
|
855
|
+
rb_define_const(io, "PRI", INT2NUM(G_IO_PRI));
|
856
|
+
rb_define_const(io, "ERR", INT2NUM(G_IO_ERR));
|
857
|
+
rb_define_const(io, "HUP", INT2NUM(G_IO_HUP));
|
858
|
+
rb_define_const(io, "NVAL", INT2NUM(G_IO_NVAL));
|
859
|
+
|
860
|
+
/* GIOFlags */
|
861
|
+
rb_define_const(io, "FLAG_APPEND", INT2NUM(G_IO_FLAG_APPEND));
|
862
|
+
rb_define_const(io, "FLAG_NONBLOCK", INT2NUM(G_IO_FLAG_NONBLOCK));
|
863
|
+
rb_define_const(io, "FLAG_READABLE", INT2NUM(G_IO_FLAG_IS_READABLE));
|
864
|
+
rb_define_const(io, "FLAG_WRITEABLE", INT2NUM(G_IO_FLAG_IS_WRITEABLE));
|
865
|
+
rb_define_const(io, "FLAG_IS_SEEKABLE", INT2NUM(G_IO_FLAG_IS_SEEKABLE));
|
866
|
+
rb_define_const(io, "FLAG_MASK", INT2NUM(G_IO_FLAG_MASK));
|
867
|
+
rb_define_const(io, "FLAG_GET_MASK", INT2NUM(G_IO_FLAG_GET_MASK));
|
868
|
+
rb_define_const(io, "FLAG_SET_MASK", INT2NUM(G_IO_FLAG_SET_MASK));
|
869
|
+
|
870
|
+
/* GIOChannelError */
|
871
|
+
rb_define_singleton_method(ioc_error, "from_errno", ioc_error_s_from_errno, 1);
|
872
|
+
|
873
|
+
rb_define_const(ioc_error, "FBIG", INT2NUM(G_IO_CHANNEL_ERROR_FBIG));
|
874
|
+
rb_define_const(ioc_error, "INVAL", INT2NUM(G_IO_CHANNEL_ERROR_INVAL));
|
875
|
+
rb_define_const(ioc_error, "IO", INT2NUM(G_IO_CHANNEL_ERROR_IO));
|
876
|
+
rb_define_const(ioc_error, "ISDIR", INT2NUM(G_IO_CHANNEL_ERROR_ISDIR));
|
877
|
+
rb_define_const(ioc_error, "NOSPC", INT2NUM(G_IO_CHANNEL_ERROR_NOSPC));
|
878
|
+
rb_define_const(ioc_error, "NXIO", INT2NUM(G_IO_CHANNEL_ERROR_NXIO));
|
879
|
+
rb_define_const(ioc_error, "OVERFLOW", INT2NUM(G_IO_CHANNEL_ERROR_OVERFLOW));
|
880
|
+
rb_define_const(ioc_error, "PIPE", INT2NUM(G_IO_CHANNEL_ERROR_PIPE));
|
881
|
+
rb_define_const(ioc_error, "FAILED", INT2NUM(G_IO_CHANNEL_ERROR_FAILED));
|
882
|
+
|
883
|
+
}
|