view release on metacpan or  search on metacpan

Event.xs  view on Meta::CPAN

  boot_signal();
  boot_group();
  boot_generic();
  boot_queue();
  {
      SV *apisv;
      api.Ver = EventAPI_VERSION;
      api.start = pe_watcher_start;
      api.queue = queueEvent;
      api.now = pe_watcher_now;
      api.suspend = pe_watcher_suspend;
      api.resume = pe_watcher_resume;
      api.stop = pe_watcher_stop;
      api.cancel = pe_watcher_cancel;
      api.tstart = pe_timeable_start;
      api.tstop  = pe_timeable_stop;
      api.NVtime = fallback_NVtime;
      api.new_idle =   (pe_idle*  (*)(HV*,SV*))    pe_idle_allocate;
      api.new_timer =  (pe_timer* (*)(HV*,SV*))    pe_timer_allocate;
      api.new_io =     (pe_io*    (*)(HV*,SV*))    pe_io_allocate;
      api.new_var =    (pe_var*   (*)(HV*,SV*))    pe_var_allocate;
      api.new_signal = (pe_signal*(*)(HV*,SV*))    pe_signal_allocate;
      api.add_hook = capi_add_hook;
      api.cancel_hook = pe_cancel_hook;
      api.install_stats = pe_install_stats;
      api.collect_stats = pe_collect_stats;
      api.AllWatchers = &AllWatchers;
      api.watcher_2sv = watcher_2sv;
      api.sv_2watcher = sv_2watcher;
      api.event_2sv = event_2sv;
      api.sv_2event = sv_2event;
      api.unloop = pe_unloop;
      api.unloop_all = pe_unloop_all;
      api.sv_2interval = sv_2interval;
      api.events_mask_2sv = events_mask_2sv;
      api.sv_2events_mask = sv_2events_mask;

      apisv = perl_get_sv("Event::API", 1);
      sv_setiv(apisv, (IV)&api);
      SvREADONLY_on(apisv);
  }

void
_add_hook(type, code)
	char *type
	SV *code
	CODE:
	pe_add_hook(type, 1, code, 0);
	/* would be nice to return new pe_qcallback* XXX */

int
_timeout_too_early()
	CODE:
	RETVAL = TimeoutTooEarly;
	TimeoutTooEarly=0;
	OUTPUT:
	RETVAL

void
_memory_counters()
     PPCODE:
{
#ifdef EVENT_MEMORY_DEBUG
    int xx;
    for (xx=0; xx < MAX_MEMORYCOUNT; xx++)
	XPUSHs(sv_2mortal(newSViv(MemoryCount[xx])));
#endif
}

void
_incr_looplevel()
     PPCODE:
     ++LoopLevel;
     ++ExitLevel;

void
_decr_looplevel()
     PPCODE:
     --LoopLevel;

void
unloop(...)
     CODE:
     pe_unloop(items? ST(0) : &PL_sv_undef);

void
unloop_all(...)
     CODE:
     pe_unloop_all(items? ST(0) : &PL_sv_undef);

bool
cache_time_api()
	CODE:
	SV **svp = hv_fetch(PL_modglobal, "Time::NVtime", 12, 0);
	if (!svp || !*svp || !SvIOK(*svp))
	    XSRETURN_NO;
	api.NVtime = INT2PTR(NV(*)(), SvIV(*svp));
	XSRETURN_YES;

NV
time()
	PROTOTYPE:
	CODE:
	RETVAL = NVtime();
	OUTPUT:
	RETVAL

void
sleep(tm)
	NV tm;
	PROTOTYPE: $
	CODE:
	pe_sys_sleep(tm);

NV
null_loops_per_second(sec)
	int sec

void
all_watchers()
	PROTOTYPE:
	PPCODE:
	pe_watcher *ev;
	if (!AllWatchers.next)
	  return;
	ev = (pe_watcher*) AllWatchers.next->self;
	while (ev) {
	  XPUSHs(watcher_2sv(ev));
	  ev = (pe_watcher*) ev->all.next->self;
	}

void
all_idle()
	PROTOTYPE:
	PPCODE:
	pe_watcher *ev;
	if (!Idle.prev)
	  return;
	ev = (pe_watcher*) Idle.prev->self;
	while (ev) {
	  XPUSHs(watcher_2sv(ev));
	  ev = (pe_watcher*) ((pe_idle*)ev)->iring.prev->self;
	}

