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.264 by root, Wed Jul 29 12:42:09 2009 UTC vs.
Revision 1.275 by root, Sun Aug 9 00:24: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
1298our $VERSION = $AnyEvent::VERSION;
1299
1300sub io($$$) {
1301 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2])
1302}
1303
1304sub timer($$$) {
1305 AnyEvent->timer (after => $_[0], interval => $_[1], cb => $_[2]);
1306}
1307
1308sub signal($$) {
1309 AnyEvent->signal (signal => $_[0], cb => $_[1]);
1310}
1311
1312sub child($$) {
1313 AnyEvent->child (pid => $_[0], cb => $_[1]);
1314}
1315
1316sub idle($) {
1317 AnyEvent->idle (cb => $_[0]);
1318}
1319
1320sub cv(;&) {
1321 AnyEvent->condvar (@_ ? (cb => $_[0]) : ())
1322}
1323
1324sub now() {
1325 AnyEvent->now
1326}
1327
1328sub now_update() {
1329 AnyEvent->now_update
1330}
1331
1332sub time() {
1333 AnyEvent->time
1334}
1335
1263package AnyEvent::Base; 1336package AnyEvent::Base;
1264 1337
1265# default implementations for many methods 1338# default implementations for many methods
1266 1339
1267sub _time { 1340sub _time {
1319 1392
1320# install a dummy wakeup watcher to reduce signal catching latency 1393# install a dummy wakeup watcher to reduce signal catching latency
1321sub _sig_add() { 1394sub _sig_add() {
1322 unless ($SIG_COUNT++) { 1395 unless ($SIG_COUNT++) {
1323 # try to align timer on a full-second boundary, if possible 1396 # try to align timer on a full-second boundary, if possible
1324 my $NOW = AnyEvent->now; 1397 my $NOW = AE::now;
1325 1398
1326 $SIG_TW = AnyEvent->timer ( 1399 $SIG_TW = AE::timer
1327 after => $MAX_SIGNAL_LATENCY - ($NOW - int $NOW), 1400 $MAX_SIGNAL_LATENCY - ($NOW - int $NOW),
1328 interval => $MAX_SIGNAL_LATENCY, 1401 $MAX_SIGNAL_LATENCY,
1329 cb => sub { }, # just for the PERL_ASYNC_CHECK 1402 sub { } # just for the PERL_ASYNC_CHECK
1330 ); 1403 ;
1331 } 1404 }
1332} 1405}
1333 1406
1334sub _sig_del { 1407sub _sig_del {
1335 undef $SIG_TW 1408 undef $SIG_TW
1336 unless --$SIG_COUNT; 1409 unless --$SIG_COUNT;
1337} 1410}
1338 1411
1339our $_sig_name_init; $_sig_name_init = sub { 1412our $_sig_name_init; $_sig_name_init = sub {
1413 eval q{ # poor man's autoloading
1340 undef $_sig_name_init; 1414 undef $_sig_name_init;
1341 1415
1342 if (_have_async_interrupt) { 1416 if (_have_async_interrupt) {
1343 *sig2num = \&Async::Interrupt::sig2num; 1417 *sig2num = \&Async::Interrupt::sig2num;
1344 *sig2name = \&Async::Interrupt::sig2name; 1418 *sig2name = \&Async::Interrupt::sig2name;
1345 } else { 1419 } else {
1346 require Config; 1420 require Config;
1347 1421
1348 my %signame2num; 1422 my %signame2num;
1349 @signame2num{ split ' ', $Config::Config{sig_name} } 1423 @signame2num{ split ' ', $Config::Config{sig_name} }
1350 = split ' ', $Config::Config{sig_num}; 1424 = split ' ', $Config::Config{sig_num};
1351 1425
1352 my @signum2name; 1426 my @signum2name;
1353 @signum2name[values %signame2num] = keys %signame2num; 1427 @signum2name[values %signame2num] = keys %signame2num;
1354 1428
1355 *sig2num = sub($) { 1429 *sig2num = sub($) {
1356 $_[0] > 0 ? shift : $signame2num{+shift} 1430 $_[0] > 0 ? shift : $signame2num{+shift}
1357 }; 1431 };
1358 *sig2name = sub ($) { 1432 *sig2name = sub ($) {
1359 $_[0] > 0 ? $signum2name[+shift] : shift 1433 $_[0] > 0 ? $signum2name[+shift] : shift
1434 };
1360 }; 1435 }
1361 } 1436 };
1437 die if $@;
1362}; 1438};
1363 1439
1364sub sig2num ($) { &$_sig_name_init; &sig2num } 1440sub sig2num ($) { &$_sig_name_init; &sig2num }
1365sub sig2name($) { &$_sig_name_init; &sig2name } 1441sub sig2name($) { &$_sig_name_init; &sig2name }
1366 1442
1367sub _signal { 1443sub signal {
1444 eval q{ # poor man's autoloading {}
1445 # probe for availability of Async::Interrupt
1446 if (_have_async_interrupt) {
1447 warn "AnyEvent: using Async::Interrupt for race-free signal handling.\n" if $VERBOSE >= 8;
1448
1449 $SIGPIPE_R = new Async::Interrupt::EventPipe;
1450 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1451
1452 } else {
1453 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1454
1455 require Fcntl;
1456
1457 if (AnyEvent::WIN32) {
1458 require AnyEvent::Util;
1459
1460 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1461 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;
1462 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case
1463 } else {
1464 pipe $SIGPIPE_R, $SIGPIPE_W;
1465 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1466 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case
1467
1468 # not strictly required, as $^F is normally 2, but let's make sure...
1469 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1470 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1471 }
1472
1473 $SIGPIPE_R
1474 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1475
1476 $SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;
1477 }
1478
1479 *signal = sub {
1368 my (undef, %arg) = @_; 1480 my (undef, %arg) = @_;
1369 1481
1370 my $signal = uc $arg{signal} 1482 my $signal = uc $arg{signal}
1371 or Carp::croak "required option 'signal' is missing"; 1483 or Carp::croak "required option 'signal' is missing";
1372 1484
1373 if ($HAVE_ASYNC_INTERRUPT) { 1485 if ($HAVE_ASYNC_INTERRUPT) {
1374 # async::interrupt 1486 # async::interrupt
1375 1487
1376 $signal = sig2num $signal; 1488 $signal = sig2num $signal;
1377 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1489 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1378 1490
1379 $SIG_ASY{$signal} ||= new Async::Interrupt 1491 $SIG_ASY{$signal} ||= new Async::Interrupt
1380 cb => sub { undef $SIG_EV{$signal} }, 1492 cb => sub { undef $SIG_EV{$signal} },
1381 signal => $signal, 1493 signal => $signal,
1382 pipe => [$SIGPIPE_R->filenos], 1494 pipe => [$SIGPIPE_R->filenos],
1383 pipe_autodrain => 0, 1495 pipe_autodrain => 0,
1384 ; 1496 ;
1385 1497
1386 } else { 1498 } else {
1387 # pure perl 1499 # pure perl
1388 1500
1389 # AE::Util has been loaded in signal 1501 # AE::Util has been loaded in signal
1390 $signal = sig2name $signal; 1502 $signal = sig2name $signal;
1391 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1503 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1392 1504
1393 $SIG{$signal} ||= sub { 1505 $SIG{$signal} ||= sub {
1394 local $!; 1506 local $!;
1395 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1507 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1396 undef $SIG_EV{$signal}; 1508 undef $SIG_EV{$signal};
1509 };
1510
1511 # can't do signal processing without introducing races in pure perl,
1512 # so limit the signal latency.
1513 _sig_add;
1514 }
1515
1516 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1397 }; 1517 };
1398 1518
1399 # can't do signal processing without introducing races in pure perl, 1519 *AnyEvent::Base::signal::DESTROY = sub {
1400 # so limit the signal latency. 1520 my ($signal, $cb) = @{$_[0]};
1521
1401 _sig_add; 1522 _sig_del;
1402 }
1403 1523
1404 bless [$signal, $arg{cb}], "AnyEvent::Base::signal" 1524 delete $SIG_CB{$signal}{$cb};
1405}
1406 1525
1407sub signal { 1526 $HAVE_ASYNC_INTERRUPT
1408 # probe for availability of Async::Interrupt 1527 ? delete $SIG_ASY{$signal}
1409 if (_have_async_interrupt) { 1528 : # delete doesn't work with older perls - they then
1410 warn "AnyEvent: using Async::Interrupt for race-free signal handling.\n" if $VERBOSE >= 8; 1529 # print weird messages, or just unconditionally exit
1411 1530 # instead of getting the default action.
1412 $SIGPIPE_R = new Async::Interrupt::EventPipe; 1531 undef $SIG{$signal}
1413 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R->fileno, poll => "r", cb => \&_signal_exec); 1532 unless keys %{ $SIG_CB{$signal} };
1414
1415 } else {
1416 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1417
1418 require Fcntl;
1419
1420 if (AnyEvent::WIN32) {
1421 require AnyEvent::Util;
1422
1423 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1424 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R) if $SIGPIPE_R;
1425 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case
1426 } else {
1427 pipe $SIGPIPE_R, $SIGPIPE_W;
1428 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1429 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case
1430
1431 # not strictly required, as $^F is normally 2, but let's make sure...
1432 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1433 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1434 } 1533 };
1435
1436 $SIGPIPE_R
1437 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1438
1439 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec);
1440 } 1534 };
1441 1535 die if $@;
1442 *signal = \&_signal;
1443 &signal 1536 &signal
1444}
1445
1446sub AnyEvent::Base::signal::DESTROY {
1447 my ($signal, $cb) = @{$_[0]};
1448
1449 _sig_del;
1450
1451 delete $SIG_CB{$signal}{$cb};
1452
1453 $HAVE_ASYNC_INTERRUPT
1454 ? delete $SIG_ASY{$signal}
1455 : # delete doesn't work with older perls - they then
1456 # print weird messages, or just unconditionally exit
1457 # instead of getting the default action.
1458 undef $SIG{$signal}
1459 unless keys %{ $SIG_CB{$signal} };
1460} 1537}
1461 1538
1462# default implementation for ->child 1539# default implementation for ->child
1463 1540
1464our %PID_CB; 1541our %PID_CB;
1493 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/ 1570 $WNOHANG ||= $^O =~ /^(?:openbsd|netbsd|linux|freebsd|cygwin|MSWin32)$/
1494 ? 1 1571 ? 1
1495 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1572 : eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1496 1573
1497 unless ($CHLD_W) { 1574 unless ($CHLD_W) {
1498 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1575 $CHLD_W = AE::signal CHLD => \&_sigchld;
1499 # child could be a zombie already, so make at least one round 1576 # child could be a zombie already, so make at least one round
1500 &_sigchld; 1577 &_sigchld;
1501 } 1578 }
1502 1579
1503 bless [$pid, $arg{cb}], "AnyEvent::Base::child" 1580 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1529 # never use more then 50% of the time for the idle watcher, 1606 # never use more then 50% of the time for the idle watcher,
1530 # within some limits 1607 # within some limits
1531 $w = 0.0001 if $w < 0.0001; 1608 $w = 0.0001 if $w < 0.0001;
1532 $w = 5 if $w > 5; 1609 $w = 5 if $w > 5;
1533 1610
1534 $w = AnyEvent->timer (after => $w, cb => $rcb); 1611 $w = AE::timer $w, 0, $rcb;
1535 } else { 1612 } else {
1536 # clean up... 1613 # clean up...
1537 undef $w; 1614 undef $w;
1538 undef $rcb; 1615 undef $rcb;
1539 } 1616 }
1540 }; 1617 };
1541 1618
1542 $w = AnyEvent->timer (after => 0.05, cb => $rcb); 1619 $w = AE::timer 0.05, 0, $rcb;
1543 1620
1544 bless \\$cb, "AnyEvent::Base::idle" 1621 bless \\$cb, "AnyEvent::Base::idle"
1545} 1622}
1546 1623
1547sub AnyEvent::Base::idle::DESTROY { 1624sub AnyEvent::Base::idle::DESTROY {
1601 Carp::croak $_[0]{_ae_croak} if $_[0]{_ae_croak}; 1678 Carp::croak $_[0]{_ae_croak} if $_[0]{_ae_croak};
1602 wantarray ? @{ $_[0]{_ae_sent} } : $_[0]{_ae_sent}[0] 1679 wantarray ? @{ $_[0]{_ae_sent} } : $_[0]{_ae_sent}[0]
1603} 1680}
1604 1681
1605sub cb { 1682sub cb {
1606 $_[0]{_ae_cb} = $_[1] if @_ > 1; 1683 my $cv = shift;
1684
1685 @_
1686 and $cv->{_ae_cb} = shift
1687 and $cv->{_ae_sent}
1688 and (delete $cv->{_ae_cb})->($cv);
1689
1607 $_[0]{_ae_cb} 1690 $cv->{_ae_cb}
1608} 1691}
1609 1692
1610sub begin { 1693sub begin {
1611 ++$_[0]{_ae_counter}; 1694 ++$_[0]{_ae_counter};
1612 $_[0]{_ae_end_cb} = $_[1] if @_ > 1; 1695 $_[0]{_ae_end_cb} = $_[1] if @_ > 1;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines