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

Comparing EV/EV.pm (file contents):
Revision 1.12 by root, Mon Oct 29 08:52:28 2007 UTC vs.
Revision 1.23 by root, Fri Nov 2 20:21:33 2007 UTC

1=head1 NAME 1=head1 NAME
2 2
3EV - perl interface to libevent, monkey.org/~provos/libevent/ 3EV - perl interface to libev, a high performance full-featured event loop
4 4
5=head1 SYNOPSIS 5=head1 SYNOPSIS
6 6
7 use EV; 7 use EV;
8 8
9 # TIMER 9 # TIMERS
10 10
11 my $w = EV::timer 2, 0, sub { 11 my $w = EV::timer 2, 0, sub {
12 warn "is called after 2s"; 12 warn "is called after 2s";
13 }; 13 };
14 14
… …
16 warn "is called roughly every 2s (repeat = 1)"; 16 warn "is called roughly every 2s (repeat = 1)";
17 }; 17 };
18 18
19 undef $w; # destroy event watcher again 19 undef $w; # destroy event watcher again
20 20
21 my $w = EV::timer_abs 0, 60, sub { 21 my $w = EV::periodic 0, 60, sub {
22 warn "is called every minute, on the minute, exactly"; 22 warn "is called every minute, on the minute, exactly";
23 }; 23 };
24 24
25 # IO 25 # IO
26 26
27 my $w = EV::io \*STDIN, EV::READ | EV::PERSIST, sub { 27 my $w = EV::io *STDIN, EV::READ, sub {
28 my ($w, $events) = @_; # all callbacks get the watcher object and event mask 28 my ($w, $revents) = @_; # all callbacks get the watcher object and event mask
29 if ($events & EV::TIMEOUT) {
30 warn "nothing received on stdin for 10 seconds, retrying";
31 } else {
32 warn "stdin is readable, you entered: ", <STDIN>; 29 warn "stdin is readable, you entered: ", <STDIN>;
33 }
34 };
35 $w->timeout (10);
36
37 my $w = EV::timed_io \*STDIN, EV::READ, 30, sub {
38 my ($w, $events) = @_;
39 if ($_[1] & EV::TIMEOUT) {
40 warn "nothing entered within 30 seconds, bye bye.\n";
41 $w->stop;
42 } else {
43 my $line = <STDIN>;
44 warn "you entered something, you again have 30 seconds.\n";
45 }
46 }; 30 };
47 31
48 # SIGNALS 32 # SIGNALS
49 33
50 my $w = EV::signal 'QUIT', sub { 34 my $w = EV::signal 'QUIT', sub {
… …
52 }; 36 };
53 37
54 my $w = EV::signal 3, sub { 38 my $w = EV::signal 3, sub {
55 warn "sigquit received (this is GNU/Linux, right?)\n"; 39 warn "sigquit received (this is GNU/Linux, right?)\n";
56 }; 40 };
41
42 # CHILD/PID STATUS CHANGES
43
44 my $w = EV::child 666, sub {
45 my ($w, $revents, $status) = @_;
46 };
57 47
58 # MAINLOOP 48 # MAINLOOP
59 EV::dispatch; # loop as long as watchers are active 49 EV::loop; # loop until EV::loop_done is called
60 EV::loop; # the same thing
61 EV::loop EV::LOOP_ONCE; # block until some events could be handles 50 EV::loop EV::LOOP_ONESHOT; # block until at least one event could be handled
62 EV::loop EV::LOOP_NONBLOCK; # check and handle some events, but do not wait 51 EV::loop EV::LOOP_NONBLOCK; # try to handle same events, but do not block
63 52
64=head1 DESCRIPTION 53=head1 DESCRIPTION
65 54
66This module provides an interface to libevent 55This module provides an interface to libev
67(L<http://monkey.org/~provos/libevent/>). You probably should acquaint 56(L<http://software.schmorp.de/pkg/libev.html>).
68yourself with its documentation and source code to be able to use this
69module fully.
70
71Please note thta this module disables the libevent EPOLL method by
72default, see BUGS, below, if you need to enable it.
73 57
74=cut 58=cut
75 59
76package EV; 60package EV;
77 61
78use strict; 62use strict;
79 63
80BEGIN { 64BEGIN {
81 our $VERSION = '0.03'; 65 our $VERSION = '0.1';
82 use XSLoader; 66 use XSLoader;
83 XSLoader::load "EV", $VERSION; 67 XSLoader::load "EV", $VERSION;
84} 68}
85 69
70@EV::Io::ISA =
71@EV::Timer::ISA =
72@EV::Periodic::ISA =
73@EV::Signal::ISA =
74@EV::Idle::ISA =
75@EV::Prepare::ISA =
76@EV::Check::ISA =
77@EV::Child::ISA = "EV::Watcher";
78
86=head1 BASIC INTERFACE 79=head1 BASIC INTERFACE
87 80
88=over 4 81=over 4
89
90=item $EV::NPRI
91
92How many priority levels are available.
93 82
94=item $EV::DIED 83=item $EV::DIED
95 84
96Must contain a reference to a function that is called when a callback 85Must contain a reference to a function that is called when a callback
97throws an exception (with $@ containing thr error). The default prints an 86throws an exception (with $@ containing thr error). The default prints an
98informative message and continues. 87informative message and continues.
99 88
100If this callback throws an exception it will be silently ignored. 89If this callback throws an exception it will be silently ignored.
101 90
91=item $time = EV::time
92
93Returns the current time in (fractional) seconds since the epoch.
94
102=item $time = EV::now 95=item $time = EV::now
103 96
104Returns the time in (fractional) seconds since the epoch. 97Returns the time the last event loop iteration has been started. This
98is the time that (relative) timers are based on, and refering to it is
99usually faster then calling EV::time.
105 100
106=item $version = EV::version
107
108=item $method = EV::method 101=item $method = EV::ev_method
109 102
110Return version string and event polling method used. 103Returns an integer describing the backend used by libev (EV::METHOD_SELECT
104or EV::METHOD_EPOLL).
111 105
112=item EV::loop $flags # EV::LOOP_ONCE, EV::LOOP_ONESHOT 106=item EV::loop [$flags]
113 107
114=item EV::loopexit $after 108Begin checking for events and calling callbacks. It returns when a
109callback calls EV::loop_done.
115 110
116Exit any active loop or dispatch after C<$after> seconds or immediately if 111The $flags argument can be one of the following:
117C<$after> is missing or zero.
118 112
119=item EV::dispatch 113 0 as above
114 EV::LOOP_ONESHOT block at most once (wait, but do not loop)
115 EV::LOOP_NONBLOCK do not block at all (fetch/handle events but do not wait)
120 116
121Same as C<EV::loop 0>. 117=item EV::loop_done [$how]
122 118
123=item EV::event $callback 119When called with no arguments or an argument of 1, makes the innermost
120call to EV::loop return.
124 121
125Creates a new event watcher waiting for nothing, calling the given callback. 122When called with an agrument of 2, all calls to EV::loop will return as
123fast as possible.
126 124
125=back
126
127=head2 WATCHER
128
129A watcher is an object that gets created to record your interest in some
130event. For instance, if you want to wait for STDIN to become readable, you
131would create an EV::io watcher for that:
132
133 my $watcher = EV::io *STDIN, EV::READ, sub {
134 my ($watcher, $revents) = @_;
135 warn "yeah, STDIN should not be readable without blocking!\n"
136 };
137
138All watchers can be active (waiting for events) or inactive (paused). Only
139active watchers will have their callbacks invoked. All callbacks will be
140called with at least two arguments: the watcher and a bitmask of received
141events.
142
143Each watcher type has its associated bit in revents, so you can use the
144same callback for multiple watchers. The event mask is named after the
145type, i..e. EV::child sets EV::CHILD, EV::prepare sets EV::PREPARE,
146EV::periodic sets EV::PERIODIC and so on, with the exception of IO events
147(which can set both EV::READ and EV::WRITE bits), and EV::timer (which
148uses EV::TIMEOUT).
149
150In the rare case where one wants to create a watcher but not start it at
151the same time, each constructor has a variant with a trailing C<_ns> in
152its name, e.g. EV::io has a non-starting variant EV::io_ns and so on.
153
154Please note that a watcher will automatically be stopped when the watcher
155object is destroyed, so you I<need> to keep the watcher objects returned by
156the constructors.
157
158Also, all methods changing some aspect of a watcher (->set, ->priority,
159->fh and so on) automatically stop and start it again if it is active,
160which means pending events get lost.
161
162=head2 WATCHER TYPES
163
164Now lets move to the existing watcher types and asociated methods.
165
166The following methods are available for all watchers. Then followes a
167description of each watcher constructor (EV::io, EV::timer, EV::periodic,
168EV::signal, EV::child, EV::idle, EV::prepare and EV::check), followed by
169any type-specific methods (if any).
170
171=over 4
172
173=item $w->start
174
175Starts a watcher if it isn't active already. Does nothing to an already
176active watcher. By default, all watchers start out in the active state
177(see the description of the C<_ns> variants if you need stopped watchers).
178
179=item $w->stop
180
181Stop a watcher if it is active. Also clear any pending events (events that
182have been received but that didn't yet result in a callback invocation),
183regardless of wether the watcher was active or not.
184
185=item $bool = $w->is_active
186
187Returns true if the watcher is active, false otherwise.
188
189=item $current_cb = $w->cb
190
191=item $old_cb = $w->cb ($new_cb)
192
193Queries the callback on the watcher and optionally changes it. You can do
194this at any time without the watcher restarting.
195
196=item $current_priority = $w->priority
197
198=item $old_priority = $w->priority ($new_priority)
199
200Queries the priority on the watcher and optionally changes it. Pending
201watchers with higher priority will be invoked first. The valid range of
202priorities lies between EV::MAXPRI (default 3) and EV::MINPRI (default
203-3). If the priority is outside this range it will automatically be
204normalised to the nearest valid priority.
205
206The default priority of any newly-created weatcher is 0.
207
208=item $w->trigger ($revents)
209
210Call the callback *now* with the given event mask.
211
212
127=item my $w = EV::io $fileno_or_fh, $eventmask, $callback 213=item $w = EV::io $fileno_or_fh, $eventmask, $callback
128 214
129=item my $w = EV::io_ns $fileno_or_fh, $eventmask, $callback 215=item $w = EV::io_ns $fileno_or_fh, $eventmask, $callback
130 216
131As long as the returned watcher object is alive, call the C<$callback> 217As long as the returned watcher object is alive, call the C<$callback>
132when the events specified in C<$eventmask> happen. Initially, the timeout 218when the events specified in C<$eventmask>.
133is disabled.
134 219
135You can additionall set a timeout to occur on the watcher, but note that
136this timeout will not be reset when you get an I/O event in the EV::PERSIST
137case, and reaching a timeout will always stop the watcher even in the
138EV::PERSIST case.
139
140If you want a timeout to occur only after a specific time of inactivity, set
141a repeating timeout and do NOT use EV::PERSIST.
142
143Eventmask can be one or more of these constants ORed together: 220The $eventmask can be one or more of these constants ORed together:
144 221
145 EV::READ wait until read() wouldn't block anymore 222 EV::READ wait until read() wouldn't block anymore
146 EV::WRITE wait until write() wouldn't block anymore 223 EV::WRITE wait until write() wouldn't block anymore
147 EV::PERSIST stay active after a (non-timeout) event occured
148 224
149The C<io_ns> variant doesn't add/start the newly created watcher. 225The C<io_ns> variant doesn't start (activate) the newly created watcher.
150 226
151=item my $w = EV::timed_io $fileno_or_fh, $eventmask, $timeout, $callback 227=item $w->set ($fileno_or_fh, $eventmask)
152 228
153=item my $w = EV::timed_io_ns $fileno_or_fh, $eventmask, $timeout, $callback 229Reconfigures the watcher, see the constructor above for details. Can be
230called at any time.
154 231
155Same as C<io> and C<io_ns>, but also specifies a timeout (as if there was 232=item $current_fh = $w->fh
156a call to C<< $w->timeout ($timout, 1) >>. The persist flag is not allowed
157and will automatically be cleared. The watcher will be restarted after each event.
158 233
159If the timeout is zero or undef, no timeout will be set, and a normal 234=item $old_fh = $w->fh ($new_fh)
160watcher (with the persist flag set!) will be created.
161 235
162This has the effect of timing out after the specified period of inactivity 236Returns the previously set filehandle and optionally set a new one.
163has happened.
164 237
165Due to the design of libevent, this is also relatively inefficient, having 238=item $current_eventmask = $w->events
166one or two io watchers and a separate timeout watcher that you reset on
167activity (by calling its C<start> method) is usually more efficient.
168 239
240=item $old_eventmask = $w->events ($new_eventmask)
241
242Returns the previously set event mask and optionally set a new one.
243
244
169=item my $w = EV::timer $after, $repeat, $callback 245=item $w = EV::timer $after, $repeat, $callback
170 246
171=item my $w = EV::timer_ns $after, $repeat, $callback 247=item $w = EV::timer_ns $after, $repeat, $callback
172 248
173Calls the callback after C<$after> seconds. If C<$repeat> is true, the 249Calls the callback after C<$after> seconds. If C<$repeat> is non-zero,
174timer will be restarted after the callback returns. This means that the 250the timer will be restarted (with the $repeat value as $after) after the
175callback would be called roughly every C<$after> seconds, prolonged by the 251callback returns.
176time the callback takes.
177 252
253This means that the callback would be called roughly after C<$after>
254seconds, and then every C<$repeat> seconds. "Roughly" because the time of
255callback processing is not taken into account, so the timer will slowly
256drift. If that isn't acceptable, look at EV::periodic.
257
258The timer is based on a monotonic clock, that is if somebody is sitting
259in front of the machine while the timer is running and changes the system
260clock, the timer will nevertheless run (roughly) the same time.
261
178The C<timer_ns> variant doesn't add/start the newly created watcher. 262The C<timer_ns> variant doesn't start (activate) the newly created watcher.
179 263
264=item $w->set ($after, $repeat)
265
266Reconfigures the watcher, see the constructor above for details. Can be at
267any time.
268
269=item $w->again
270
271Similar to the C<start> method, but has special semantics for repeating timers:
272
273If the timer is active and repeating, reset the timeout to occur
274C<$repeat> seconds after now.
275
276If the timer is active and non-repeating, it will be stopped.
277
278If the timer is in active and repeating, start it.
279
280Otherwise do nothing.
281
282This behaviour is useful when you have a timeout for some IO
283operation. You create a timer object with the same value for C<$after> and
284C<$repeat>, and then, in the read/write watcher, run the C<again> method
285on the timeout.
286
287
288=item $w = EV::periodic $at, $interval, $callback
289
180=item my $w = EV::timer_abs $at, $interval, $callback 290=item $w = EV::periodic_ns $at, $interval, $callback
181
182=item my $w = EV::timer_abs_ns $at, $interval, $callback
183 291
184Similar to EV::timer, but the time is given as an absolute point in time 292Similar to EV::timer, but the time is given as an absolute point in time
185(C<$at>), plus an optional C<$interval>. 293(C<$at>), plus an optional C<$interval>.
186 294
187If the C<$interval> is zero, then the callback will be called at the time 295If the C<$interval> is zero, then the callback will be called at the time
188C<$at> if that is in the future, or as soon as possible if its in the 296C<$at> if that is in the future, or as soon as possible if it is in the
189past. It will not automatically repeat. 297past. It will not automatically repeat.
190 298
191If the C<$interval> is nonzero, then the watcher will always be scheduled 299If the C<$interval> is nonzero, then the watcher will always be scheduled
192to time out at the next C<$at + integer * $interval> time. 300to time out at the next C<$at + N * $interval> time.
193 301
194This can be used to schedule a callback to run at very regular intervals, 302This can be used to schedule a callback to run at very regular intervals,
195as long as the processing time is less then the interval (otherwise 303as long as the processing time is less then the interval (otherwise
196obviously events will be skipped). 304obviously events will be skipped).
197 305
198Another way to think about it (for the mathematically inclined) is that 306Another way to think about it (for the mathematically inclined) is that
199C<timer_abs> will try to tun the callback at the next possible time where 307EV::periodic will try to run the callback at the next possible time where
200C<$time = $at (mod $interval)>, regardless of any time jumps. 308C<$time = $at (mod $interval)>, regardless of any time jumps.
201 309
310This periodic timer is based on "wallclock time", that is, if the clock
311changes (C<ntp>, C<date -s> etc.), then the timer will nevertheless run at
312the specified time. This means it will never drift (it might jitter, but
313it will not drift).
314
202The C<timer_abs_ns> variant doesn't add/start the newly created watcher. 315The C<periodic_ns> variant doesn't start (activate) the newly created watcher.
203 316
317=item $w->set ($at, $interval)
318
319Reconfigures the watcher, see the constructor above for details. Can be at
320any time.
321
322
204=item my $w = EV::signal $signal, $callback 323=item $w = EV::signal $signal, $callback
205 324
206=item my $w = EV::signal_ns $signal, $callback 325=item $w = EV::signal_ns $signal, $callback
207 326
208Call the callback when $signal is received (the signal can be specified 327Call the callback when $signal is received (the signal can be specified
209by number or by name, just as with kill or %SIG). Signal watchers are 328by number or by name, just as with kill or %SIG).
210persistent no natter what.
211 329
212EV will grab the signal for the process (the kernel only allows one 330EV will grab the signal for the process (the kernel only allows one
213component to receive signals) when you start a signal watcher, and 331component to receive a signal at a time) when you start a signal watcher,
214removes it again when you stop it. Pelr does the same when you add/remove 332and removes it again when you stop it. Perl does the same when you
215callbacks to %SIG, so watch out. 333add/remove callbacks to %SIG, so watch out.
216 334
217Unfortunately, only one handler can be registered per signal. Screw 335You can have as many signal watchers per signal as you want.
218libevent.
219 336
220The C<signal_ns> variant doesn't add/start the newly created watcher. 337The C<signal_ns> variant doesn't start (activate) the newly created watcher.
338
339=item $w->set ($signal)
340
341Reconfigures the watcher, see the constructor above for details. Can be at
342any time.
343
344=item $current_signum = $w->signal
345
346=item $old_signum = $w->signal ($new_signal)
347
348Returns the previously set signal (always as a number not name) and
349optionally set a new one.
350
351
352=item $w = EV::child $pid, $callback
353
354=item $w = EV::child_ns $pid, $callback
355
356Call the callback when a status change for pid C<$pid> (or any pid
357if C<$pid> is 0) has been received. More precisely: when the process
358receives a SIGCHLD, EV will fetch the outstanding exit/wait status for all
359changed/zombie children and call the callback.
360
361Unlike all other callbacks, this callback will be called with an
362additional third argument which is the exit status. See the C<waitpid>
363function for details.
364
365You can have as many pid watchers per pid as you want.
366
367The C<child_ns> variant doesn't start (activate) the newly created watcher.
368
369=item $w->set ($pid)
370
371Reconfigures the watcher, see the constructor above for details. Can be at
372any time.
373
374=item $current_pid = $w->pid
375
376=item $old_pid = $w->pid ($new_pid)
377
378Returns the previously set process id and optionally set a new one.
379
380
381=item $w = EV::idle $callback
382
383=item $w = EV::idle_ns $callback
384
385Call the callback when there are no pending io, timer/periodic, signal or
386child events, i.e. when the process is idle.
387
388The process will not block as long as any idle watchers are active, and
389they will be called repeatedly until stopped.
390
391The C<idle_ns> variant doesn't start (activate) the newly created watcher.
392
393
394=item $w = EV::prepare $callback
395
396=item $w = EV::prepare_ns $callback
397
398Call the callback just before the process would block. You can still
399create/modify any watchers at this point.
400
401See the EV::check watcher, below, for explanations and an example.
402
403The C<prepare_ns> variant doesn't start (activate) the newly created watcher.
404
405
406=item $w = EV::check $callback
407
408=item $w = EV::check_ns $callback
409
410Call the callback just after the process wakes up again (after it has
411gathered events), but before any other callbacks have been invoked.
412
413This is used to integrate other event-based software into the EV
414mainloop: You register a prepare callback and in there, you create io and
415timer watchers as required by the other software. Here is a real-world
416example of integrating Net::SNMP (with some details left out):
417
418 our @snmp_watcher;
419
420 our $snmp_prepare = EV::prepare sub {
421 # do nothing unless active
422 $dispatcher->{_event_queue_h}
423 or return;
424
425 # make the dispatcher handle any outstanding stuff
426
427 # create an IO watcher for each and every socket
428 @snmp_watcher = (
429 (map { EV::io $_, EV::READ, sub { } }
430 keys %{ $dispatcher->{_descriptors} }),
431 );
432
433 # if there are any timeouts, also create a timer
434 push @snmp_watcher, EV::timer $event->[Net::SNMP::Dispatcher::_TIME] - EV::now, 0, sub { }
435 if $event->[Net::SNMP::Dispatcher::_ACTIVE];
436 };
437
438The callbacks are irrelevant, the only purpose of those watchers is
439to wake up the process as soon as one of those events occurs (socket
440readable, or timer timed out). The corresponding EV::check watcher will then
441clean up:
442
443 our $snmp_check = EV::check sub {
444 # destroy all watchers
445 @snmp_watcher = ();
446
447 # make the dispatcher handle any new stuff
448 };
449
450The callbacks of the created watchers will not be called as the watchers
451are destroyed before this cna happen (remember EV::check gets called
452first).
453
454The C<check_ns> variant doesn't start (activate) the newly created watcher.
221 455
222=back 456=back
223 457
224=head1 THE EV::Event CLASS 458=head1 THREADS
225 459
226All EV functions creating an event watcher (designated by C<my $w => 460Threads are not supported by this in any way. Perl pseudo-threads is evil
227above) support the following methods on the returned watcher object: 461stuff and must die.
228
229=over 4
230
231=item $w->add ($timeout)
232
233Stops and (re-)starts the event watcher, setting the optional timeout to
234the given value, or clearing the timeout if none is given.
235
236=item $w->start
237
238Stops and (re-)starts the event watcher without touching the timeout.
239
240=item $w->del
241
242=item $w->stop
243
244Stop the event watcher if it was started.
245
246=item $current_callback = $w->cb
247
248=item $old_callback = $w->cb ($new_callback)
249
250Return the previously set callback and optionally set a new one.
251
252=item $current_fh = $w->fh
253
254=item $old_fh = $w->fh ($new_fh)
255
256Returns the previously set filehandle and optionally set a new one (also
257clears the EV::SIGNAL flag when setting a filehandle).
258
259=item $current_signal = $w->signal
260
261=item $old_signal = $w->signal ($new_signal)
262
263Returns the previously set signal number and optionally set a new one (also sets
264the EV::SIGNAL flag when setting a signal).
265
266=item $current_eventmask = $w->events
267
268=item $old_eventmask = $w->events ($new_eventmask)
269
270Returns the previously set event mask and optionally set a new one.
271
272=item $w->timeout ($after, $repeat)
273
274Resets the timeout (see C<EV::timer> for details).
275
276=item $w->timeout_abs ($at, $interval)
277
278Resets the timeout (see C<EV::timer_abs> for details).
279
280=item $w->priority_set ($priority)
281
282Set the priority of the watcher to C<$priority> (0 <= $priority < $EV::NPRI).
283
284=back
285
286=head1 BUGS
287
288Lots. Libevent itself isn't well tested and rather buggy, and this module
289is quite new at the moment.
290
291Please note that the epoll method is not, in general, reliable in programs
292that use fork (even if no libveent calls are being made in the forked
293process). If your program behaves erratically, try setting the environment
294variable C<EVENT_NOEPOLL> first when running the program.
295
296In general, if you fork, then you can only use the EV module in one of the
297children.
298 462
299=cut 463=cut
300 464
301our $DIED = sub { 465our $DIED = sub {
302 warn "EV: error in callback (ignoring): $@"; 466 warn "EV: error in callback (ignoring): $@";
303}; 467};
304 468
305our $NPRI = 4; 469init;
306our $BASE = init;
307priority_init $NPRI;
308 470
309push @AnyEvent::REGISTRY, [EV => "EV::AnyEvent"]; 471push @AnyEvent::REGISTRY, [EV => "EV::AnyEvent"];
310 472
3111; 4731;
312 474
313=head1 SEE ALSO 475=head1 SEE ALSO
314 476
315 L<EV::DNS>, L<event(3)>, L<event.h>, L<evdns.h>.
316 L<EV::AnyEvent>. 477 L<EV::DNS>, L<EV::AnyEvent>.
317 478
318=head1 AUTHOR 479=head1 AUTHOR
319 480
320 Marc Lehmann <schmorp@schmorp.de> 481 Marc Lehmann <schmorp@schmorp.de>
321 http://home.schmorp.de/ 482 http://home.schmorp.de/

Diff Legend

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