void
all_running()
	PROTOTYPE:
	PPCODE:
	int fx;
	for (fx = CurCBFrame; fx >= 0; fx--) {
	  pe_watcher *ev = (CBFrame + fx)->ev->up; /* XXX */
	  XPUSHs(watcher_2sv(ev));
	  if (GIMME_V != G_ARRAY)
	    break;
	}

void
queue(...)
	PROTOTYPE: $;$
	PREINIT:
	pe_watcher *wa;
	pe_event *ev;
	PPCODE:
	wa = (pe_watcher*) sv_2watcher(ST(0));
	if (items == 1) {
	    ev = (*wa->vtbl->new_event)(wa);
	    ++ev->hits;
	}
	else if (items == 2) {
	  if (SvNIOK(ST(1))) {
	    ev = (*wa->vtbl->new_event)(wa);
	    ev->hits += SvIV(ST(1));
	  }
	  else {
	    ev = (pe_event*) sv_2event(ST(1));
	    if (ev->up != wa)
	      croak("queue: event doesn't match watcher");
	  }
	}
	queueEvent(ev);

int
one_event(...)
	PROTOTYPE: ;$
	CODE:
	NV maxtm = 60;
	if (items == 1) maxtm = SvNV(ST(0));
	RETVAL = safe_one_event(maxtm);
	OUTPUT:
	RETVAL

void
_loop()
	CODE:
	pe_check_recovery();
	pe_reentry();
        if (!ActiveWatchers)
          warn("Event: loop without active watchers");
	while (ExitLevel >= LoopLevel && ActiveWatchers) {
	  ENTER;
	  SAVETMPS;
	  one_event(60);
	  FREETMPS;
	  LEAVE;
	}
	LEAVE; /* reentry */

void
queue_pending()
	CODE:
	pe_queue_pending();

int
_empty_queue(prio)
	int prio
	CODE:
	pe_check_recovery();
	pe_reentry();
	while (pe_empty_queue(prio));
	LEAVE; /* reentry */

void
queue_time(prio)
	int prio
	PPCODE:
	NV max=0;
	int xx;
	if (prio < 0 || prio >= PE_QUEUES)
	  croak("queue_time(%d) out of domain [0..%d]",
		prio, PE_QUEUES-1);
	for (xx=0; xx <= prio; xx++)
	  if (max < QueueTime[xx]) max = QueueTime[xx];
	XPUSHs(max? sv_2mortal(newSVnv(max)) : &PL_sv_undef);


MODULE = Event		PACKAGE = Event::Event::Io

void
pe_event::got()
	PPCODE:
	XPUSHs(sv_2mortal(events_mask_2sv(((pe_ioevent*)THIS)->got)));

MODULE = Event		PACKAGE = Event::Event::Dataful

void
pe_event::data()
	PPCODE:
	XPUSHs(((pe_datafulevent*)THIS)->data);

MODULE = Event		PACKAGE = Event::Event

void
DESTROY(ref)
	SV *ref;
	CODE:
{
	pe_event *THIS = (pe_event*) sv_2event(ref);
	if (WaDEBUGx(THIS) >= 3) {
	    STRLEN n_a;
	    warn("Event=0x%x '%s' DESTROY SV=0x%x",
		 THIS, SvPV(THIS->up->desc, n_a),
		 THIS->mysv? SvRV(THIS->mysv) : 0);
	}
	(*THIS->vtbl->dtor)(THIS);
}

void
pe_event::mom()
	PPCODE:
	if (--WarnCounter >= 0) warn("'mom' renamed to 'w'");
	XPUSHs(watcher_2sv(THIS->up));

void
pe_event::w()
	PPCODE:
	XPUSHs(watcher_2sv(THIS->up));

void
pe_event::hits()
	PPCODE:
	XPUSHs(sv_2mortal(newSViv(THIS->hits)));

void
pe_event::prio()
	PPCODE:
	XPUSHs(sv_2mortal(newSViv(THIS->prio)));

MODULE = Event		PACKAGE = Event::Watcher

