ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.xs
(Generate patch)

Comparing EV/EV.xs (file contents):
Revision 1.97 by root, Fri Dec 21 04:41:12 2007 UTC vs.
Revision 1.101 by root, Sat Dec 22 05:47:51 2007 UTC

… …
3#include "XSUB.h" 3#include "XSUB.h"
4 4
5/*#include <netinet/in.h>*/ 5/*#include <netinet/in.h>*/
6 6
7#define EV_PROTOTYPES 1 7#define EV_PROTOTYPES 1
8#define EV_USE_NANOSLEEP EV_USE_MONOTONIC
8#define EV_H <ev.h> 9#define EV_H <ev.h>
9#include "EV/EVAPI.h" 10#include "EV/EVAPI.h"
10 11
11/* fix perl api breakage */ 12/* fix perl api breakage */
12#undef signal 13#undef signal
… …
388 evapi.sv_signum = sv_signum; 389 evapi.sv_signum = sv_signum;
389 evapi.supported_backends = ev_supported_backends (); 390 evapi.supported_backends = ev_supported_backends ();
390 evapi.recommended_backends = ev_recommended_backends (); 391 evapi.recommended_backends = ev_recommended_backends ();
391 evapi.embeddable_backends = ev_embeddable_backends (); 392 evapi.embeddable_backends = ev_embeddable_backends ();
392 evapi.time = ev_time; 393 evapi.time = ev_time;
394 evapi.sleep = ev_sleep;
393 evapi.loop_new = ev_loop_new; 395 evapi.loop_new = ev_loop_new;
394 evapi.loop_destroy = ev_loop_destroy; 396 evapi.loop_destroy = ev_loop_destroy;
395 evapi.loop_fork = ev_loop_fork; 397 evapi.loop_fork = ev_loop_fork;
396 evapi.loop_count = ev_loop_count; 398 evapi.loop_count = ev_loop_count;
397 evapi.now = ev_now; 399 evapi.now = ev_now;
… …
464 C_ARGS: evapi.default_loop 466 C_ARGS: evapi.default_loop
465 467
466unsigned int ev_loop_count () 468unsigned int ev_loop_count ()
467 C_ARGS: evapi.default_loop 469 C_ARGS: evapi.default_loop
468 470
471void ev_set_io_collect_interval (NV interval)
472 C_ARGS: evapi.default_loop, interval
473
474void ev_set_timeout_collect_interval (NV interval)
475 C_ARGS: evapi.default_loop, interval
476
469void ev_loop (int flags = 0) 477void ev_loop (int flags = 0)
470 C_ARGS: evapi.default_loop, flags 478 C_ARGS: evapi.default_loop, flags
471 479
472void ev_unloop (int how = 1) 480void ev_unloop (int how = 1)
473 C_ARGS: evapi.default_loop, how 481 C_ARGS: evapi.default_loop, how
… …
687 { 695 {
688 SvREFCNT_dec (w->data); 696 SvREFCNT_dec (w->data);
689 w->data = newSVsv (new_data); 697 w->data = newSVsv (new_data);
690 } 698 }
691} 699}
700 OUTPUT:
701 RETVAL
702
703SV *loop (ev_watcher *w)
704 CODE:
705 RETVAL = newRV_inc (w->loop);
692 OUTPUT: 706 OUTPUT:
693 RETVAL 707 RETVAL
694 708
695int priority (ev_watcher *w, int new_priority = 0) 709int priority (ev_watcher *w, int new_priority = 0)
696 CODE: 710 CODE:
… …
909void DESTROY (ev_idle *w) 923void DESTROY (ev_idle *w)
910 CODE: 924 CODE:
911 STOP (idle, w); 925 STOP (idle, w);
912 e_destroy (w); 926 e_destroy (w);
913 927
914MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_check_ 928MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_prepare_
915 929
916void ev_prepare_start (ev_prepare *w) 930void ev_prepare_start (ev_prepare *w)
917 CODE: 931 CODE:
918 START (prepare, w); 932 START (prepare, w);
919 933
… …
1115 CODE: 1129 CODE:
1116 RETVAL = newSVsv (w->fh); 1130 RETVAL = newSVsv (w->fh);
1117 OUTPUT: 1131 OUTPUT:
1118 RETVAL 1132 RETVAL
1119 1133
1120MODULE = EV PACKAGE = EV::Loop PREFIX = ev_loop_ 1134MODULE = EV PACKAGE = EV::Loop PREFIX = ev_
1121 1135
1122SV *new (SV *klass, unsigned int flags = 0) 1136SV *new (SV *klass, unsigned int flags = 0)
1123 CODE: 1137 CODE:
1124{ 1138{
1125 struct ev_loop *loop = ev_loop_new (flags); 1139 struct ev_loop *loop = ev_loop_new (flags);
… …
1134 1148
1135void DESTROY (struct ev_loop *loop) 1149void DESTROY (struct ev_loop *loop)
1136 CODE: 1150 CODE:
1137 if (loop != evapi.default_loop) /* global destruction sucks */ 1151 if (loop != evapi.default_loop) /* global destruction sucks */
1138 ev_loop_destroy (loop); 1152 ev_loop_destroy (loop);
1153
1154void ev_loop_fork (struct ev_loop *loop)
1155
1156NV ev_now (struct ev_loop *loop)
1157
1158void ev_set_io_collect_interval (struct ev_loop *loop, NV interval)
1159
1160void ev_set_timeout_collect_interval (struct ev_loop *loop, NV interval)
1161
1162unsigned int ev_backend (struct ev_loop *loop)
1163
1164unsigned int ev_loop_count (struct ev_loop *loop)
1165
1166void ev_loop (struct ev_loop *loop, int flags = 0)
1167
1168void ev_unloop (struct ev_loop *loop, int how = 1)
1169
1170void ev_feed_fd_event (struct ev_loop *loop, int fd, int revents = EV_NONE)
1171
1172#if 0
1173
1174void ev_feed_signal_event (struct ev_loop *loop, SV *signal)
1175 CODE:
1176{
1177 Signal signum = sv_signum (signal);
1178 CHECK_SIG (signal, signum);
1179
1180 ev_feed_signal_event (loop, signum);
1181}
1182
1183#endif
1139 1184
1140ev_io *io (struct ev_loop *loop, SV *fh, int events, SV *cb) 1185ev_io *io (struct ev_loop *loop, SV *fh, int events, SV *cb)
1141 ALIAS: 1186 ALIAS:
1142 io_ns = 1 1187 io_ns = 1
1143 CODE: 1188 CODE:
… …
1151 if (!ix) START (io, RETVAL); 1196 if (!ix) START (io, RETVAL);
1152} 1197}
1153 OUTPUT: 1198 OUTPUT:
1154 RETVAL 1199 RETVAL
1155 1200
1201ev_timer *timer (struct ev_loop *loop, NV after, NV repeat, SV *cb)
1202 ALIAS:
1203 timer_ns = 1
1204 INIT:
1205 CHECK_REPEAT (repeat);
1206 CODE:
1207 RETVAL = e_new (sizeof (ev_timer), cb, ST (0));
1208 ev_timer_set (RETVAL, after, repeat);
1209 if (!ix) START (timer, RETVAL);
1210 OUTPUT:
1211 RETVAL
1212
1213SV *periodic (struct ev_loop *loop, NV at, NV interval, SV *reschedule_cb, SV *cb)
1214 ALIAS:
1215 periodic_ns = 1
1216 INIT:
1217 CHECK_REPEAT (interval);
1218 CODE:
1219{
1220 ev_periodic *w;
1221 w = e_new (sizeof (ev_periodic), cb, ST (0));
1222 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
1223 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0);
1224 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
1225 if (!ix) START (periodic, w);
1226}
1227 OUTPUT:
1228 RETVAL
1229
1230#if 0
1231
1232ev_signal *signal (struct ev_loop *loop, SV *signal, SV *cb)
1233 ALIAS:
1234 signal_ns = 1
1235 CODE:
1236{
1237 Signal signum = sv_signum (signal);
1238 CHECK_SIG (signal, signum);
1239
1240 RETVAL = e_new (sizeof (ev_signal), cb, ST (0));
1241 ev_signal_set (RETVAL, signum);
1242 if (!ix) START (signal, RETVAL);
1243}
1244 OUTPUT:
1245 RETVAL
1246
1247#endif
1248
1249ev_idle *idle (struct ev_loop *loop, SV *cb)
1250 ALIAS:
1251 idle_ns = 1
1252 CODE:
1253 RETVAL = e_new (sizeof (ev_idle), cb, ST (0));
1254 ev_idle_set (RETVAL);
1255 if (!ix) START (idle, RETVAL);
1256 OUTPUT:
1257 RETVAL
1258
1259ev_prepare *prepare (struct ev_loop *loop, SV *cb)
1260 ALIAS:
1261 prepare_ns = 1
1262 CODE:
1263 RETVAL = e_new (sizeof (ev_prepare), cb, ST (0));
1264 ev_prepare_set (RETVAL);
1265 if (!ix) START (prepare, RETVAL);
1266 OUTPUT:
1267 RETVAL
1268
1269ev_check *check (struct ev_loop *loop, SV *cb)
1270 ALIAS:
1271 check_ns = 1
1272 CODE:
1273 RETVAL = e_new (sizeof (ev_check), cb, ST (0));
1274 ev_check_set (RETVAL);
1275 if (!ix) START (check, RETVAL);
1276 OUTPUT:
1277 RETVAL
1278
1279ev_fork *fork (struct ev_loop *loop, SV *cb)
1280 ALIAS:
1281 fork_ns = 1
1282 CODE:
1283 RETVAL = e_new (sizeof (ev_fork), cb, ST (0));
1284 ev_fork_set (RETVAL);
1285 if (!ix) START (fork, RETVAL);
1286 OUTPUT:
1287 RETVAL
1288
1289ev_child *child (struct ev_loop *loop, int pid, SV *cb)
1290 ALIAS:
1291 child_ns = 1
1292 CODE:
1293 RETVAL = e_new (sizeof (ev_child), cb, ST (0));
1294 ev_child_set (RETVAL, pid);
1295 if (!ix) START (child, RETVAL);
1296 OUTPUT:
1297 RETVAL
1298
1299ev_stat *stat (struct ev_loop *loop, SV *path, NV interval, SV *cb)
1300 ALIAS:
1301 stat_ns = 1
1302 CODE:
1303 RETVAL = e_new (sizeof (ev_stat), cb, ST (0));
1304 RETVAL->fh = newSVsv (path);
1305 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
1306 if (!ix) START (stat, RETVAL);
1307 OUTPUT:
1308 RETVAL
1309
1310ev_embed *embed (struct ev_loop *loop, struct ev_loop *other, SV *cb = &PL_sv_undef)
1311 ALIAS:
1312 embed_ns = 1
1313 CODE:
1314{
1315 if (!(ev_backend (other) & ev_embeddable_backends ()))
1316 croak ("passed loop is not embeddable via EV::embed,");
1317
1318 RETVAL = e_new (sizeof (ev_embed), cb, ST (0));
1319 RETVAL->fh = newSVsv (ST (1));
1320 ev_embed_set (RETVAL, other);
1321
1322 if (!SvOK (cb)) ev_set_cb (RETVAL, 0);
1323
1324 if (!ix) START (embed, RETVAL);
1325}
1326 OUTPUT:
1327 RETVAL
1328
1329void once (struct ev_loop *loop, SV *fh, int events, SV *timeout, SV *cb)
1330 CODE:
1331 ev_once (
1332 loop,
1333 sv_fileno (fh), events,
1334 SvOK (timeout) ? SvNV (timeout) : -1.,
1335 e_once_cb,
1336 newSVsv (cb)
1337 );
1338

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines