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

Comparing Faster/Faster.pm (file contents):
Revision 1.6 by root, Fri Mar 10 00:11:44 2006 UTC vs.
Revision 1.14 by root, Fri Mar 10 18:58:20 2006 UTC

… …
31my $LINK = "$Config{ld} $Config{ldflags} $Config{lddlflags} $Config{ccdlflags}"; 31my $LINK = "$Config{ld} $Config{ldflags} $Config{lddlflags} $Config{ccdlflags}";
32my $LIBS = "$Config{libs}"; 32my $LIBS = "$Config{libs}";
33my $_o = $Config{_o}; 33my $_o = $Config{_o};
34my $_so = ".so"; 34my $_so = ".so";
35 35
36# we don't need no steenking PIC on x86
37$COMPILE =~ s/-f(?:PIC|pic)//g
38 if $Config{archname} =~ /^(i[3456]86)-/;
39
40my $opt_assert = 1;
41
36our $source; 42our $source;
37our $label_next; 43
38our $label_last; 44my @ops;
39our $label_redo; 45my $op;
46my $op_name;
47my @loop;
40 48
41my %flag; 49my %flag;
42 50
51# complex flag steting is no longer required, rewrite this ugly code
43for (split /\n/, <<EOF) { 52for (split /\n/, <<EOF) {
44 leavesub unsafe 53 leavesub unsafe
45 leavesublv unsafe 54 leavesublv unsafe
46 return unsafe 55 return unsafe
47 flip unsafe 56 flip unsafe
… …
50 redo unsafe 59 redo unsafe
51 next unsafe 60 next unsafe
52 eval unsafe 61 eval unsafe
53 leaveeval unsafe 62 leaveeval unsafe
54 entertry unsafe 63 entertry unsafe
55 substconst unsafe
56 formline unsafe 64 formline unsafe
57 grepstart unsafe 65 grepstart unsafe
66 mapstart unsafe
67 substcont unsafe
68 entereval unsafe noasync todo
58 require unsafe 69 require unsafe
59 match unsafe todo
60 subst unsafe todo
61 entereval unsafe todo
62 mapstart unsafe todo
63 70
71 mapstart noasync
64 pushmark noasync 72 grepstart noasync
73 match noasync
74
65 padsv noasync 75 last noasync
76 next noasync
77 redo noasync
78 seq noasync
79 pushmark noasync extend=0
80 padsv noasync extend=1
81 padav noasync extend=1
82 padhv noasync extend=1
83 padany noasync extend=1
66 entersub noasync 84 entersub noasync
67 aassign noasync 85 aassign noasync
68 sassign noasync 86 sassign noasync
69 rv2av noasync 87 rv2av noasync
88 rv2cv noasync
89 rv2gv noasync
90 rv2hv noasync
91 refgen noasync
70 nextstate noasync 92 nextstate noasync
71 gv noasync 93 gv noasync
72 gvsv noasync 94 gvsv noasync
73 add noasync 95 add noasync
74 subtract noasync 96 subtract noasync
… …
77 complement noasync 99 complement noasync
78 cond_expr noasync 100 cond_expr noasync
79 and noasync 101 and noasync
80 or noasync 102 or noasync
81 not noasync 103 not noasync
104 defined noasync
82 method_named noasync 105 method_named noasync
83 preinc noasync 106 preinc noasync
84 postinc noasync 107 postinc noasync
85 predec noasync 108 predec noasync
86 postdec noasync 109 postdec noasync
87 stub noasync 110 stub noasync
88 unstack noasync 111 unstack noasync
89 leaveloop noasync 112 leaveloop noasync
90 shift noasync
91 aelemA noasync 113 aelem noasync
92 aelemfast noasync 114 aelemfast noasync
115 helem noasync
116 pushre noasync
117 subst noasync
118 const noasync extend=1
119 list noasync
120 join noasync
121 split noasync
122 concat noasync
123 push noasync
124 pop noasync
125 shift noasync
126 unshift noasync
127 length noasync
128 substr noasync
129 stringify noasync
130 eq noasync
131 ne noasync
132 gt noasync
133 lt noasync
134 ge noasync
135 le noasync
136 enteriter noasync
137 ord noasync
138
139 iter async
93EOF 140EOF
94 my (undef, $op, @flags) = split /\s+/; 141 my (undef, $op, @flags) = split /\s+/;
95 142
96 undef $flag{$_}{$op} 143 undef $flag{$_}{$op}
97 for ("known", @flags); 144 for ("known", @flags);
98} 145}
99 146
147my %callop = (
148 entersub => "(PL_ppaddr [OP_ENTERSUB]) (aTHX)",
149 mapstart => "Perl_pp_grepstart (aTHX)",
150);
151
152sub callop {
153 $callop{$op_name} || "Perl_pp_$op_name (aTHX)"
154}
155
156sub assert {
157 return unless $opt_assert;
158 $source .= " assert ((\"$op_name\", ($_[0])));\n";
159}
160
161sub out_callop {
162 assert "nextop == (OP *)$$op";
163 $source .= " PL_op = nextop; nextop = " . (callop $op) . ";\n";
164}
165
166sub out_jump_next {
167 assert "nextop == (OP *)${$op->next}";
168 $source .= " goto op_${$op->next};\n";
169}
170
100sub out_next { 171sub out_next {
101 my ($op) = @_;
102
103 if (${$op->next}) {
104 $source .= " nextop = (OP *)${$op->next}L;\n"; 172 $source .= " nextop = (OP *)${$op->next}L;\n";
105 $source .= " goto op_${$op->next};\n";
106 } else {
107 $source .= " return 0;\n";
108 }
109}
110 173
111sub callop { 174 out_jump_next;
112 my ($op) = @_;
113
114 my $name = $op->name;
115
116 $name eq "entersub"
117 ? "(PL_ppaddr [OP_ENTERSUB]) (aTHX)"
118 : $name eq "mapstart"
119 ? "Perl_pp_grepstart (aTHX)"
120 : "Perl_pp_$name (aTHX)"
121} 175}
176
177sub out_linear {
178 out_callop;
179 out_jump_next;
180}
181
182sub out_cond_jump {
183 $source .= " if (nextop == (OP *)${$_[0]}L) goto op_${$_[0]};\n";
184}
185
186sub op_entersub {
187 out_callop;
188 $source .= " RUNOPS_TILL ((OP *)${$op->next}L);\n";
189 out_jump_next;
190}
191
192*op_require = \&op_entersub;
122 193
123sub op_nextstate { 194sub op_nextstate {
124 my ($op) = @_;
125
126 $source .= " PL_curcop = (COP *)nextop;\n"; 195 $source .= " PL_curcop = (COP *)nextop;\n";
127 $source .= " PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;\n"; 196 $source .= " PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;\n";
128 $source .= " FREETMPS;\n"; 197 $source .= " FREETMPS;\n";
129 198
130 out_next $op; 199 out_next;
131} 200}
132 201
133sub op_pushmark { 202sub op_pushmark {
134 my ($op) = @_;
135
136 $source .= " PUSHMARK (PL_stack_sp);\n"; 203 $source .= " PUSHMARK (PL_stack_sp);\n";
137 204
138 out_next $op; 205 out_next;
139} 206}
140 207
141sub op_const { 208if ($Config{useithreads} ne "define") {
142 my ($op) = @_; 209 # disable optimisations on ithreads
143 210
211 *op_const = sub {
144 $source .= " { dSP; XPUSHs ((SV *)${$op->sv}L); PUTBACK; }\n"; 212 $source .= " { dSP; XPUSHs ((SV *)${$op->sv}L); PUTBACK; }\n";
145 213
146 out_next $op; 214 out_next;
147} 215 };
148 216
149*op_gv = \&op_const; 217 *op_gv = \&op_const;
150 218
219 *op_aelemfast = sub {
220 my $targ = $op->targ;
221 my $private = $op->private;
222
223 $source .= " {\n";
224
225 if ($op->flags & B::OPf_SPECIAL) {
226 $source .= " AV *av = (AV*)PAD_SV((PADOFFSET)$targ);\n";
227 } else {
228 $source .= " AV *av = GvAV ((GV *)${$op->sv}L);\n";
229 }
230
231 if ($op->flags & B::OPf_MOD) {
232 $source .= " SV *sv = *av_fetch (av, $private, 1);\n";
233 } else {
234 $source .= " SV **svp = av_fetch (av, $private, 0); SV *sv = svp ? *svp : &PL_sv_undef;\n";
235 }
236
237 if (!($op->flags & B::OPf_MOD)) {
238 $source .= " if (SvGMAGICAL (sv)) sv = sv_mortalcopy (sv);\n";
239 }
240
241 $source .= " dSP;\n";
242 $source .= " XPUSHs (sv);\n";
243 $source .= " PUTBACK;\n";
244 $source .= " }\n";
245
246 out_next;
247 };
248
249 *op_gvsv = sub {
250 $source .= " {\n";
251 $source .= " dSP;\n";
252 $source .= " EXTEND (SP, 1);\n";
253
254 if ($op->private & B::OPpLVAL_INTRO) {
255 $source .= " PUSHs (save_scalar ((GV *)${$op->sv}L));\n";
256 } else {
257 $source .= " PUSHs (GvSV ((GV *)${$op->sv}L));\n";
258 }
259
260 $source .= " PUTBACK;\n";
261 $source .= " }\n";
262
263 out_next;
264 };
265}
266
267# does kill Crossfire/res2pm
151sub op_stringify { 268sub op_stringify {
152 my ($op) = @_; 269 my $targ = $op->targ;
153 270
154 $source .= " { dSP; dTARGET; sv_copypv (TARG, TOPs); SETTARG; }\n"; 271 $source .= <<EOF;
272 {
273 dSP;
274 SV *targ = PAD_SV ((PADOFFSET)$targ);
275 sv_copypv (TARG, TOPs);
276 SETTARG;
277 PUTBACK;
278 }
279EOF
155 280
156 out_next $op; 281 out_next;
157} 282}
158 283
159sub op_and { 284sub op_and {
160 my ($op) = @_;
161
162 $source .= <<EOF; 285 $source .= <<EOF;
163 { 286 {
164 dSP; 287 dSP;
165 288
166 if (SvTRUE (TOPs)) 289 if (SvTRUE (TOPs))
… …
171 goto op_${$op->other}; 294 goto op_${$op->other};
172 } 295 }
173 } 296 }
174EOF 297EOF
175 298
176 out_next $op; 299 out_next;
300}
301
302sub op_or {
303 $source .= <<EOF;
304 {
305 dSP;
306
307 if (!SvTRUE (TOPs))
308 {
309 --SP;
310 PUTBACK;
311 nextop = (OP *)${$op->other}L;
312 goto op_${$op->other};
313 }
314 }
315EOF
316
317 out_next;
177} 318}
178 319
179sub op_padsv { 320sub op_padsv {
180 my ($op) = @_;
181
182 my $flags = $op->flags; 321 my $flags = $op->flags;
183 my $target = $op->targ; 322 my $target = $op->targ;
184 323
185 $source .= <<EOF; 324 $source .= <<EOF;
186 { 325 {
… …
198 } 337 }
199 $source .= <<EOF; 338 $source .= <<EOF;
200 } 339 }
201EOF 340EOF
202 341
203 out_next $op; 342 out_next;
204}
205
206sub op_aelemfast {
207 my ($op) = @_;
208
209 my $targ = $op->targ;
210 my $private = $op->private;
211
212 $source .= " {\n";
213
214 if ($op->flags & B::OPf_SPECIAL) {
215 $source .= " AV *av = (AV*)PAD_SV((PADOFFSET)$targ);\n";
216 } else {
217 $source .= " AV *av = GvAV ((GV *)${$op->sv}L);\n";
218 }
219
220 if ($op->flags & B::OPf_MOD) {
221 $source .= " SV *sv = *av_fetch (av, $private, 1);\n";
222 } else {
223 $source .= " SV **svp = av_fetch (av, $private, 0); SV *sv = svp ? *svp : &PL_sv_undef;\n";
224 }
225
226 if (!($op->flags & B::OPf_MOD)) {
227 $source .= " if (SvGMAGICAL (sv)) sv = sv_mortalcopy (sv);\n";
228 }
229
230 $source .= " dSP;\n";
231 $source .= " XPUSHs (sv);\n";
232 $source .= " PUTBACK;\n";
233 $source .= " }\n";
234
235 out_next $op;
236} 343}
237 344
238# pattern const+ (or general push1) 345# pattern const+ (or general push1)
239# pattern pushmark return(?) 346# pattern pushmark return(?)
240# pattern pushmark gv rv2av pushmark padsv+o.ä. aassign 347# pattern pushmark gv rv2av pushmark padsv+o.ä. aassign
241 348
242# pattern const method_named 349# pattern const method_named
243sub op_method_named { 350sub op_method_named {
244 my ($op) = @_;
245
246 $source .= <<EOF; 351 $source .= <<EOF;
247 { 352 {
248 static HV *last_stash; 353 static HV *last_stash;
249 static SV *last_res; 354 static SV *last_cv;
355 static U32 last_sub_generation;
250 356
251 SV *obj = *(PL_stack_base + TOPMARK + 1); 357 SV *obj = *(PL_stack_base + TOPMARK + 1);
252 358
253 if (SvROK (obj) && SvOBJECT (SvRV (obj))) 359 if (!SvGMAGICAL (obj) && SvROK (obj) && SvOBJECT (SvRV (obj)))
254 { 360 {
255 dSP; 361 dSP;
256 HV *stash = SvSTASH (SvRV (obj)); 362 HV *stash = SvSTASH (SvRV (obj));
257 363
258 /* simple "polymorphic" inline cache */ 364 /* simple "polymorphic" inline cache */
259 if (stash == last_stash) 365 if (stash == last_stash
366 && PL_sub_generation == last_sub_generation)
260 { 367 {
261 XPUSHs (last_res); 368 XPUSHs (last_cv);
262 PUTBACK; 369 PUTBACK;
263 } 370 }
264 else 371 else
265 { 372 {
266 PL_op = nextop;
267 nextop = Perl_pp_method_named (aTHX); 373 PL_op = nextop; nextop = Perl_pp_method_named (aTHX);
268 374
269 SPAGAIN; 375 SPAGAIN;
376 last_sub_generation = PL_sub_generation;
270 last_stash = stash; 377 last_stash = stash;
271 last_res = TOPs; 378 last_cv = TOPs;
272 } 379 }
273 } 380 }
274 else 381 else
275 { 382 {
276 /* error case usually */ 383 /* error case usually */
277 PL_op = nextop;
278 nextop = Perl_pp_method_named (aTHX); 384 PL_op = nextop; nextop = Perl_pp_method_named (aTHX);
279 } 385 }
280 } 386 }
281EOF 387EOF
282 388
283 out_next $op; 389 out_next;
390}
391
392sub op_grepstart {
393 out_callop;
394 $op = $op->next;
395 out_cond_jump $op->other;
396 out_jump_next;
397}
398
399*op_mapstart = \&op_grepstart;
400
401sub op_substcont {
402 out_callop;
403 out_cond_jump $op->other->pmreplstart;
404 assert "nextop == (OP *)${$op->other->next}L";
405 $source .= " goto op_${$op->other->next};\n";
406}
407
408sub out_break_op {
409 my ($idx) = @_;
410
411 out_callop;
412
413 out_cond_jump $_->[$idx]
414 for reverse @loop;
415
416 $source .= " return nextop;\n";
417}
418
419sub xop_next {
420 out_break_op 0;
421}
422
423sub op_last {
424 out_break_op 1;
425}
426
427sub xop_redo {
428 out_break_op 2;
284} 429}
285 430
286sub cv2c { 431sub cv2c {
287 my ($cv) = @_; 432 my ($cv) = @_;
288 433
434 @loop = ();
435
289 my %opsseen; 436 my %opsseen;
290 my @ops;
291 my @todo = $cv->START; 437 my @todo = $cv->START;
292 438
293 while (my $op = shift @todo) { 439 while (my $op = shift @todo) {
294 for (; $$op; $op = $op->next) { 440 for (; $$op; $op = $op->next) {
295 last if $opsseen{$$op}++; 441 last if $opsseen{$$op}++;
296 push @ops, $op; 442 push @ops, $op;
443
297 my $name = $op->name; 444 my $name = $op->name;
445 my $class = B::class $op;
446
298 if (B::class($op) eq "LOGOP") { 447 if ($class eq "LOGOP") {
299 push @todo, $op->other; 448 unshift @todo, $op->other; # unshift vs. push saves jumps
300 } elsif ($name eq "subst" and ${ $op->pmreplstart }) { 449 } elsif ($class eq "PMOP") {
301 push @todo, $op->pmreplstart; 450 unshift @todo, $op->pmreplstart if ${$op->pmreplstart};
302 } elsif ($name =~ /^enter(loop|iter)$/) { 451 } elsif ($class eq "LOOP") {
303# if ($] > 5.009) { 452 push @loop, [$op->nextop, $op->lastop->next, $op->redoop->next];
304# $labels{${$op->nextop}} = "NEXT";
305# $labels{${$op->lastop}} = "LAST";
306# $labels{${$op->redoop}} = "REDO";
307# } else {
308# $labels{$op->nextop->seq} = "NEXT";
309# $labels{$op->lastop->seq} = "LAST";
310# $labels{$op->redoop->seq} = "REDO";
311# }
312 } 453 }
313 } 454 }
314 } 455 }
315 456
316 local $source = <<EOF; 457 local $source = <<EOF;
458OP *%%%FUNC%%% (pTHX)
459{
460 register OP *nextop = (OP *)${$ops[0]}L;
461EOF
462
463 while (@ops) {
464 $op = shift @ops;
465 $op_name = $op->name;
466
467 $source .= "op_$$op: /* $op_name */\n";
468 #$source .= "fprintf (stderr, \"$$op in op $op_name\\n\");\n";#d#
469 #$source .= "{ dSP; sv_dump (TOPs); }\n";#d#
470
471 $source .= " PERL_ASYNC_CHECK ();\n"
472 unless exists $flag{noasync}{$op_name};
473
474 if (my $can = __PACKAGE__->can ("op_$op_name")) {
475 # handcrafted replacement
476 $can->($op);
477
478 } elsif (exists $flag{unsafe}{$op_name}) {
479 # unsafe, return to interpreter
480 assert "nextop == (OP *)$$op";
481 $source .= " return nextop;\n";
482
483 } elsif ("LOGOP" eq B::class $op) {
484 # logical operation with optionaö branch
485 out_callop;
486 out_cond_jump $op->other;
487 out_jump_next;
488
489 } elsif ("PMOP" eq B::class $op) {
490 # regex-thingy
491 out_callop;
492 out_cond_jump $op->pmreplroot if ${$op->pmreplroot};
493 out_jump_next;
494
495 } else {
496 # normal operator, linear execution
497 out_linear;
498 }
499 }
500
501 $op_name = "func exit"; assert (0);
502
503 $source .= <<EOF;
504op_0:
505 return 0;
506}
507EOF
508 #warn $source;
509
510 $source
511}
512
513sub source2ptr {
514 my ($source) = @_;
515
516 my $md5 = Digest::MD5::md5_hex $source;
517 $source =~ s/%%%FUNC%%%/Faster_$md5/;
518
519 my $stem = "/tmp/$md5";
520
521 unless (-e "$stem$_so") {
522 open FILE, ">:raw", "$stem.c";
523 print FILE <<EOF;
317#define PERL_NO_GET_CONTEXT 524#define PERL_NO_GET_CONTEXT
318 525
319#include <assert.h> 526#include <assert.h>
320 527
321#include "EXTERN.h" 528#include "EXTERN.h"
322#include "perl.h" 529#include "perl.h"
323#include "XSUB.h" 530#include "XSUB.h"
324 531
325/*typedef OP *(*PPFUNC)(pTHX);*/ 532#define RUNOPS_TILL(op) \\
326 533 while (nextop != (op)) \\
327OP *%%%FUNC%%% (pTHX) 534 { \\
328{
329 register OP *nextop = (OP *)${$ops[0]}L;
330EOF
331
332 for my $op (@ops) {
333 my $name = $op->name;
334 my $ppaddr = ppaddr $op->type;
335
336 $source .= "op_$$op: /* $name */\n";
337 #$source .= "fprintf (stderr, \"$$op in op $name\\n\");\n";#d#
338 #$source .= "{ dSP; sv_dump (TOPs); }\n";#d#
339
340 unless (exists $flag{noasync}{$name}) {
341 $source .= " PERL_ASYNC_CHECK ();\n";
342 }
343
344 if (my $can = __PACKAGE__->can ("op_$name")) {
345 $can->($op);
346 } elsif (exists $flag{unsafe}{$name}) {
347 $source .= " assert ((\"$name\", nextop == (OP *)$$op));\n";#d#
348 $source .= " PL_op = nextop; return " . (callop $op) . ";\n";
349 } elsif ("LOGOP" eq B::class $op or exists $flag{otherop}{$name}) {
350 $source .= " assert ((\"$name\", nextop == (OP *)$$op));\n";#d#
351 $source .= " PL_op = nextop; nextop = " . (callop $op) . ";\n";
352 $source .= " if (nextop == (OP *)${$op->other}L) goto op_${$op->other};\n";
353 $source .= " assert ((\"$name\", nextop == (OP *)${$op->next}));\n";#d#
354 $source .= ${$op->next} ? " goto op_${$op->next};\n" : " return 0;\n";
355 } else {
356 $source .= " assert ((\"$name\", nextop == (OP *)$$op));\n";#d#
357 $source .= " PL_op = nextop; nextop = " . (callop $op) . ";\n";
358 if ($name eq "entersub") {
359 $source .= <<EOF;
360while (nextop != (OP *)${$op->next})
361 {
362 PERL_ASYNC_CHECK (); 535 PERL_ASYNC_CHECK (); \\
363 PL_op = nextop; nextop = (PL_op->op_ppaddr)(aTHX); 536 PL_op = nextop; nextop = (PL_op->op_ppaddr)(aTHX); \\
364 }
365EOF
366 }
367 $source .= " assert ((\"$name\", nextop == (OP *)${$op->next}));\n";#d#
368 $source .= ${$op->next} ? " goto op_${$op->next};\n" : " return 0;\n";
369 }
370 } 537 }
371 538
372 $source .= "}\n"; 539EOF
373 #warn $source;
374
375 $source
376}
377
378sub source2ptr {
379 my ($source) = @_;
380
381 my $md5 = Digest::MD5::md5_hex $source;
382 $source =~ s/%%%FUNC%%%/Faster_$md5/;
383
384 my $stem = "/tmp/$md5";
385
386 unless (-e "$stem$_so") {
387 open FILE, ">:raw", "$stem.c";
388 print FILE $source; 540 print FILE $source;
389 close FILE; 541 close FILE;
390 system "$COMPILE -o $stem$_o $stem.c"; 542 system "$COMPILE -o $stem$_o $stem.c";
391 system "$LINK -o $stem$_so $stem$_o $LIBS"; 543 system "$LINK -o $stem$_so $stem$_o $LIBS";
392 } 544 }
… …
400} 552}
401 553
402sub entersub { 554sub entersub {
403 my ($cv) = @_; 555 my ($cv) = @_;
404 556
557 # always compile the whole stash
558# my @stash = $cv->STASH->ARRAY;
559# warn join ":", @stash;
560# exit;
561
405 eval { 562 eval {
406 my $source = cv2c $cv; 563 my $source = cv2c $cv;
407 564
408 my $ptr = source2ptr $source; 565 my $ptr = source2ptr $source;
409 566
410 patch_cv $cv, $ptr; 567 patch_cv $cv, $ptr;
411 }; 568 };
412 569
413 warn $@ if $@; 570 warn $@ if $@;
414} 571}
415 572
… …
417 574
4181; 5751;
419 576
420=back 577=back
421 578
422=head1 LIMITATIONS 579=head1 BUGS/LIMITATIONS
423 580
424Tainting and debugging will disable Faster. 581Perl will check much less often for asynchronous signals in
582Faster-compiled code. It tries to check on every function call, loop
583iteration and every I/O operator, though.
584
585The following things will disable Faster. If you manage to enable them at
586runtime, bad things will happen.
587
588 enabled tainting
589 enabled debugging
590
591This will dramatically reduce Faster's performance:
592
593 threads (but you don't care about speed if you use threads anyway)
594
595These constructs will force the use of the interpreter as soon as they are
596being executed, for the rest of the currently executed:
597
598 .., ... (flipflop operators)
599 goto
600 next, redo (but not well-behaved last's)
601 eval
602 require
603 any use of formats
425 604
426=head1 AUTHOR 605=head1 AUTHOR
427 606
428 Marc Lehmann <schmorp@schmorp.de> 607 Marc Lehmann <schmorp@schmorp.de>
429 http://home.schmorp.de/ 608 http://home.schmorp.de/

Diff Legend

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