void
DESTROY(ref)
	SV *ref;
	CODE:
{
	pe_watcher *THIS = (pe_watcher*) sv_2watcher(ref);
	assert(THIS);
	if (THIS->mysv) {
	    THIS->mysv=0;
	    if (WaCANDESTROY(THIS)) /*mysv*/
		(*THIS->vtbl->dtor)(THIS);
	}
}

void
pe_watcher::pending()
	PPCODE:
{
    if (GIMME_V == G_ARRAY) {
	pe_event *ev = (pe_event *) THIS->events.prev->self;
	while (ev) {
	    XPUSHs(event_2sv(ev));
	    ev = (pe_event*) ev->peer.prev->self;
	}
    } else {
	XPUSHs(THIS->events.next->self? &PL_sv_yes : &PL_sv_no);
    }
}

void
pe_watcher::again()
	CODE:
	pe_watcher_start(THIS, 1);

void
pe_watcher::start()
	CODE:
	pe_watcher_start(THIS, 0);

void
pe_watcher::suspend(...)
	CODE:
	if (items == 2) {
	    if (sv_true(ST(1)))
		pe_watcher_suspend(THIS);
	    else
		pe_watcher_resume(THIS);
	} else {
	    warn("Ambiguous use of suspend"); /*XXX*/
	    pe_watcher_suspend(THIS);
	    XSRETURN_YES;
	}

void
pe_watcher::resume()
	CODE:
	warn("Please use $w->suspend(0) instead of resume"); /* DEPRECATED */
	pe_watcher_resume(THIS);

void
pe_watcher::stop()
	CODE:
	pe_watcher_stop(THIS, 1);

void
pe_watcher::cancel()
	CODE:
	pe_watcher_cancel(THIS);

void
pe_watcher::now()
	CODE:
	pe_watcher_now(THIS);

void
pe_watcher::use_keys(...)
	PREINIT:
	PPCODE:
	warn("use_keys is deprecated");

void
pe_watcher::is_running(...)
	PPCODE:
	XPUSHs(sv_2mortal(newSViv(THIS->running)));

void
pe_watcher::is_active(...)
	PPCODE:
	PUTBACK;
	XPUSHs(boolSV(WaACTIVE(THIS)));

void
pe_watcher::is_suspended(...)
	PPCODE:
	PUTBACK;
	XPUSHs(boolSV(WaSUSPEND(THIS)));

void
pe_watcher::is_cancelled(...)
	PPCODE:
	PUTBACK;
	XPUSHs(boolSV(WaCANCELLED(THIS)));

