ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent/lib/AnyEvent.pm
(Generate patch)

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.263 by root, Wed Jul 29 12:39:21 2009 UTC vs.
Revision 1.274 by root, Sun Aug 9 00:20:35 2009 UTC

… …
181my variables are only visible after the statement in which they are 181my variables are only visible after the statement in which they are
182declared. 182declared.
183 183
184=head2 I/O WATCHERS 184=head2 I/O WATCHERS
185 185
186 $w = AnyEvent->io (
187 fh => <filehandle_or_fileno>,
188 poll => <"r" or "w">,
189 cb => <callback>,
190 );
191
186You can create an I/O watcher by calling the C<< AnyEvent->io >> method 192You can create an I/O watcher by calling the C<< AnyEvent->io >> method
187with the following mandatory key-value pairs as arguments: 193with the following mandatory key-value pairs as arguments:
188 194
189C<fh> is the Perl I<file handle> (or a naked file descriptor) to watch 195C<fh> is the Perl I<file handle> (or a naked file descriptor) to watch
190for events (AnyEvent might or might not keep a reference to this file 196for events (AnyEvent might or might not keep a reference to this file
… …
219 undef $w; 225 undef $w;
220 }); 226 });
221 227
222=head2 TIME WATCHERS 228=head2 TIME WATCHERS
223 229
230 $w = AnyEvent->timer (after => <seconds>, cb => <callback>);
231
232 $w = AnyEvent->timer (
233 after => <fractional_seconds>,
234 interval => <fractional_seconds>,
235 cb => <callback>,
236 );
237
224You can create a time watcher by calling the C<< AnyEvent->timer >> 238You can create a time watcher by calling the C<< AnyEvent->timer >>
225method with the following mandatory arguments: 239method with the following mandatory arguments:
226 240
227C<after> specifies after how many seconds (fractional values are 241C<after> specifies after how many seconds (fractional values are
228supported) the callback should be invoked. C<cb> is the callback to invoke 242supported) the callback should be invoked. C<cb> is the callback to invoke
… …
355 369
356=back 370=back
357 371
358=head2 SIGNAL WATCHERS 372=head2 SIGNAL WATCHERS
359 373
374 $w = AnyEvent->signal (signal => <uppercase_signal_name>, cb => <callback>);
375
360You can watch for signals using a signal watcher, C<signal> is the signal 376You can watch for signals using a signal watcher, C<signal> is the signal
361I<name> in uppercase and without any C<SIG> prefix, C<cb> is the Perl 377I<name> in uppercase and without any C<SIG> prefix, C<cb> is the Perl
362callback to be invoked whenever a signal occurs. 378callback to be invoked whenever a signal occurs.
363 379
364Although the callback might get passed parameters, their value and 380Although the callback might get passed parameters, their value and
… …
383 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 }); 399 my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
384 400
385=head3 Signal Races, Delays and Workarounds 401=head3 Signal Races, Delays and Workarounds
386 402
387Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching 403Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching
388callbacks to signals in a generic way, which is a pity, as you cannot do 404callbacks to signals in a generic way, which is a pity, as you cannot
389race-free signal handling in perl. AnyEvent will try to do it's best, but 405do race-free signal handling in perl, requiring C libraries for
406this. AnyEvent will try to do it's best, which means in some cases,
390in some cases, signals will be delayed. The maximum time a signal might 407signals will be delayed. The maximum time a signal might be delayed is
391be delayed is specified in C<$AnyEvent::MAX_SIGNAL_LATENCY> (default: 10 408specified in C<$AnyEvent::MAX_SIGNAL_LATENCY> (default: 10 seconds). This
392seconds). This variable can be changed only before the first signal 409variable can be changed only before the first signal watcher is created,
393watcher is created, and should be left alone otherwise. Higher values 410and should be left alone otherwise. This variable determines how often
411AnyEvent polls for signals (in case a wake-up was missed). Higher values
394will cause fewer spurious wake-ups, which is better for power and CPU 412will cause fewer spurious wake-ups, which is better for power and CPU
413saving.
414
395saving. All these problems can be avoided by installing the optional 415All these problems can be avoided by installing the optional
396L<Async::Interrupt> module. This will not work with inherently broken 416L<Async::Interrupt> module, which works with most event loops. It will not
397event loops such as L<Event> or L<Event::Lib> (and not with L<POE> 417work with inherently broken event loops such as L<Event> or L<Event::Lib>
398currently, as POE does it's own workaround with one-second latency). With 418(and not with L<POE> currently, as POE does it's own workaround with
399those, you just have to suffer the delays. 419one-second latency). For those, you just have to suffer the delays.
400 420
401=head2 CHILD PROCESS WATCHERS 421=head2 CHILD PROCESS WATCHERS
422
423 $w = AnyEvent->child (pid => <process id>, cb => <callback>);
402 424
403You can also watch on a child process exit and catch its exit status. 425You can also watch on a child process exit and catch its exit status.
404 426
405The child process is specified by the C<pid> argument (one some backends, 427The child process is specified by the C<pid> argument (one some backends,
406using C<0> watches for any child process exit, on others this will 428using C<0> watches for any child process exit, on others this will
… …
455 # do something else, then wait for process exit 477 # do something else, then wait for process exit
456 $done->recv; 478 $done->recv;
457 479
458=head2 IDLE WATCHERS 480=head2 IDLE WATCHERS
459 481
482 $w = AnyEvent->idle (cb => <callback>);
483
460Sometimes there is a need to do something, but it is not so important 484Sometimes there is a need to do something, but it is not so important
461to do it instantly, but only when there is nothing better to do. This 485to do it instantly, but only when there is nothing better to do. This
462"nothing better to do" is usually defined to be "no other events need 486"nothing better to do" is usually defined to be "no other events need
463attention by the event loop". 487attention by the event loop".
464 488
… …
490 }); 514 });
491 }); 515 });
492 516
493=head2 CONDITION VARIABLES 517=head2 CONDITION VARIABLES
494 518
519 $cv = AnyEvent->condvar;
520
521 $cv->send (<list>);
522 my @res = $cv->recv;
523
495If you are familiar with some event loops you will know that all of them 524If you are familiar with some event loops you will know that all of them
496require you to run some blocking "loop", "run" or similar function that 525require you to run some blocking "loop", "run" or similar function that
497will actively watch for new events and call your callbacks. 526will actively watch for new events and call your callbacks.
498 527
499AnyEvent is slightly different: it expects somebody else to run the event 528AnyEvent is slightly different: it expects somebody else to run the event
… …
761=item $cb = $cv->cb ($cb->($cv)) 790=item $cb = $cv->cb ($cb->($cv))
762 791
763This is a mutator function that returns the callback set and optionally 792This is a mutator function that returns the callback set and optionally
764replaces it before doing so. 793replaces it before doing so.
765 794
766The callback will be called when the condition becomes "true", i.e. when 795The callback will be called when the condition becomes (or already was)
767C<send> or C<croak> are called, with the only argument being the condition 796"true", i.e. when C<send> or C<croak> are called (or were called), with
768variable itself. Calling C<recv> inside the callback or at any later time 797the only argument being the condition variable itself. Calling C<recv>
769is guaranteed not to block. 798inside the callback or at any later time is guaranteed not to block.
770 799
771=back 800=back
772 801
773=head1 SUPPORTED EVENT LOOPS/BACKENDS 802=head1 SUPPORTED EVENT LOOPS/BACKENDS
774 803
… …
1086 1115
1087BEGIN { AnyEvent::common_sense } 1116BEGIN { AnyEvent::common_sense }
1088 1117
1089use Carp (); 1118use Carp ();
1090 1119
1091our $VERSION = 4.881; 1120our $VERSION = 4.92;
1092our $MODEL; 1121our $MODEL;
1093 1122
1094our $AUTOLOAD; 1123our $AUTOLOAD;
1095our @ISA; 1124our @ISA;
1096 1125
… …
1258 # we assume CLOEXEC is already set by perl in all important cases 1287 # we assume CLOEXEC is already set by perl in all important cases
1259 1288
1260 ($fh2, $rw) 1289 ($fh2, $rw)
1261} 1290}
1262 1291
1292#############################################################################
1293# "new" API, currently only emulation of it
1294#############################################################################
1295
1296package AE;
1297
1298sub io($$$) {
1299 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2])
1300}
1301
1302sub timer($$$) {
1303 AnyEvent->timer (after => $_[0], interval => $_[1], cb => $_[2]);
1304}
1305
1306sub signal($$) {
1307 AnyEvent->signal (signal => $_[0], cb => $_[1]);
1308}
1309
1310sub child($$) {
1311 AnyEvent->child (pid => $_[0], cb => $_[1]);
1312}
1313
1314sub idle($) {
1315 AnyEvent->idle (cb => $_[0]);
1316}
1317
1318sub cv(;&) {
1319 AnyEvent->condvar (@_ ? (cb => $_[0]) : ())
1320}
1321
1322sub now() {
1323 AnyEvent->now
1324}
1325
1326sub now_update() {
1327 AnyEvent->now_update
1328}
1329
1330sub time() {
1331 AnyEvent->time
1332}
1333
1263package AnyEvent::Base; 1334package AnyEvent::Base;
1264 1335
1265# default implementations for many methods 1336# default implementations for many methods
1266 1337
1267sub _time { 1338sub _time {
… …
1319 1390
1320# install a dummy wakeup watcher to reduce signal catching latency 1391# install a dummy wakeup watcher to reduce signal catching latency
1321sub _sig_add() { 1392sub _sig_add() {
1322 unless ($SIG_COUNT++) { 1393 unless ($SIG_COUNT++) {
1323 # try to align timer on a full-second boundary, if possible 1394 # try to align timer on a full-second boundary, if possible
1324 my $NOW = AnyEvent->now; 1395 my $NOW = AE::now;
1325 1396
1326 $SIG_TW = AnyEvent->timer ( 1397 $SIG_TW = AE::timer
1327 after => $MAX_SIGNAL_LATENCY - ($NOW - int $NOW), 1398 $MAX_SIGNAL_LATENCY - ($NOW - int $NOW),
1328 interval => $MAX_SIGNAL_LATENCY, 1399 $MAX_SIGNAL_LATENCY,
1329 cb => sub { }, # just for the PERL_ASYNC_CHECK 1400 sub { } # just for the PERL_ASYNC_CHECK
1330 ); 1401 ;
1331 } 1402 }
1332} 1403}
1333 1404
1334sub _sig_del { 1405sub _sig_del {
1335 undef $SIG_TW 1406 undef $SIG_TW
1336 unless --$SIG_COUNT; 1407 unless --$SIG_COUNT;
1337} 1408}
1338 1409
1339our %SIGNAME2NUM;
1340our @SIGNUM2NAME;
1341our $_sig_name_init; $_sig_name_init = sub { 1410our $_sig_name_init; $_sig_name_init = sub {
1411 eval q{ # poor man's autoloading
1342 undef $_sig_name_init; 1412 undef $_sig_name_init;
1343 1413
1344 if (_have_async_interrupt) { 1414 if (_have_async_interrupt) {
1345 *sig2num = \&Async::Interrupt::sig2num; 1415 *sig2num = \&Async::Interrupt::sig2num;
1346 *sig2name = \&Async::Interrupt::sig2name; 1416 *sig2name = \&Async::Interrupt::sig2name;
1347 } else { 1417 } else {
1348 require Config; 1418 require Config;
1349 1419
1420 my %signame2num;
1350 @SIGNAME2NUM{ split ' ', $Config::Config{sig_name} } 1421 @signame2num{ split ' ', $Config::Config{sig_name} }
1351 = split ' ', $Config::Config{sig_num}; 1422 = split ' ', $Config::Config{sig_num};
1352 @SIGNUM2NAME[values %SIGNAME2NUM] = keys %SIGNAME2NUM;
1353 1423
1424 my @signum2name;
1425 @signum2name[values %signame2num] = keys %signame2num;
1426
1354 *sig2num = sub($) { 1427 *sig2num = sub($) {
1355 $_[0] > 0 ? shift : $SIGNAME2NUM{+shift} 1428 $_[0] > 0 ? shift : $signame2num{+shift}
1356 }; 1429 };
1357 *sig2name = sub ($) { 1430 *sig2name = sub ($) {
1358 $_[0] > 0 ? $SIGNUM2NAME[+shift] : shift 1431 $_[0] > 0 ? $signum2name[+shift] : shift
1432 };
1359 }; 1433 }
1360 } 1434 };
1435 die if $@;
1361}; 1436};
1362 1437
1363sub sig2num ($) { &$_sig_name_init; &sig2num } 1438sub sig2num ($) { &$_sig_name_init; &sig2num }
1364sub sig2name($) { &$_sig_name_init; &sig2name } 1439sub sig2name($) { &$_sig_name_init; &sig2name }
1365 1440
1366sub _signal { 1441sub signal {
1442 eval q{ # poor man's autoloading {}
1443 # probe for availability of Async::Interrupt
1444 if (_have_async_interrupt) {
1445 warn "AnyEvent: using Async::Interrupt for race-free signal handling.\n" if $VERBOSE >= 8;
1446
1447 $SIGPIPE_R = new Async::Interrupt::EventPipe;
1448 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1449
1450 } else {
1451 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1452
1453 require Fcntl;
1454
1455 if (AnyEvent::WIN32) {
1456 require AnyEvent::Util;
1457
1458 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1459 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;
1460 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case
1461 } else {
1462 pipe $SIGPIPE_R, $SIGPIPE_W;
1463 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1464 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case
1465
1466 # not strictly required, as $^F is normally 2, but let's make sure...
1467 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1468 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1469 }
1470
1471 $SIGPIPE_R
1472 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1473
1474 $SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;
1475 }
1476
1477 *signal = sub {
1367 my (undef, %arg) = @_; 1478 my (undef, %arg) = @_;
1368 1479
1369 my $signal = uc $arg{signal} 1480 my $signal = uc $arg{signal}
1370 or Carp::croak "required option 'signal' is missing"; 1481 or Carp::croak "required option 'signal' is missing";
1371 1482
1372 if ($HAVE_ASYNC_INTERRUPT) { 1483 if ($HAVE_ASYNC_INTERRUPT) {
1373 # async::interrupt 1484 # async::interrupt
1374 1485
1375 $signal = sig2num $signal; 1486 $signal = sig2num $signal;
1376 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1487 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1377 1488
1378 $SIG_ASY{$signal} ||= new Async::Interrupt 1489 $SIG_ASY{$signal} ||= new Async::Interrupt
1379 cb => sub { undef $SIG_EV{$signal} }, 1490 cb => sub { undef $SIG_EV{$signal} },
1380 signal => $signal, 1491 signal => $signal,
1381 pipe => [$SIGPIPE_R->filenos], 1492 pipe => [$SIGPIPE_R->filenos],
1382 pipe_autodrain => 0, 1493 pipe_autodrain => 0,
1383 ; 1494 ;
1384 1495
1385 } else { 1496 } else {
1386 # pure perl 1497 # pure perl
1387 1498
1388 # AE::Util has been loaded in signal 1499 # AE::Util has been loaded in signal
1389 $signal = sig2name $signal; 1500 $signal = sig2name $signal;
1390 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1501 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1391 1502
1392 $SIG{$signal} ||= sub { 1503 $SIG{$signal} ||= sub {
1393 local $!; 1504 local $!;
1394 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1505 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1395 undef $SIG_EV{$signal}; 1506 undef $SIG_EV{$signal};
1507 };
1508
1509 # can't do signal processing without introducing races in pure perl,
1510 # so limit the signal latency.
1511 _sig_add;
1512 }
1513
1514 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1396 }; 1515 };
1397 1516
1398 # can't do signal processing without introducing races in pure perl, 1517 *AnyEvent::Base::signal::DESTROY = sub {
1399 # so limit the signal latency. 1518 my ($signal, $cb) = @{$_[0]};
1519
1400 _sig_add; 1520 _sig_del;
1401 }
1402 1521
1403 bless [$signal, $arg{cb}], "AnyEvent::Base::signal" 1522 delete $SIG_CB{$signal}{$cb};
1404}
1405 1523
1406sub signal { 1524 $HAVE_ASYNC_INTERRUPT
1407 # probe for availability of Async::Interrupt 1525 ? delete $SIG_ASY{$signal}
1408 if (_have_async_interrupt) { 1526 : # delete doesn't work with older perls - they then
1409 warn "AnyEvent: using Async::Interrupt for race-free signal handling.\n" if $VERBOSE >= 8; 1527 # print weird messages, or just unconditionally exit
1410 1528 # instead of getting the default action.
1411 $SIGPIPE_R = new Async::Interrupt::EventPipe; 1529 undef $SIG{$signal}
1412 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R->fileno, poll => "r", cb => \&_signal_exec); 1530 unless keys %{ $SIG_CB{$signal} };
1413
1414 } else {
1415 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1416
1417 require Fcntl;
1418
1419 if (AnyEvent::WIN32) {
1420 require AnyEvent::Util;
1421
1422 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1423 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R) if $SIGPIPE_R;
1424 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case
1425 } else {
1426 pipe $SIGPIPE_R, $SIGPIPE_W;
1427 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1428 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case
1429
1430 # not strictly required, as $^F is normally 2, but let's make sure...
1431 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1432 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1433 } 1531 };
1434
1435 $SIGPIPE_R
1436 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1437
1438 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec);
1439 } 1532 };
1440 1533 die if $@;
1441 *signal = \&_signal;
1442 &signal 1534 &signal
1443}
1444
1445sub AnyEvent::Base::signal::DESTROY {
1446 my ($signal, $cb) = @{$_[0]};
1447
1448 _sig_del;
1449
1450 delete $SIG_CB{$signal}{$cb};
1451
1452 $HAVE_ASYNC_INTERRUPT
1453 ? delete $SIG_ASY{$signal}
1454 : # delete doesn't work with older perls - they then
1455 # print weird messages, or just unconditionally exit
1456 # instead of getting the default action.
1457 undef $SIG{$signal}
1458 unless keys %{ $SIG_CB{$signal} };
1459} 1535}
1460 1536
1461# default implementation for ->child 1537# default implementation for ->child
1462 1538
1463our %PID_CB; 1539our %PID_CB;
… …
1492 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/ 1568 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/
1493 ? 1 1569 ? 1
1494 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1570 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1495 1571
1496 unless ($CHLD_W) { 1572 unless ($CHLD_W) {
1497 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1573 $CHLD_W = AE::signal CHLD => \&_sigchld;
1498 # child could be a zombie already, so make at least one round 1574 # child could be a zombie already, so make at least one round
1499 &_sigchld; 1575 &_sigchld;
1500 } 1576 }
1501 1577
1502 bless [$pid, $arg{cb}], "AnyEvent::Base::child" 1578 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
… …
1528 # never use more then 50% of the time for the idle watcher, 1604 # never use more then 50% of the time for the idle watcher,
1529 # within some limits 1605 # within some limits
1530 $w = 0.0001 if $w < 0.0001; 1606 $w = 0.0001 if $w < 0.0001;
1531 $w = 5 if $w > 5; 1607 $w = 5 if $w > 5;
1532 1608
1533 $w = AnyEvent->timer (after => $w, cb => $rcb); 1609 $w = AE::timer $w, 0, $rcb;
1534 } else { 1610 } else {
1535 # clean up... 1611 # clean up...
1536 undef $w; 1612 undef $w;
1537 undef $rcb; 1613 undef $rcb;
1538 } 1614 }
1539 }; 1615 };
1540 1616
1541 $w = AnyEvent->timer (after => 0.05, cb => $rcb); 1617 $w = AE::timer 0.05, 0, $rcb;
1542 1618
1543 bless \\$cb, "AnyEvent::Base::idle" 1619 bless \\$cb, "AnyEvent::Base::idle"
1544} 1620}
1545 1621
1546sub AnyEvent::Base::idle::DESTROY { 1622sub AnyEvent::Base::idle::DESTROY {
… …
1600 Carp::croak $_[0]{_ae_croak} if $_[0]{_ae_croak}; 1676 Carp::croak $_[0]{_ae_croak} if $_[0]{_ae_croak};
1601 wantarray ? @{ $_[0]{_ae_sent} } : $_[0]{_ae_sent}[0] 1677 wantarray ? @{ $_[0]{_ae_sent} } : $_[0]{_ae_sent}[0]
1602} 1678}
1603 1679
1604sub cb { 1680sub cb {
1605 $_[0]{_ae_cb} = $_[1] if @_ > 1; 1681 my $cv = shift;
1682
1683 @_
1684 and $cv->{_ae_cb} = shift
1685 and $cv->{_ae_sent}
1686 and (delete $cv->{_ae_cb})->($cv);
1687
1606 $_[0]{_ae_cb} 1688 $cv->{_ae_cb}
1607} 1689}
1608 1690
1609sub begin { 1691sub begin {
1610 ++$_[0]{_ae_counter}; 1692 ++$_[0]{_ae_counter};
1611 $_[0]{_ae_end_cb} = $_[1] if @_ > 1; 1693 $_[0]{_ae_end_cb} = $_[1] if @_ > 1;

Diff Legend

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