void
pe_watcher::cb(...)
	PPCODE:
	PUTBACK;
	_watcher_callback(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::cbtime(...)
	PPCODE:
	PUTBACK;
	_watcher_cbtime(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::desc(...)
	PPCODE:
	PUTBACK;
	_watcher_desc(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::debug(...)
	PPCODE:
	PUTBACK;
	_watcher_debug(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::prio(...)
	PPCODE:
	PUTBACK;
	_watcher_priority(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::reentrant(...)
	PPCODE:
	PUTBACK;
	_watcher_reentrant(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::repeat(...)
	PPCODE:
	PUTBACK;
	_watcher_repeat(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::max_cb_tm(...)
	PPCODE:
	PUTBACK;
	_watcher_max_cb_tm(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

MODULE = Event		PACKAGE = Event::Watcher::Tied

void
allocate(clname, temple)
	SV *clname
	SV *temple
	PPCODE:
	if (!SvROK(temple)) croak("Bad template");
	XPUSHs(watcher_2sv(pe_tied_allocate(gv_stashsv(clname, 1),
					    SvRV(temple))));

void
pe_watcher::hard(...)
	PPCODE:
	PUTBACK;
	_timeable_hard(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::at(...)
	PPCODE:
	PUTBACK;
	_tied_at(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::flags(...)
	PPCODE:
	PUTBACK;
	_tied_flags(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

MODULE = Event		PACKAGE = Event::idle

void
allocate(clname, temple)
	SV *clname;
	SV *temple;
	PPCODE:
	if (!SvROK(temple)) croak("Bad template");
	XPUSHs(watcher_2sv(pe_idle_allocate(gv_stashsv(clname, 1),
			SvRV(temple))));

void
pe_watcher::hard(...)
	PPCODE:
	PUTBACK;
	_timeable_hard(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::max(...)
	PPCODE:
	PUTBACK;
	_idle_max_interval(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::min(...)
	PPCODE:
	PUTBACK;
	_idle_min_interval(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

MODULE = Event		PACKAGE = Event::timer

void
allocate(clname, temple)
	SV *clname;
	SV *temple;
	PPCODE:
	XPUSHs(watcher_2sv(pe_timer_allocate(gv_stashsv(clname, 1),
			SvRV(temple))));

void
pe_watcher::at(...)
	PPCODE:
	PUTBACK;
	_timer_at(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::hard(...)
	PPCODE:
	PUTBACK;
	_timeable_hard(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::interval(...)
	PPCODE:
	PUTBACK;
	_timer_interval(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

MODULE = Event		PACKAGE = Event::io

void
allocate(clname, temple)
	SV *clname;
	SV *temple;
	PPCODE:
	if (!SvROK(temple)) croak("Bad template");
	XPUSHs(watcher_2sv(pe_io_allocate(gv_stashsv(clname, 1),
			SvRV(temple))));

void
pe_watcher::poll(...)
	PPCODE:
	PUTBACK;
	_io_poll(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::fd(...)
	PPCODE:
	PUTBACK;
	_io_handle(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::timeout(...)
	PPCODE:
	PUTBACK;
	_io_timeout(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::timeout_cb(...)
	PPCODE:
	PUTBACK;
	_io_timeout_cb(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

MODULE = Event		PACKAGE = Event::var

void
allocate(clname, temple)
	SV *clname;
	SV *temple;
	PPCODE:
	XPUSHs(watcher_2sv(pe_var_allocate(gv_stashsv(clname, 1),
		SvRV(temple))));

void
pe_watcher::var(...)
	PPCODE:
	PUTBACK;
	_var_variable(THIS, items == 2? ST(1) : 0); /* don't mortalcopy!! */
	SPAGAIN;

void
pe_watcher::poll(...)
	PPCODE:
	PUTBACK;
	_var_events(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

MODULE = Event		PACKAGE = Event::signal

void
allocate(clname, temple)
	SV *clname;
	SV *temple;
	PPCODE:
	XPUSHs(watcher_2sv(pe_signal_allocate(gv_stashsv(clname, 1),
		SvRV(temple))));

void
pe_watcher::signal(...)
	PPCODE:
	PUTBACK;
	_signal_signal(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

MODULE = Event		PACKAGE = Event::group

void
allocate(clname, temple)
     SV *clname;
     SV *temple;
     PPCODE:
     XPUSHs(watcher_2sv(pe_group_allocate(gv_stashsv(clname, 1),
		SvRV(temple))));

void
pe_watcher::timeout(...)
	PPCODE:
	PUTBACK;
	_group_timeout(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::add(...)
	PPCODE:
	PUTBACK;
	_group_add(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

void
pe_watcher::del(...)
	PPCODE:
	PUTBACK;
	_group_del(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

MODULE = Event		PACKAGE = Event::generic

void
allocate(clname, temple)
     SV *clname;
     SV *temple;
     PPCODE:
     XPUSHs(watcher_2sv(pe_generic_allocate(gv_stashsv(clname, 1),
		SvRV(temple))));

void
pe_watcher::source(...)
	PPCODE:
	PUTBACK;
	_generic_source(THIS, items == 2? sv_mortalcopy(ST(1)) : 0);
	SPAGAIN;

MODULE = Event		PACKAGE = Event::generic::Source

void
allocate(clname, temple)
	SV *clname;
	SV *temple;
	PPCODE:
	if (!SvROK(temple)) croak("Bad template");
	XPUSHs(genericsrc_2sv(pe_genericsrc_allocate(gv_stashsv(clname, 1),
			SvRV(temple))));

void
DESTROY(ref)
	SV *ref;
	CODE:
{
	pe_genericsrc_dtor(sv_2genericsrc(ref));
}

void
pe_genericsrc::event(...)
	PPCODE:
	pe_genericsrc_event(THIS,
		items >= 2 ? sv_mortalcopy(ST(1)) : &PL_sv_undef);