dépôts / lhc / web / wiklou.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
fixed section anchors
[lhc/web/wiklou.git] / includes / Parser.php
1 <?php
2
3 include_once('Tokenizer.php');
4
5 # PHP Parser
6 #
7 # Processes wiki markup
8 #
9 # There are two main entry points into the Parser class: parse() and preSaveTransform().
10 # The parse() function produces HTML output, preSaveTransform() produces altered wiki markup.
11 #
12 # Globals used:
13 # objects: $wgLang, $wgDateFormatter, $wgLinkCache, $wgCurParser
14 #
15 # NOT $wgArticle, $wgUser or $wgTitle. Keep them away!
16 #
17 # settings: $wgUseTex*, $wgUseCategoryMagic*, $wgUseDynamicDates*, $wgInterwikiMagic*,
18 # $wgNamespacesWithSubpages, $wgLanguageCode, $wgAllowExternalImages*,
19 # $wgLocaltimezone
20 #
21 # * only within ParserOptions
22 #
23 #
24 #----------------------------------------
25 # Variable substitution O(N^2) attack
26 #-----------------------------------------
27 # Without countermeasures, it would be possible to attack the parser by saving a page
28 # filled with a large number of inclusions of large pages. The size of the generated
29 # page would be proportional to the square of the input size. Hence, we limit the number
30 # of inclusions of any given page, thus bringing any attack back to O(N).
31 #
32 define( "MAX_INCLUDE_REPEAT", 5 );
33
34 # Recursion depth of variable/inclusion evaluation
35 define( "MAX_INCLUDE_PASSES", 3 );
36
37 # Allowed values for $mOutputType
38 define( "OT_HTML", 1 );
39 define( "OT_WIKI", 2 );
40
41 class Parser
42 {
43 # Cleared with clearState():
44 var $mOutput, $mAutonumber, $mLastSection, $mDTopen, $mStripState;
45 var $mVariables, $mIncludeCount;
46
47 # Temporary:
48 var $mOptions, $mTitle, $mOutputType;
49
50 function Parser()
51 {
52 $this->clearState();
53 }
54
55 function clearState()
56 {
57 $this->mOutput = new ParserOutput;
58 $this->mAutonumber = 0;
59 $this->mLastSection = "";
60 $this->mDTopen = false;
61 $this->mStripState = false;
62 $this->mVariables = false;
63 $this->mIncludeCount = array();
64 }
65
66 # First pass--just handle <nowiki> sections, pass the rest off
67 # to doWikiPass2() which does all the real work.
68 #
69 # Returns a ParserOutput
70 #
71 function parse( $text, &$title, $options, $linestart = true, $clearState = true )
72 {
73 $fname = "Parser::parse";
74 wfProfileIn( $fname );
75
76 if ( $clearState ) {
77 $this->clearState();
78 }
79
80 $this->mOptions = $options;
81 $this->mTitle =& $title;
82 $this->mOutputType = OT_HTML;
83
84 $stripState = NULL;
85 $text = $this->strip( $text, $this->mStripState );
86 $text = $this->doWikiPass2( $text, $linestart );
87 $text = $this->unstrip( $text, $this->mStripState );
88
89 $this->mOutput->setText( $text );
90 wfProfileOut( $fname );
91 return $this->mOutput;
92 }
93
94 /* static */ function getRandomString()
95 {
96 return dechex(mt_rand(0, 0x7fffffff)) . dechex(mt_rand(0, 0x7fffffff));
97 }
98
99 # Strips <nowiki>, <pre> and <math>
100 # Returns the text, and fills an array with data needed in unstrip()
101 #
102 function strip( $text, &$state )
103 {
104 $state = array(
105 'nwlist' => array(),
106 'nwsecs' => 0,
107 'nwunq' => Parser::getRandomString(),
108 'mathlist' => array(),
109 'mathsecs' => 0,
110 'mathunq' => Parser::getRandomString(),
111 'prelist' => array(),
112 'presecs' => 0,
113 'preunq' => Parser::getRandomString()
114 );
115 $render = ($this->mOutputType == OT_HTML);
116 $stripped = "";
117 $stripped2 = "";
118 $stripped3 = "";
119
120 # Replace any instances of the placeholders
121 $text = str_replace( $state['nwunq'], wfHtmlEscapeFirst( $state['nwunq'] ), $text );
122 $text = str_replace( $state['mathunq'], wfHtmlEscapeFirst( $state['mathunq'] ), $text );
123 $text = str_replace( $state['preunq'], wfHtmlEscapeFirst( $state['preunq'] ), $text );
124
125 while ( "" != $text ) {
126 $p = preg_split( "/<\\s*nowiki\\s*>/i", $text, 2 );
127 $stripped .= $p[0];
128 if ( ( count( $p ) < 2 ) || ( "" == $p[1] ) ) {
129 $text = "";
130 } else {
131 $q = preg_split( "/<\\/\\s*nowiki\\s*>/i", $p[1], 2 );
132 ++$state['nwsecs'];
133
134 if ( $render ) {
135 $state['nwlist'][$state['nwsecs']] = wfEscapeHTMLTagsOnly($q[0]);
136 } else {
137 $state['nwlist'][$state['nwsecs']] = "<nowiki>{$q[0]}</nowiki>";
138 }
139
140 $stripped .= $state['nwunq'] . sprintf("%08X", $state['nwsecs']);
141 $text = $q[1];
142 }
143 }
144
145 if( $this->mOptions->getUseTeX() ) {
146 while ( "" != $stripped ) {
147 $p = preg_split( "/<\\s*math\\s*>/i", $stripped, 2 );
148 $stripped2 .= $p[0];
149 if ( ( count( $p ) < 2 ) || ( "" == $p[1] ) ) {
150 $stripped = "";
151 } else {
152 $q = preg_split( "/<\\/\\s*math\\s*>/i", $p[1], 2 );
153 ++$state['mathsecs'];
154
155 if ( $render ) {
156 $state['mathlist'][$state['mathsecs']] = renderMath($q[0]);
157 } else {
158 $state['mathlist'][$state['mathsecs']] = "<math>{$q[0]}</math>";
159 }
160
161 $stripped2 .= $state['mathunq'] . sprintf("%08X", $state['mathsecs']);
162 $stripped = $q[1];
163 }
164 }
165 } else {
166 $stripped2 = $stripped;
167 }
168
169 while ( "" != $stripped2 ) {
170 $p = preg_split( "/<\\s*pre\\s*>/i", $stripped2, 2 );
171 $stripped3 .= $p[0];
172 if ( ( count( $p ) < 2 ) || ( "" == $p[1] ) ) {
173 $stripped2 = "";
174 } else {
175 $q = preg_split( "/<\\/\\s*pre\\s*>/i", $p[1], 2 );
176 ++$state['presecs'];
177
178 if ( $render ) {
179 $state['prelist'][$state['presecs']] = "<pre>". wfEscapeHTMLTagsOnly($q[0]). "</pre>\n";
180 } else {
181 $state['prelist'][$state['presecs']] = "<pre>{$q[0]}</pre>";
182 }
183
184 $stripped3 .= $state['preunq'] . sprintf("%08X", $state['presecs']);
185 $stripped2 = $q[1];
186 }
187 }
188 return $stripped3;
189 }
190
191 function unstrip( $text, &$state )
192 {
193 for ( $i = 1; $i <= $state['presecs']; ++$i ) {
194 $text = str_replace( $state['preunq'] . sprintf("%08X", $i), $state['prelist'][$i], $text );
195 }
196
197 for ( $i = 1; $i <= $state['mathsecs']; ++$i ) {
198 $text = str_replace( $state['mathunq'] . sprintf("%08X", $i), $state['mathlist'][$i], $text );
199 }
200
201 for ( $i = 1; $i <= $state['nwsecs']; ++$i ) {
202 $text = str_replace( $state['nwunq'] . sprintf("%08X", $i), $state['nwlist'][$i], $text );
203 }
204 return $text;
205 }
206
207 function categoryMagic ()
208 {
209 global $wgLang , $wgUser ;
210 if ( !$this->mOptions->getUseCategoryMagic() ) return ;
211 $id = $this->mTitle->getArticleID() ;
212 $cat = $wgLang->ucfirst ( wfMsg ( "category" ) ) ;
213 $ti = $this->mTitle->getText() ;
214 $ti = explode ( ":" , $ti , 2 ) ;
215 if ( $cat != $ti[0] ) return "" ;
216 $r = "<br break='all'/>\n" ;
217
218 $articles = array() ;
219 $parents = array () ;
220 $children = array() ;
221
222
223 # $sk =& $this->mGetSkin();
224 $sk =& $wgUser->getSkin() ;
225
226 $doesexist = false ;
227 if ( $doesexist ) {
228 $sql = "SELECT cur_title,cur_namespace FROM cur,links WHERE l_to={$id} AND l_from=cur_id";
229 } else {
230 $sql = "SELECT cur_title,cur_namespace FROM cur,brokenlinks WHERE bl_to={$id} AND bl_from=cur_id" ;
231 }
232
233 $res = wfQuery ( $sql, DB_READ ) ;
234 while ( $x = wfFetchObject ( $res ) )
235 {
236 # $t = new Title ;
237 # $t->newFromDBkey ( $x->l_from ) ;
238 # $t = $t->getText() ;
239 $t = $wgLang->getNsText ( $x->cur_namespace ) ;
240 if ( $t != "" ) $t .= ":" ;
241 $t .= $x->cur_title ;
242
243 $y = explode ( ":" , $t , 2 ) ;
244 if ( count ( $y ) == 2 && $y[0] == $cat ) {
245 array_push ( $children , $sk->makeLink ( $t , $y[1] ) ) ;
246 } else {
247 array_push ( $articles , $sk->makeLink ( $t ) ) ;
248 }
249 }
250 wfFreeResult ( $res ) ;
251
252 # Children
253 if ( count ( $children ) > 0 )
254 {
255 asort ( $children ) ;
256 $r .= "<h2>".wfMsg("subcategories")."</h2>\n" ;
257 $r .= implode ( ", " , $children ) ;
258 }
259
260 # Articles
261 if ( count ( $articles ) > 0 )
262 {
263 asort ( $articles ) ;
264 $h = wfMsg( "category_header", $ti[1] );
265 $r .= "<h2>{$h}</h2>\n" ;
266 $r .= implode ( ", " , $articles ) ;
267 }
268
269
270 return $r ;
271 }
272
273 function getHTMLattrs ()
274 {
275 $htmlattrs = array( # Allowed attributes--no scripting, etc.
276 "title", "align", "lang", "dir", "width", "height",
277 "bgcolor", "clear", /* BR */ "noshade", /* HR */
278 "cite", /* BLOCKQUOTE, Q */ "size", "face", "color",
279 /* FONT */ "type", "start", "value", "compact",
280 /* For various lists, mostly deprecated but safe */
281 "summary", "width", "border", "frame", "rules",
282 "cellspacing", "cellpadding", "valign", "char",
283 "charoff", "colgroup", "col", "span", "abbr", "axis",
284 "headers", "scope", "rowspan", "colspan", /* Tables */
285 "id", "class", "name", "style" /* For CSS */
286 );
287 return $htmlattrs ;
288 }
289
290 function fixTagAttributes ( $t )
291 {
292 if ( trim ( $t ) == "" ) return "" ; # Saves runtime ;-)
293 $htmlattrs = $this->getHTMLattrs() ;
294
295 # Strip non-approved attributes from the tag
296 $t = preg_replace(
297 "/(\\w+)(\\s*=\\s*([^\\s\">]+|\"[^\">]*\"))?/e",
298 "(in_array(strtolower(\"\$1\"),\$htmlattrs)?(\"\$1\".((\"x\$3\" != \"x\")?\"=\$3\":'')):'')",
299 $t);
300 # Strip javascript "expression" from stylesheets. Brute force approach:
301 # If anythin offensive is found, all attributes of the HTML tag are dropped
302
303 if( preg_match(
304 "/style\\s*=.*(expression|tps*:\/\/|url\\s*\().*/is",
305 wfMungeToUtf8( $t ) ) )
306 {
307 $t="";
308 }
309
310 return trim ( $t ) ;
311 }
312
313 function doTableStuff ( $t )
314 {
315 $t = explode ( "\n" , $t ) ;
316 $td = array () ; # Is currently a td tag open?
317 $ltd = array () ; # Was it TD or TH?
318 $tr = array () ; # Is currently a tr tag open?
319 $ltr = array () ; # tr attributes
320 foreach ( $t AS $k => $x )
321 {
322 $x = rtrim ( $x ) ;
323 $fc = substr ( $x , 0 , 1 ) ;
324 if ( "{|" == substr ( $x , 0 , 2 ) )
325 {
326 $t[$k] = "<table " . $this->fixTagAttributes ( substr ( $x , 3 ) ) . ">" ;
327 array_push ( $td , false ) ;
328 array_push ( $ltd , "" ) ;
329 array_push ( $tr , false ) ;
330 array_push ( $ltr , "" ) ;
331 }
332 else if ( count ( $td ) == 0 ) { } # Don't do any of the following
333 else if ( "|}" == substr ( $x , 0 , 2 ) )
334 {
335 $z = "</table>\n" ;
336 $l = array_pop ( $ltd ) ;
337 if ( array_pop ( $tr ) ) $z = "</tr>" . $z ;
338 if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
339 array_pop ( $ltr ) ;
340 $t[$k] = $z ;
341 }
342 /* else if ( "|_" == substr ( $x , 0 , 2 ) ) # Caption
343 {
344 $z = trim ( substr ( $x , 2 ) ) ;
345 $t[$k] = "<caption>{$z}</caption>\n" ;
346 }*/
347 else if ( "|-" == substr ( $x , 0 , 2 ) ) # Allows for |---------------
348 {
349 $x = substr ( $x , 1 ) ;
350 while ( $x != "" && substr ( $x , 0 , 1 ) == '-' ) $x = substr ( $x , 1 ) ;
351 $z = "" ;
352 $l = array_pop ( $ltd ) ;
353 if ( array_pop ( $tr ) ) $z = "</tr>" . $z ;
354 if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
355 array_pop ( $ltr ) ;
356 $t[$k] = $z ;
357 array_push ( $tr , false ) ;
358 array_push ( $td , false ) ;
359 array_push ( $ltd , "" ) ;
360 array_push ( $ltr , $this->fixTagAttributes ( $x ) ) ;
361 }
362 else if ( "|" == $fc || "!" == $fc || "|+" == substr ( $x , 0 , 2 ) ) # Caption
363 {
364 if ( "|+" == substr ( $x , 0 , 2 ) )
365 {
366 $fc = "+" ;
367 $x = substr ( $x , 1 ) ;
368 }
369 $after = substr ( $x , 1 ) ;
370 if ( $fc == "!" ) $after = str_replace ( "!!" , "||" , $after ) ;
371 $after = explode ( "||" , $after ) ;
372 $t[$k] = "" ;
373 foreach ( $after AS $theline )
374 {
375 $z = "" ;
376 if ( $fc != "+" )
377 {
378 $tra = array_pop ( $ltr ) ;
379 if ( !array_pop ( $tr ) ) $z = "<tr {$tra}>\n" ;
380 array_push ( $tr , true ) ;
381 array_push ( $ltr , "" ) ;
382 }
383
384 $l = array_pop ( $ltd ) ;
385 if ( array_pop ( $td ) ) $z = "</{$l}>" . $z ;
386 if ( $fc == "|" ) $l = "TD" ;
387 else if ( $fc == "!" ) $l = "TH" ;
388 else if ( $fc == "+" ) $l = "CAPTION" ;
389 else $l = "" ;
390 array_push ( $ltd , $l ) ;
391 $y = explode ( "|" , $theline , 2 ) ;
392 if ( count ( $y ) == 1 ) $y = "{$z}<{$l}>{$y[0]}" ;
393 else $y = $y = "{$z}<{$l} ".$this->fixTagAttributes($y[0]).">{$y[1]}" ;
394 $t[$k] .= $y ;
395 array_push ( $td , true ) ;
396 }
397 }
398 }
399
400 # Closing open td, tr && table
401 while ( count ( $td ) > 0 )
402 {
403 if ( array_pop ( $td ) ) $t[] = "</td>" ;
404 if ( array_pop ( $tr ) ) $t[] = "</tr>" ;
405 $t[] = "</table>" ;
406 }
407
408 $t = implode ( "\n" , $t ) ;
409 # $t = $this->removeHTMLtags( $t );
410 return $t ;
411 }
412
413 # Well, OK, it's actually about 14 passes. But since all the
414 # hard lifting is done inside PHP's regex code, it probably
415 # wouldn't speed things up much to add a real parser.
416 #
417 function doWikiPass2( $text, $linestart )
418 {
419 $fname = "Parser::doWikiPass2";
420 wfProfileIn( $fname );
421
422 $text = $this->removeHTMLtags( $text );
423 $text = $this->replaceVariables( $text );
424
425 # $text = preg_replace( "/(^|\n)-----*/", "\\1<hr>", $text );
426 $text = str_replace ( "<HR>", "<hr/>", $text );
427
428 $text = $this->doHeadings( $text );
429 $text = $this->doBlockLevels( $text, $linestart );
430
431 if($this->mOptions->getUseDynamicDates()) {
432 global $wgDateFormatter;
433 $text = $wgDateFormatter->reformat( $this->mOptions->getDateFormat(), $text );
434 }
435
436 $text = $this->replaceExternalLinks( $text );
437 $text = $this->replaceInternalLinks ( $text );
438 $text = $this->doTableStuff ( $text ) ;
439
440 $text = $this->formatHeadings( $text );
441
442 $sk =& $this->mOptions->getSkin();
443 $text = $sk->transformContent( $text );
444 $text .= $this->categoryMagic () ;
445
446 wfProfileOut( $fname );
447 return $text;
448 }
449
450
451 /* private */ function doHeadings( $text )
452 {
453 for ( $i = 6; $i >= 1; --$i ) {
454 $h = substr( "======", 0, $i );
455 $text = preg_replace( "/^{$h}(.+){$h}(\\s|$)/m",
456 "<h{$i}>\\1</h{$i}>\\2", $text );
457 }
458 return $text;
459 }
460
461 # Note: we have to do external links before the internal ones,
462 # and otherwise take great care in the order of things here, so
463 # that we don't end up interpreting some URLs twice.
464
465 /* private */ function replaceExternalLinks( $text )
466 {
467 $fname = "Parser::replaceExternalLinks";
468 wfProfileIn( $fname );
469 $text = $this->subReplaceExternalLinks( $text, "http", true );
470 $text = $this->subReplaceExternalLinks( $text, "https", true );
471 $text = $this->subReplaceExternalLinks( $text, "ftp", false );
472 $text = $this->subReplaceExternalLinks( $text, "irc", false );
473 $text = $this->subReplaceExternalLinks( $text, "gopher", false );
474 $text = $this->subReplaceExternalLinks( $text, "news", false );
475 $text = $this->subReplaceExternalLinks( $text, "mailto", false );
476 wfProfileOut( $fname );
477 return $text;
478 }
479
480 /* private */ function subReplaceExternalLinks( $s, $protocol, $autonumber )
481 {
482 $unique = "4jzAfzB8hNvf4sqyO9Edd8pSmk9rE2in0Tgw3";
483 $uc = "A-Za-z0-9_\\/~%\\-+&*#?!=()@\\x80-\\xFF";
484
485 # this is the list of separators that should be ignored if they
486 # are the last character of an URL but that should be included
487 # if they occur within the URL, e.g. "go to www.foo.com, where .."
488 # in this case, the last comma should not become part of the URL,
489 # but in "www.foo.com/123,2342,32.htm" it should.
490 $sep = ",;\.:";
491 $fnc = "A-Za-z0-9_.,~%\\-+&;#*?!=()@\\x80-\\xFF";
492 $images = "gif|png|jpg|jpeg";
493
494 # PLEASE NOTE: The curly braces { } are not part of the regex,
495 # they are interpreted as part of the string (used to tell PHP
496 # that the content of the string should be inserted there).
497 $e1 = "/(^|[^\\[])({$protocol}:)([{$uc}{$sep}]+)\\/([{$fnc}]+)\\." .
498 "((?i){$images})([^{$uc}]|$)/";
499
500 $e2 = "/(^|[^\\[])({$protocol}:)(([".$uc."]|[".$sep."][".$uc."])+)([^". $uc . $sep. "]|[".$sep."]|$)/";
501 $sk =& $this->mOptions->getSkin();
502
503 if ( $autonumber and $this->mOptions->getAllowExternalImages() ) { # Use img tags only for HTTP urls
504 $s = preg_replace( $e1, "\\1" . $sk->makeImage( "{$unique}:\\3" .
505 "/\\4.\\5", "\\4.\\5" ) . "\\6", $s );
506 }
507 $s = preg_replace( $e2, "\\1" . "<a href=\"{$unique}:\\3\"" .
508 $sk->getExternalLinkAttributes( "{$unique}:\\3", wfEscapeHTML(
509 "{$unique}:\\3" ) ) . ">" . wfEscapeHTML( "{$unique}:\\3" ) .
510 "</a>\\5", $s );
511 $s = str_replace( $unique, $protocol, $s );
512
513 $a = explode( "[{$protocol}:", " " . $s );
514 $s = array_shift( $a );
515 $s = substr( $s, 1 );
516
517 $e1 = "/^([{$uc}"."{$sep}]+)](.*)\$/sD";
518 $e2 = "/^([{$uc}"."{$sep}]+)\\s+([^\\]]+)](.*)\$/sD";
519
520 foreach ( $a as $line ) {
521 if ( preg_match( $e1, $line, $m ) ) {
522 $link = "{$protocol}:{$m[1]}";
523 $trail = $m[2];
524 if ( $autonumber ) { $text = "[" . ++$this->mAutonumber . "]"; }
525 else { $text = wfEscapeHTML( $link ); }
526 } else if ( preg_match( $e2, $line, $m ) ) {
527 $link = "{$protocol}:{$m[1]}";
528 $text = $m[2];
529 $trail = $m[3];
530 } else {
531 $s .= "[{$protocol}:" . $line;
532 continue;
533 }
534 if( $link == $text || preg_match( "!$protocol://" . preg_quote( $text, "/" ) . "/?$!", $link ) ) {
535 $paren = "";
536 } else {
537 # Expand the URL for printable version
538 $paren = "<span class='urlexpansion'> (<i>" . htmlspecialchars ( $link ) . "</i>)</span>";
539 }
540 $la = $sk->getExternalLinkAttributes( $link, $text );
541 $s .= "<a href='{$link}'{$la}>{$text}</a>{$paren}{$trail}";
542
543 }
544 return $s;
545 }
546
547 /* private */ function handle3Quotes( &$state, $token )
548 {
549 if ( $state["strong"] ) {
550 if ( $state["em"] && $state["em"] > $state["strong"] )
551 {
552 # ''' lala ''lala '''
553 $s = "</em></strong><em>";
554 } else {
555 $s = "</strong>";
556 }
557 $state["strong"] = FALSE;
558 } else {
559 $s = "<strong>";
560 $state["strong"] = $token["pos"];
561 }
562 return $s;
563 }
564
565 /* private */ function handle2Quotes( &$state, $token )
566 {
567 if ( $state["em"] ) {
568 if ( $state["strong"] && $state["strong"] > $state["em"] )
569 {
570 # ''lala'''lala'' ....'''
571 $s = "</strong></em><strong>";
572 } else {
573 $s = "</em>";
574 }
575 $state["em"] = FALSE;
576 } else {
577 $s = "<em>";
578 $state["em"] = $token["pos"];
579 }
580 return $s;
581 }
582
583 /* private */ function handle5Quotes( &$state, $token )
584 {
585 if ( $state["em"] && $state["strong"] ) {
586 if ( $state["em"] < $state["strong"] ) {
587 $s .= "</strong></em>";
588 } else {
589 $s .= "</em></strong>";
590 }
591 $state["strong"] = $state["em"] = FALSE;
592 } elseif ( $state["em"] ) {
593 $s .= "</em><strong>";
594 $state["em"] = FALSE;
595 $state["strong"] = $token["pos"];
596 } elseif ( $state["strong"] ) {
597 $s .= "</strong><em>";
598 $state["strong"] = FALSE;
599 $state["em"] = $token["pos"];
600 } else { # not $em and not $strong
601 $s .= "<strong><em>";
602 $state["strong"] = $state["em"] = $token["pos"];
603 }
604 return $s;
605 }
606
607 /* private */ function replaceInternalLinks( $str )
608 {
609 global $wgLang; # for language specific parser hook
610
611 $tokenizer=Tokenizer::newFromString( $str );
612 $tokenStack = array();
613
614 $s="";
615 $state["em"] = FALSE;
616 $state["strong"] = FALSE;
617 $tagIsOpen = FALSE;
618 $threeopen = false;
619
620 # The tokenizer splits the text into tokens and returns them one by one.
621 # Every call to the tokenizer returns a new token.
622 while ( $token = $tokenizer->nextToken() )
623 {
624 $threeopen = false;
625 switch ( $token["type"] )
626 {
627 case "text":
628 # simple text with no further markup
629 $txt = $token["text"];
630 break;
631 case "[[[":
632 # remember the tag opened with 3 [
633 $threeopen = true;
634 case "[[":
635 # link opening tag.
636 # FIXME : Treat orphaned open tags (stack not empty when text is over)
637 $tagIsOpen = TRUE;
638 array_push( $tokenStack, $token );
639 $txt="";
640 break;
641
642 case "]]]":
643 case "]]":
644 # link close tag.
645 # get text from stack, glue it together, and call the code to handle a
646 # link
647
648 if ( count( $tokenStack ) == 0 )
649 {
650 # stack empty. Found a ]] without an opening [[
651 $txt = "]]";
652 } else {
653 $linkText = "";
654 $lastToken = array_pop( $tokenStack );
655 while ( !(($lastToken["type"] == "[[[") or ($lastToken["type"] == "[[")) )
656 {
657 if( !empty( $lastToken["text"] ) ) {
658 $linkText = $lastToken["text"] . $linkText;
659 }
660 $lastToken = array_pop( $tokenStack );
661 }
662
663 $txt = $linkText ."]]";
664
665 if( isset( $lastToken["text"] ) ) {
666 $prefix = $lastToken["text"];
667 } else {
668 $prefix = "";
669 }
670 $nextToken = $tokenizer->previewToken();
671 if ( $nextToken["type"] == "text" )
672 {
673 # Preview just looks at it. Now we have to fetch it.
674 $nextToken = $tokenizer->nextToken();
675 $txt .= $nextToken["text"];
676 }
677 $txt = $this->handleInternalLink( $txt, $prefix );
678
679 # did the tag start with 3 [ ?
680 if($threeopen) {
681 # show the first as text
682 $txt = "[".$txt;
683 $threeopen=false;
684 }
685
686 }
687 $tagIsOpen = (count( $tokenStack ) != 0);
688 break;
689 case "----":
690 $txt = "\n<hr/>\n";
691 break;
692 case "'''":
693 # This and the three next ones handle quotes
694 $txt = $this->handle3Quotes( $state, $token );
695 break;
696 case "''":
697 $txt = $this->handle2Quotes( $state, $token );
698 break;
699 case "'''''":
700 $txt = $this->handle5Quotes( $state, $token );
701 break;
702 case "":
703 # empty token
704 $txt="";
705 break;
706 case "RFC ":
707 if ( $tagIsOpen ) {
708 $txt = "RFC ";
709 } else {
710 $txt = $this->doMagicRFC( $tokenizer );
711 }
712 break;
713 case "ISBN ":
714 if ( $tagIsOpen ) {
715 $txt = "ISBN ";
716 } else {
717 $txt = $this->doMagicISBN( $tokenizer );
718 }
719 break;
720 default:
721 # Call language specific Hook.
722 $txt = $wgLang->processToken( $token, $tokenStack );
723 if ( NULL == $txt ) {
724 # An unkown token. Highlight.
725 $txt = "<font color=\"#FF0000\"><b>".$token["type"]."</b></font>";
726 $txt .= "<font color=\"#FFFF00\"><b>".$token["text"]."</b></font>";
727 }
728 break;
729 }
730 # If we're parsing the interior of a link, don't append the interior to $s,
731 # but push it to the stack so it can be processed when a ]] token is found.
732 if ( $tagIsOpen && $txt != "" ) {
733 $token["type"] = "text";
734 $token["text"] = $txt;
735 array_push( $tokenStack, $token );
736 } else {
737 $s .= $txt;
738 }
739 } #end while
740 if ( count( $tokenStack ) != 0 )
741 {
742 # still objects on stack. opened [[ tag without closing ]] tag.
743 $txt = "";
744 while ( $lastToken = array_pop( $tokenStack ) )
745 {
746 if ( $lastToken["type"] == "text" )
747 {
748 $txt = $lastToken["text"] . $txt;
749 } else {
750 $txt = $lastToken["type"] . $txt;
751 }
752 }
753 $s .= $txt;
754 }
755 return $s;
756 }
757
758 /* private */ function handleInternalLink( $line, $prefix )
759 {
760 global $wgLang, $wgLinkCache;
761 global $wgNamespacesWithSubpages, $wgLanguageCode;
762 static $fname = "Parser::replaceInternalLinks" ;
763 wfProfileIn( $fname );
764
765 wfProfileIn( "$fname-setup" );
766 static $tc = FALSE;
767 if ( !$tc ) { $tc = Title::legalChars() . "#"; }
768 $sk =& $this->mOptions->getSkin();
769
770 # Match a link having the form [[namespace:link|alternate]]trail
771 static $e1 = FALSE;
772 if ( !$e1 ) { $e1 = "/^([{$tc}]+)(?:\\|([^]]+))?]](.*)\$/sD"; }
773 # Match the end of a line for a word that's not followed by whitespace,
774 # e.g. in the case of 'The Arab al[[Razi]]', 'al' will be matched
775 #$e2 = "/^(.*)\\b(\\w+)\$/suD";
776 #$e2 = "/^(.*\\s)(\\S+)\$/suD";
777 static $e2 = '/^(.*\s)([a-zA-Z\x80-\xff]+)$/sD';
778
779
780 # Special and Media are pseudo-namespaces; no pages actually exist in them
781 static $image = FALSE;
782 static $special = FALSE;
783 static $media = FALSE;
784 static $category = FALSE;
785 if ( !$image ) { $image = Namespace::getImage(); }
786 if ( !$special ) { $special = Namespace::getSpecial(); }
787 if ( !$media ) { $media = Namespace::getMedia(); }
788 if ( !$category ) { $category = wfMsg ( "category" ) ; }
789
790 $nottalk = !Namespace::isTalk( $this->mTitle->getNamespace() );
791
792 wfProfileOut( "$fname-setup" );
793 $s = "";
794
795 if ( preg_match( $e1, $line, $m ) ) { # page with normal text or alt
796 $text = $m[2];
797 $trail = $m[3];
798 } else { # Invalid form; output directly
799 $s .= $prefix . "[[" . $line ;
800 return $s;
801 }
802
803 /* Valid link forms:
804 Foobar -- normal
805 :Foobar -- override special treatment of prefix (images, language links)
806 /Foobar -- convert to CurrentPage/Foobar
807 /Foobar/ -- convert to CurrentPage/Foobar, strip the initial / from text
808 */
809 $c = substr($m[1],0,1);
810 $noforce = ($c != ":");
811 if( $c == "/" ) { # subpage
812 if(substr($m[1],-1,1)=="/") { # / at end means we don't want the slash to be shown
813 $m[1]=substr($m[1],1,strlen($m[1])-2);
814 $noslash=$m[1];
815 } else {
816 $noslash=substr($m[1],1);
817 }
818 if($wgNamespacesWithSubpages[$this->mTitle->getNamespace()]) { # subpages allowed here
819 $link = $this->mTitle->getPrefixedText(). "/" . trim($noslash);
820 if( "" == $text ) {
821 $text= $m[1];
822 } # this might be changed for ugliness reasons
823 } else {
824 $link = $noslash; # no subpage allowed, use standard link
825 }
826 } elseif( $noforce ) { # no subpage
827 $link = $m[1];
828 } else {
829 $link = substr( $m[1], 1 );
830 }
831 if( "" == $text )
832 $text = $link;
833
834 $nt = Title::newFromText( $link );
835 if( !$nt ) {
836 $s .= $prefix . "[[" . $line;
837 return $s;
838 }
839 $ns = $nt->getNamespace();
840 $iw = $nt->getInterWiki();
841 if( $noforce ) {
842 if( $iw && $this->mOptions->getInterwikiMagic() && $nottalk && $wgLang->getLanguageName( $iw ) ) {
843 array_push( $this->mOutput->mLanguageLinks, $nt->getPrefixedText() );
844 $s .= $prefix . $trail;
845 return $s;
846 }
847 if( $ns == $image ) {
848 $s .= $prefix . $sk->makeImageLinkObj( $nt, $text ) . $trail;
849 $wgLinkCache->addImageLinkObj( $nt );
850 return $s;
851 }
852 }
853 if( ( $nt->getPrefixedText() == $this->mTitle->getPrefixedText() ) &&
854 ( strpos( $link, "#" ) == FALSE ) ) {
855 $s .= $prefix . "<strong>" . $text . "</strong>" . $trail;
856 return $s;
857 }
858
859 # Category feature
860 $catns = strtoupper ( $nt->getDBkey () ) ;
861 $catns = explode ( ":" , $catns ) ;
862 if ( count ( $catns ) > 1 ) $catns = array_shift ( $catns ) ;
863 else $catns = "" ;
864 if ( $catns == strtoupper($category) && $this->mOptions->getUseCategoryMagic() ) {
865 $t = explode ( ":" , $nt->getText() ) ;
866 array_shift ( $t ) ;
867 $t = implode ( ":" , $t ) ;
868 $t = $wgLang->ucFirst ( $t ) ;
869 $nnt = Title::newFromText ( $category.":".$t ) ;
870 $t = $sk->makeLinkObj( $nnt, $t, "", $trail , $prefix );
871 $this->mOutput->mCategoryLinks[] = $t ;
872 $s .= $prefix . $trail ;
873 return $s ;
874 }
875 if( $ns == $media ) {
876 $s .= $prefix . $sk->makeMediaLinkObj( $nt, $text ) . $trail;
877 $wgLinkCache->addImageLinkObj( $nt );
878 return $s;
879 } elseif( $ns == $special ) {
880 $s .= $prefix . $sk->makeKnownLinkObj( $nt, $text, "", $trail );
881 return $s;
882 }
883 $s .= $sk->makeLinkObj( $nt, $text, "", $trail , $prefix );
884
885 wfProfileOut( $fname );
886 return $s;
887 }
888
889 # Some functions here used by doBlockLevels()
890 #
891 /* private */ function closeParagraph()
892 {
893 $result = "";
894 if ( 0 != strcmp( "", $this->mLastSection ) ) {
895 $result = "</" . $this->mLastSection . ">";
896 }
897 $this->mLastSection = "";
898 return $result."\n";
899 }
900 # getCommon() returns the length of the longest common substring
901 # of both arguments, starting at the beginning of both.
902 #
903 /* private */ function getCommon( $st1, $st2 )
904 {
905 $fl = strlen( $st1 );
906 $shorter = strlen( $st2 );
907 if ( $fl < $shorter ) { $shorter = $fl; }
908
909 for ( $i = 0; $i < $shorter; ++$i ) {
910 if ( $st1{$i} != $st2{$i} ) { break; }
911 }
912 return $i;
913 }
914 # These next three functions open, continue, and close the list
915 # element appropriate to the prefix character passed into them.
916 #
917 /* private */ function openList( $char )
918 {
919 $result = $this->closeParagraph();
920
921 if ( "*" == $char ) { $result .= "<ul><li>"; }
922 else if ( "#" == $char ) { $result .= "<ol><li>"; }
923 else if ( ":" == $char ) { $result .= "<dl><dd>"; }
924 else if ( ";" == $char ) {
925 $result .= "<dl><dt>";
926 $this->mDTopen = true;
927 }
928 else { $result = "<!-- ERR 1 -->"; }
929
930 return $result;
931 }
932
933 /* private */ function nextItem( $char )
934 {
935 if ( "*" == $char || "#" == $char ) { return "</li><li>"; }
936 else if ( ":" == $char || ";" == $char ) {
937 $close = "</dd>";
938 if ( $this->mDTopen ) { $close = "</dt>"; }
939 if ( ";" == $char ) {
940 $this->mDTopen = true;
941 return $close . "<dt>";
942 } else {
943 $this->mDTopen = false;
944 return $close . "<dd>";
945 }
946 }
947 return "<!-- ERR 2 -->";
948 }
949
950 /* private */function closeList( $char )
951 {
952 if ( "*" == $char ) { $text = "</li></ul>"; }
953 else if ( "#" == $char ) { $text = "</li></ol>"; }
954 else if ( ":" == $char ) {
955 if ( $this->mDTopen ) {
956 $this->mDTopen = false;
957 $text = "</dt></dl>";
958 } else {
959 $text = "</dd></dl>";
960 }
961 }
962 else { return "<!-- ERR 3 -->"; }
963 return $text."\n";
964 }
965
966 /* private */ function doBlockLevels( $text, $linestart )
967 {
968 $fname = "Parser::doBlockLevels";
969 wfProfileIn( $fname );
970 # Parsing through the text line by line. The main thing
971 # happening here is handling of block-level elements p, pre,
972 # and making lists from lines starting with * # : etc.
973 #
974 $a = explode( "\n", $text );
975 $text = $lastPref = "";
976 $this->mDTopen = $inBlockElem = false;
977
978 if ( ! $linestart ) { $text .= array_shift( $a ); }
979 foreach ( $a as $t ) {
980 if ( "" != $text ) { $text .= "\n"; }
981
982 $oLine = $t;
983 $opl = strlen( $lastPref );
984 $npl = strspn( $t, "*#:;" );
985 $pref = substr( $t, 0, $npl );
986 $pref2 = str_replace( ";", ":", $pref );
987 $t = substr( $t, $npl );
988
989 if ( 0 != $npl && 0 == strcmp( $lastPref, $pref2 ) ) {
990 $text .= $this->nextItem( substr( $pref, -1 ) );
991
992 if ( ";" == substr( $pref, -1 ) ) {
993 $cpos = strpos( $t, ":" );
994 if ( ! ( false === $cpos ) ) {
995 $term = substr( $t, 0, $cpos );
996 $text .= $term . $this->nextItem( ":" );
997 $t = substr( $t, $cpos + 1 );
998 }
999 }
1000 } else if (0 != $npl || 0 != $opl) {
1001 $cpl = $this->getCommon( $pref, $lastPref );
1002
1003 while ( $cpl < $opl ) {
1004 $text .= $this->closeList( $lastPref{$opl-1} );
1005 --$opl;
1006 }
1007 if ( $npl <= $cpl && $cpl > 0 ) {
1008 $text .= $this->nextItem( $pref{$cpl-1} );
1009 }
1010 while ( $npl > $cpl ) {
1011 $char = substr( $pref, $cpl, 1 );
1012 $text .= $this->openList( $char );
1013
1014 if ( ";" == $char ) {
1015 $cpos = strpos( $t, ":" );
1016 if ( ! ( false === $cpos ) ) {
1017 $term = substr( $t, 0, $cpos );
1018 $text .= $term . $this->nextItem( ":" );
1019 $t = substr( $t, $cpos + 1 );
1020 }
1021 }
1022 ++$cpl;
1023 }
1024 $lastPref = $pref2;
1025 }
1026 if ( 0 == $npl ) { # No prefix--go to paragraph mode
1027 if ( preg_match(
1028 "/(<table|<blockquote|<h1|<h2|<h3|<h4|<h5|<h6|<p)/i", $t ) ) {
1029 $text .= $this->closeParagraph();
1030 $inBlockElem = true;
1031 }
1032 if ( ! $inBlockElem ) {
1033 if ( " " == $t{0} ) {
1034 $newSection = "pre";
1035 # $t = wfEscapeHTML( $t );
1036 }
1037 else { $newSection = "p"; }
1038
1039 if ( 0 == strcmp( "", trim( $oLine ) ) ) {
1040 $text .= $this->closeParagraph();
1041 $text .= "<" . $newSection . ">";
1042 } else if ( 0 != strcmp( $this->mLastSection,
1043 $newSection ) ) {
1044 $text .= $this->closeParagraph();
1045 if ( 0 != strcmp( "p", $newSection ) ) {
1046 $text .= "<" . $newSection . ">";
1047 }
1048 }
1049 $this->mLastSection = $newSection;
1050 }
1051 if ( $inBlockElem &&
1052 preg_match( "/(<\\/table|<\\/blockquote|<\\/h1|<\\/h2|<\\/h3|<\\/h4|<\\/h5|<\\/h6|<\\/p)/i", $t ) ) {
1053 $inBlockElem = false;
1054 }
1055 }
1056 $text .= $t;
1057 }
1058 while ( $npl ) {
1059 $text .= $this->closeList( $pref2{$npl-1} );
1060 --$npl;
1061 }
1062 if ( "" != $this->mLastSection ) {
1063 if ( "p" != $this->mLastSection ) {
1064 $text .= "</" . $this->mLastSection . ">";
1065 }
1066 $this->mLastSection = "";
1067 }
1068 wfProfileOut( $fname );
1069 return $text;
1070 }
1071
1072 function getVariableValue( $index ) {
1073 global $wgLang;
1074
1075 switch ( $index ) {
1076 case MAG_CURRENTMONTH:
1077 return date( "m" );
1078 case MAG_CURRENTMONTHNAME:
1079 return $wgLang->getMonthName( date("n") );
1080 case MAG_CURRENTMONTHNAMEGEN:
1081 return $wgLang->getMonthNameGen( date("n") );
1082 case MAG_CURRENTDAY:
1083 return date("j");
1084 case MAG_CURRENTDAYNAME:
1085 return $wgLang->getWeekdayName( date("w")+1 );
1086 case MAG_CURRENTYEAR:
1087 return date( "Y" );
1088 case MAG_CURRENTTIME:
1089 return $wgLang->time( wfTimestampNow(), false );
1090 case MAG_NUMBEROFARTICLES:
1091 return wfNumberOfArticles();
1092 default:
1093 return NULL;
1094 }
1095 }
1096
1097 function initialiseVariables()
1098 {
1099 global $wgVariableIDs;
1100 $this->mVariables = array();
1101
1102 foreach ( $wgVariableIDs as $id ) {
1103 $mw =& MagicWord::get( $id );
1104 $mw->addToArray( $this->mVariables, $this->getVariableValue( $id ) );
1105 }
1106 }
1107
1108 /* private */ function replaceVariables( $text )
1109 {
1110 global $wgLang, $wgCurParser;
1111 global $wgScript, $wgArticlePath;
1112
1113 $fname = "Parser::replaceVariables";
1114 wfProfileIn( $fname );
1115
1116 $bail = false;
1117 if ( !$this->mVariables ) {
1118 $this->initialiseVariables();
1119 }
1120 $titleChars = Title::legalChars();
1121 $regex = "/{{([$titleChars]*?)}}/s";
1122
1123 # "Recursive" variable expansion: run it through a couple of passes
1124 for ( $i=0; $i<MAX_INCLUDE_REPEAT && !$bail; $i++ ) {
1125 $oldText = $text;
1126
1127 # It's impossible to rebind a global in PHP
1128 # Instead, we run the substitution on a copy, then merge the changed fields back in
1129 $wgCurParser = $this->fork();
1130
1131 $text = preg_replace_callback( $regex, "wfBraceSubstitution", $text );
1132 if ( $oldText == $text ) {
1133 $bail = true;
1134 }
1135 $this->merge( $wgCurParser );
1136 }
1137
1138 return $text;
1139 }
1140
1141 # Returns a copy of this object except with various variables cleared
1142 # This copy can be re-merged with the parent after operations on the copy
1143 function fork()
1144 {
1145 $copy = $this;
1146 $copy->mOutput = new ParserOutput;
1147 return $copy;
1148 }
1149
1150 # Merges a copy split off with fork()
1151 function merge( &$copy )
1152 {
1153 $this->mOutput->merge( $copy->mOutput );
1154
1155 # Merge include throttling arrays
1156 foreach( $copy->mIncludeCount as $dbk => $count ) {
1157 if ( array_key_exists( $dbk, $this->mIncludeCount ) ) {
1158 $this->mIncludeCount[$dbk] += $count;
1159 } else {
1160 $this->mIncludeCount[$dbk] = $count;
1161 }
1162 }
1163 }
1164
1165 function braceSubstitution( $matches )
1166 {
1167 global $wgLinkCache;
1168 $fname = "Parser::braceSubstitution";
1169 $found = false;
1170 $nowiki = false;
1171
1172 $text = $matches[1];
1173
1174 # SUBST
1175 $mwSubst =& MagicWord::get( MAG_SUBST );
1176 if ( $mwSubst->matchStartAndRemove( $text ) ) {
1177 if ( $this->mOutputType == OT_HTML ) {
1178 # Invalid SUBST not replaced at PST time
1179 # Return without further processing
1180 $text = $matches[0];
1181 $found = true;
1182 }
1183 } elseif ( $this->mOutputType == OT_WIKI ) {
1184 # SUBST not found in PST pass, do nothing
1185 $text = $matches[0];
1186 $found = true;
1187 }
1188
1189 # Various prefixes
1190 if ( !$found ) {
1191 # Check for MSGNW:
1192 $mwMsgnw =& MagicWord::get( MAG_MSGNW );
1193 if ( $mwMsgnw->matchStartAndRemove( $text ) ) {
1194 $nowiki = true;
1195 } else {
1196 # Remove obsolete MSG:
1197 $mwMsg =& MagicWord::get( MAG_MSG );
1198 $mwMsg->matchStartAndRemove( $text );
1199 }
1200
1201 # Check if it is an internal message
1202 $mwInt =& MagicWord::get( MAG_INT );
1203 if ( $mwInt->matchStartAndRemove( $text ) ) {
1204 $text = wfMsg( $text );
1205 $found = true;
1206 }
1207 }
1208
1209 # Check for a match against internal variables
1210 if ( !$found && array_key_exists( $text, $this->mVariables ) ) {
1211 $text = $this->mVariables[$text];
1212 $found = true;
1213 $this->mOutput->mContainsOldMagic = true;
1214 }
1215
1216 # Load from database
1217 if ( !$found ) {
1218 $title = Title::newFromText( $text, NS_TEMPLATE );
1219 if ( !is_null( $text ) && !$title->isExternal() ) {
1220 # Check for excessive inclusion
1221 $dbk = $title->getPrefixedDBkey();
1222 if ( !array_key_exists( $dbk, $this->mIncludeCount ) ) {
1223 $this->mIncludeCount[$dbk] = 0;
1224 }
1225 if ( ++$this->mIncludeCount[$dbk] <= MAX_INCLUDE_REPEAT ) {
1226 $article = new Article( $title );
1227 $articleContent = $article->getContentWithoutUsingSoManyDamnGlobals();
1228 if ( $articleContent !== false ) {
1229 $found = true;
1230 $text = $articleContent;
1231
1232 # Escaping and link table handling
1233 # Not required for preSaveTransform()
1234 if ( $this->mOutputType == OT_HTML ) {
1235 if ( $nowiki ) {
1236 $text = wfEscapeWikiText( $text );
1237 } else {
1238 $text = $this->removeHTMLtags( $text );
1239 }
1240 $wgLinkCache->suspend();
1241 $text = $this->replaceInternalLinks( $text );
1242 $wgLinkCache->resume();
1243 $wgLinkCache->addLinkObj( $title );
1244
1245 }
1246 }
1247 }
1248
1249 # If the title is valid but undisplayable, make a link to it
1250 if ( $this->mOutputType == OT_HTML && !$found ) {
1251 $text = "[[" . $title->getPrefixedText() . "]]";
1252 $found = true;
1253 }
1254 }
1255 }
1256
1257 if ( !$found ) {
1258 return $matches[0];
1259 } else {
1260 return $text;
1261 }
1262 }
1263
1264 # Cleans up HTML, removes dangerous tags and attributes
1265 /* private */ function removeHTMLtags( $text )
1266 {
1267 $fname = "Parser::removeHTMLtags";
1268 wfProfileIn( $fname );
1269 $htmlpairs = array( # Tags that must be closed
1270 "b", "i", "u", "font", "big", "small", "sub", "sup", "h1",
1271 "h2", "h3", "h4", "h5", "h6", "cite", "code", "em", "s",
1272 "strike", "strong", "tt", "var", "div", "center",
1273 "blockquote", "ol", "ul", "dl", "table", "caption", "pre",
1274 "ruby", "rt" , "rb" , "rp", "p"
1275 );
1276 $htmlsingle = array(
1277 "br", "hr", "li", "dt", "dd", "hr/"
1278 );
1279 $htmlnest = array( # Tags that can be nested--??
1280 "table", "tr", "td", "th", "div", "blockquote", "ol", "ul",
1281 "dl", "font", "big", "small", "sub", "sup"
1282 );
1283 $tabletags = array( # Can only appear inside table
1284 "td", "th", "tr"
1285 );
1286
1287 $htmlsingle = array_merge( $tabletags, $htmlsingle );
1288 $htmlelements = array_merge( $htmlsingle, $htmlpairs );
1289
1290 $htmlattrs = $this->getHTMLattrs () ;
1291
1292 # Remove HTML comments
1293 $text = preg_replace( "/<!--.*-->/sU", "", $text );
1294
1295 $bits = explode( "<", $text );
1296 $text = array_shift( $bits );
1297 $tagstack = array(); $tablestack = array();
1298
1299 foreach ( $bits as $x ) {
1300 $prev = error_reporting( E_ALL & ~( E_NOTICE | E_WARNING ) );
1301 preg_match( "/^(\\/?)(\\w+)([^>]*)(\\/{0,1}>)([^<]*)$/",
1302 $x, $regs );
1303 list( $qbar, $slash, $t, $params, $brace, $rest ) = $regs;
1304 error_reporting( $prev );
1305
1306 $badtag = 0 ;
1307 if ( in_array( $t = strtolower( $t ), $htmlelements ) ) {
1308 # Check our stack
1309 if ( $slash ) {
1310 # Closing a tag...
1311 if ( ! in_array( $t, $htmlsingle ) &&
1312 ( $ot = array_pop( $tagstack ) ) != $t ) {
1313 array_push( $tagstack, $ot );
1314 $badtag = 1;
1315 } else {
1316 if ( $t == "table" ) {
1317 $tagstack = array_pop( $tablestack );
1318 }
1319 $newparams = "";
1320 }
1321 } else {
1322 # Keep track for later
1323 if ( in_array( $t, $tabletags ) &&
1324 ! in_array( "table", $tagstack ) ) {
1325 $badtag = 1;
1326 } else if ( in_array( $t, $tagstack ) &&
1327 ! in_array ( $t , $htmlnest ) ) {
1328 $badtag = 1 ;
1329 } else if ( ! in_array( $t, $htmlsingle ) ) {
1330 if ( $t == "table" ) {
1331 array_push( $tablestack, $tagstack );
1332 $tagstack = array();
1333 }
1334 array_push( $tagstack, $t );
1335 }
1336 # Strip non-approved attributes from the tag
1337 $newparams = $this->fixTagAttributes($params);
1338
1339 }
1340 if ( ! $badtag ) {
1341 $rest = str_replace( ">", "&gt;", $rest );
1342 $text .= "<$slash$t $newparams$brace$rest";
1343 continue;
1344 }
1345 }
1346 $text .= "&lt;" . str_replace( ">", "&gt;", $x);
1347 }
1348 # Close off any remaining tags
1349 while ( $t = array_pop( $tagstack ) ) {
1350 $text .= "</$t>\n";
1351 if ( $t == "table" ) { $tagstack = array_pop( $tablestack ); }
1352 }
1353 wfProfileOut( $fname );
1354 return $text;
1355 }
1356
1357 /*
1358 *
1359 * This function accomplishes several tasks:
1360 * 1) Auto-number headings if that option is enabled
1361 * 2) Add an [edit] link to sections for logged in users who have enabled the option
1362 * 3) Add a Table of contents on the top for users who have enabled the option
1363 * 4) Auto-anchor headings
1364 *
1365 * It loops through all headlines, collects the necessary data, then splits up the
1366 * string and re-inserts the newly formatted headlines.
1367 *
1368 */
1369
1370 /* private */ function formatHeadings( $text )
1371 {
1372 $doNumberHeadings = $this->mOptions->getNumberHeadings();
1373 $doShowToc = $this->mOptions->getShowToc();
1374 if( !$this->mTitle->userCanEdit() ) {
1375 $showEditLink = 0;
1376 $rightClickHack = 0;
1377 } else {
1378 $showEditLink = $this->mOptions->getEditSection();
1379 $rightClickHack = $this->mOptions->getEditSectionOnRightClick();
1380 }
1381
1382 # Inhibit editsection links if requested in the page
1383 $esw =& MagicWord::get( MAG_NOEDITSECTION );
1384 if( $esw->matchAndRemove( $text ) ) {
1385 $showEditLink = 0;
1386 }
1387 # if the string __NOTOC__ (not case-sensitive) occurs in the HTML,
1388 # do not add TOC
1389 $mw =& MagicWord::get( MAG_NOTOC );
1390 if( $mw->matchAndRemove( $text ) ) {
1391 $doShowToc = 0;
1392 }
1393
1394 # never add the TOC to the Main Page. This is an entry page that should not
1395 # be more than 1-2 screens large anyway
1396 if( $this->mTitle->getPrefixedText() == wfMsg("mainpage") ) {
1397 $doShowToc = 0;
1398 }
1399
1400 # We need this to perform operations on the HTML
1401 $sk =& $this->mOptions->getSkin();
1402
1403 # Get all headlines for numbering them and adding funky stuff like [edit]
1404 # links
1405 preg_match_all( "/<H([1-6])(.*?" . ">)(.*?)<\/H[1-6]>/i", $text, $matches );
1406
1407 # headline counter
1408 $headlineCount = 0;
1409
1410 # Ugh .. the TOC should have neat indentation levels which can be
1411 # passed to the skin functions. These are determined here
1412 $toclevel = 0;
1413 $toc = "";
1414 $full = "";
1415 $head = array();
1416 $sublevelCount = array();
1417 foreach( $matches[3] as $headline ) {
1418 if( $level ) {
1419 $prevlevel = $level;
1420 }
1421 $level = $matches[1][$headlineCount];
1422 if( ( $doNumberHeadings || $doShowToc ) && $prevlevel && $level > $prevlevel ) {
1423 # reset when we enter a new level
1424 $sublevelCount[$level] = 0;
1425 $toc .= $sk->tocIndent( $level - $prevlevel );
1426 $toclevel += $level - $prevlevel;
1427 }
1428 if( ( $doNumberHeadings || $doShowToc ) && $level < $prevlevel ) {
1429 # reset when we step back a level
1430 $sublevelCount[$level+1]=0;
1431 $toc .= $sk->tocUnindent( $prevlevel - $level );
1432 $toclevel -= $prevlevel - $level;
1433 }
1434 # count number of headlines for each level
1435 $sublevelCount[$level]++;
1436
1437 if( $doNumberHeadings || $doShowToc ) {
1438 for( $i = 1; $i <= $level; $i++ ) {
1439 if( $sublevelCount[$i] ) {
1440 if( $dot ) {
1441 $numbering .= ".";
1442 }
1443 $numbering .= $sublevelCount[$i];
1444 $dot = 1;
1445 }
1446 }
1447 }
1448
1449 # The canonized header is a version of the header text safe to use for links
1450 # Avoid insertion of weird stuff like <math> by expanding the relevant sections
1451 $canonized_headline = Parser::unstrip( $headline, $this->mStripState );
1452
1453 # strip out HTML
1454 $canonized_headline = preg_replace( "/<.*?" . ">/","",$canonized_headline );
1455
1456 $tocline = trim( $canonized_headline );
1457 $canonized_headline = str_replace( '"', "", $canonized_headline );
1458 $canonized_headline = str_replace( " ", "_", trim( $canonized_headline) );
1459 $refer[$headlineCount] = $canonized_headline;
1460
1461 # count how many in assoc. array so we can track dupes in anchors
1462 $refers[$canonized_headline]++;
1463 $refcount[$headlineCount]=$refers[$canonized_headline];
1464
1465 # Prepend the number to the heading text
1466
1467 if( $doNumberHeadings || $doShowToc ) {
1468 $tocline = $numbering . " " . $tocline;
1469
1470 # Don't number the heading if it is the only one (looks silly)
1471 if( $doNumberHeadings && count( $matches[3] ) > 1) {
1472 # the two are different if the line contains a link
1473 $headline=$numbering . " " . $headline;
1474 }
1475 }
1476
1477 # Create the anchor for linking from the TOC to the section
1478 $anchor = $canonized_headline;
1479 if($refcount[$headlineCount] > 1 ) {
1480 $anchor .= "_" . $refcount[$headlineCount];
1481 }
1482 if( $doShowToc ) {
1483 $toc .= $sk->tocLine($anchor,$tocline,$toclevel);
1484 }
1485 if( $showEditLink ) {
1486 $head[$headlineCount] .= $sk->editSectionLink($headlineCount+1);
1487 }
1488
1489
1490 # the headline might have a link
1491 if( preg_match( "/(.*)<a(.*)/", $headline, $headlinematches ) ) {
1492 # if so give an anchor name to the already existent link
1493 $headline = $headlinematches[1]
1494 . "<a name=\"$anchor\" " . $headlinematches[2];
1495 } else {
1496 # else create an anchor link for the headline
1497 $headline = "<a name=\"$anchor\">$headline</a>";
1498 }
1499
1500 # give headline the correct <h#> tag
1501 $head[$headlineCount] .= "<h".$level.$matches[2][$headlineCount] .$headline."</h".$level.">";
1502
1503 # Add the edit section link
1504 if( $rightClickHack ) {
1505 $head[$headlineCount] = $sk->editSectionScript($headlineCount+1,$head[$headlineCount]);
1506 }
1507
1508 $numbering = "";
1509 $headlineCount++;
1510 $dot = 0;
1511 }
1512
1513 if( $doShowToc ) {
1514 $toclines = $headlineCount;
1515 $toc .= $sk->tocUnindent( $toclevel );
1516 $toc = $sk->tocTable( $toc );
1517 }
1518
1519 # split up and insert constructed headlines
1520
1521 $blocks = preg_split( "/<H[1-6].*?" . ">.*?<\/H[1-6]>/i", $text );
1522 $i = 0;
1523
1524 foreach( $blocks as $block ) {
1525 if( $showEditLink && $headlineCount > 0 && $i == 0 ) {
1526 # This is the [edit] link that appears for the top block of text when
1527 # section editing is enabled
1528 $full .= $sk->editSectionLink(0);
1529 }
1530 $full .= $block;
1531 if( $doShowToc && $toclines>3 && !$i) {
1532 # Let's add a top anchor just in case we want to link to the top of the page
1533 $full = "<a name=\"top\"></a>".$full.$toc;
1534 }
1535
1536 if( !empty( $head[$i] ) ) {
1537 $full .= $head[$i];
1538 }
1539 $i++;
1540 }
1541
1542 return $full;
1543 }
1544
1545 /* private */ function doMagicISBN( &$tokenizer )
1546 {
1547 global $wgLang;
1548
1549 # Check whether next token is a text token
1550 # If yes, fetch it and convert the text into a
1551 # Special::BookSources link
1552 $token = $tokenizer->previewToken();
1553 while ( $token["type"] == "" )
1554 {
1555 $tokenizer->nextToken();
1556 $token = $tokenizer->previewToken();
1557 }
1558 if ( $token["type"] == "text" )
1559 {
1560 $token = $tokenizer->nextToken();
1561 $x = $token["text"];
1562 $valid = "0123456789-ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1563
1564 $isbn = $blank = "" ;
1565 while ( " " == $x{0} ) {
1566 $blank .= " ";
1567 $x = substr( $x, 1 );
1568 }
1569 while ( strstr( $valid, $x{0} ) != false ) {
1570 $isbn .= $x{0};
1571 $x = substr( $x, 1 );
1572 }
1573 $num = str_replace( "-", "", $isbn );
1574 $num = str_replace( " ", "", $num );
1575
1576 if ( "" == $num ) {
1577 $text = "ISBN $blank$x";
1578 } else {
1579 $titleObj = Title::makeTitle( NS_SPECIAL, "Booksources" );
1580 $text = "<a href=\"" .
1581 $titleObj->escapeLocalUrl( "isbn={$num}" ) .
1582 "\" class=\"internal\">ISBN $isbn</a>";
1583 $text .= $x;
1584 }
1585 } else {
1586 $text = "ISBN ";
1587 }
1588 return $text;
1589 }
1590 /* private */ function doMagicRFC( &$tokenizer )
1591 {
1592 global $wgLang;
1593
1594 # Check whether next token is a text token
1595 # If yes, fetch it and convert the text into a
1596 # link to an RFC source
1597 $token = $tokenizer->previewToken();
1598 while ( $token["type"] == "" )
1599 {
1600 $tokenizer->nextToken();
1601 $token = $tokenizer->previewToken();
1602 }
1603 if ( $token["type"] == "text" )
1604 {
1605 $token = $tokenizer->nextToken();
1606 $x = $token["text"];
1607 $valid = "0123456789";
1608
1609 $rfc = $blank = "" ;
1610 while ( " " == $x{0} ) {
1611 $blank .= " ";
1612 $x = substr( $x, 1 );
1613 }
1614 while ( strstr( $valid, $x{0} ) != false ) {
1615 $rfc .= $x{0};
1616 $x = substr( $x, 1 );
1617 }
1618
1619 if ( "" == $rfc ) {
1620 $text .= "RFC $blank$x";
1621 } else {
1622 $url = wfmsg( "rfcurl" );
1623 $url = str_replace( "$1", $rfc, $url);
1624 $sk =& $this->mOptions->getSkin();
1625 $la = $sk->getExternalLinkAttributes( $url, "RFC {$rfc}" );
1626 $text = "<a href='{$url}'{$la}>RFC {$rfc}</a>{$x}";
1627 }
1628 } else {
1629 $text = "RFC ";
1630 }
1631 return $text;
1632 }
1633
1634 function preSaveTransform( $text, &$title, &$user, $options, $clearState = true )
1635 {
1636 $this->mOptions = $options;
1637 $this->mTitle = $title;
1638 $this->mOutputType = OT_WIKI;
1639
1640 if ( $clearState ) {
1641 $this->clearState();
1642 }
1643
1644 $stripState = false;
1645 $text = str_replace("\r\n", "\n", $text);
1646 $text = $this->strip( $text, $stripState, false );
1647 $text = $this->pstPass2( $text, $user );
1648 $text = $this->unstrip( $text, $stripState );
1649 return $text;
1650 }
1651
1652 /* private */ function pstPass2( $text, &$user )
1653 {
1654 global $wgLang, $wgLocaltimezone, $wgCurParser;
1655
1656 # Variable replacement
1657 # Because mOutputType is OT_WIKI, this will only process {{subst:xxx}} type tags
1658 $text = $this->replaceVariables( $text );
1659
1660 # Signatures
1661 #
1662 $n = $user->getName();
1663 $k = $user->getOption( "nickname" );
1664 if ( "" == $k ) { $k = $n; }
1665 if(isset($wgLocaltimezone)) {
1666 $oldtz = getenv("TZ"); putenv("TZ=$wgLocaltimezone");
1667 }
1668 /* Note: this is an ugly timezone hack for the European wikis */
1669 $d = $wgLang->timeanddate( date( "YmdHis" ), false ) .
1670 " (" . date( "T" ) . ")";
1671 if(isset($wgLocaltimezone)) putenv("TZ=$oldtz");
1672
1673 $text = preg_replace( "/~~~~~/", $d, $text );
1674 $text = preg_replace( "/~~~~/", "[[" . $wgLang->getNsText(
1675 Namespace::getUser() ) . ":$n|$k]] $d", $text );
1676 $text = preg_replace( "/~~~/", "[[" . $wgLang->getNsText(
1677 Namespace::getUser() ) . ":$n|$k]]", $text );
1678
1679 # Context links: [[|name]] and [[name (context)|]]
1680 #
1681 $tc = "[&;%\\-,.\\(\\)' _0-9A-Za-z\\/:\\x80-\\xff]";
1682 $np = "[&;%\\-,.' _0-9A-Za-z\\/:\\x80-\\xff]"; # No parens
1683 $namespacechar = '[ _0-9A-Za-z\x80-\xff]'; # Namespaces can use non-ascii!
1684 $conpat = "/^({$np}+) \\(({$tc}+)\\)$/";
1685
1686 $p1 = "/\[\[({$np}+) \\(({$np}+)\\)\\|]]/"; # [[page (context)|]]
1687 $p2 = "/\[\[\\|({$tc}+)]]/"; # [[|page]]
1688 $p3 = "/\[\[($namespacechar+):({$np}+)\\|]]/"; # [[namespace:page|]]
1689 $p4 = "/\[\[($namespacechar+):({$np}+) \\(({$np}+)\\)\\|]]/";
1690 # [[ns:page (cont)|]]
1691 $context = "";
1692 $t = $this->mTitle->getText();
1693 if ( preg_match( $conpat, $t, $m ) ) {
1694 $context = $m[2];
1695 }
1696 $text = preg_replace( $p4, "[[\\1:\\2 (\\3)|\\2]]", $text );
1697 $text = preg_replace( $p1, "[[\\1 (\\2)|\\1]]", $text );
1698 $text = preg_replace( $p3, "[[\\1:\\2|\\2]]", $text );
1699
1700 if ( "" == $context ) {
1701 $text = preg_replace( $p2, "[[\\1]]", $text );
1702 } else {
1703 $text = preg_replace( $p2, "[[\\1 ({$context})|\\1]]", $text );
1704 }
1705
1706 /*
1707 $mw =& MagicWord::get( MAG_SUBST );
1708 $wgCurParser = $this->fork();
1709 $text = $mw->substituteCallback( $text, "wfBraceSubstitution" );
1710 $this->merge( $wgCurParser );
1711 */
1712
1713 # Trim trailing whitespace
1714 # MAG_END (__END__) tag allows for trailing
1715 # whitespace to be deliberately included
1716 $text = rtrim( $text );
1717 $mw =& MagicWord::get( MAG_END );
1718 $mw->matchAndRemove( $text );
1719
1720 return $text;
1721 }
1722
1723
1724 }
1725
1726 class ParserOutput
1727 {
1728 var $mText, $mLanguageLinks, $mCategoryLinks, $mContainsOldMagic;
1729
1730 function ParserOutput( $text = "", $languageLinks = array(), $categoryLinks = array(),
1731 $containsOldMagic = false )
1732 {
1733 $this->mText = $text;
1734 $this->mLanguageLinks = $languageLinks;
1735 $this->mCategoryLinks = $categoryLinks;
1736 $this->mContainsOldMagic = $containsOldMagic;
1737 }
1738
1739 function getText() { return $this->mText; }
1740 function getLanguageLinks() { return $this->mLanguageLinks; }
1741 function getCategoryLinks() { return $this->mCategoryLinks; }
1742 function containsOldMagic() { return $this->mContainsOldMagic; }
1743 function setText( $text ) { return wfSetVar( $this->mText, $text ); }
1744 function setLanguageLinks( $ll ) { return wfSetVar( $this->mLanguageLinks, $ll ); }
1745 function setCategoryLinks( $cl ) { return wfSetVar( $this->mCategoryLinks, $cl ); }
1746 function setContainsOldMagic( $com ) { return wfSetVar( $this->mContainsOldMagic, $com ); }
1747
1748 function merge( $other ) {
1749 $this->mLanguageLinks = array_merge( $this->mLanguageLinks, $other->mLanguageLinks );
1750 $this->mCategoryLinks = array_merge( $this->mCategoryLinks, $this->mLanguageLinks );
1751 $this->mContainsOldMagic = $this->mContainsOldMagic || $other->mContainsOldMagic;
1752 }
1753
1754 }
1755
1756 class ParserOptions
1757 {
1758 # All variables are private
1759 var $mUseTeX; # Use texvc to expand <math> tags
1760 var $mUseCategoryMagic; # Treat [[Category:xxxx]] tags specially
1761 var $mUseDynamicDates; # Use $wgDateFormatter to format dates
1762 var $mInterwikiMagic; # Interlanguage links are removed and returned in an array
1763 var $mAllowExternalImages; # Allow external images inline
1764 var $mSkin; # Reference to the preferred skin
1765 var $mDateFormat; # Date format index
1766 var $mEditSection; # Create "edit section" links
1767 var $mEditSectionOnRightClick; # Generate JavaScript to edit section on right click
1768 var $mNumberHeadings; # Automatically number headings
1769 var $mShowToc; # Show table of contents
1770
1771 function getUseTeX() { return $this->mUseTeX; }
1772 function getUseCategoryMagic() { return $this->mUseCategoryMagic; }
1773 function getUseDynamicDates() { return $this->mUseDynamicDates; }
1774 function getInterwikiMagic() { return $this->mInterwikiMagic; }
1775 function getAllowExternalImages() { return $this->mAllowExternalImages; }
1776 function getSkin() { return $this->mSkin; }
1777 function getDateFormat() { return $this->mDateFormat; }
1778 function getEditSection() { return $this->mEditSection; }
1779 function getEditSectionOnRightClick() { return $this->mEditSectionOnRightClick; }
1780 function getNumberHeadings() { return $this->mNumberHeadings; }
1781 function getShowToc() { return $this->mShowToc; }
1782
1783 function setUseTeX( $x ) { return wfSetVar( $this->mUseTeX, $x ); }
1784 function setUseCategoryMagic( $x ) { return wfSetVar( $this->mUseCategoryMagic, $x ); }
1785 function setUseDynamicDates( $x ) { return wfSetVar( $this->mUseDynamicDates, $x ); }
1786 function setInterwikiMagic( $x ) { return wfSetVar( $this->mInterwikiMagic, $x ); }
1787 function setAllowExternalImages( $x ) { return wfSetVar( $this->mAllowExternalImages, $x ); }
1788 function setSkin( $x ) { return wfSetRef( $this->mSkin, $x ); }
1789 function setDateFormat( $x ) { return wfSetVar( $this->mDateFormat, $x ); }
1790 function setEditSection( $x ) { return wfSetVar( $this->mEditSection, $x ); }
1791 function setEditSectionOnRightClick( $x ) { return wfSetVar( $this->mEditSectionOnRightClick, $x ); }
1792 function setNumberHeadings( $x ) { return wfSetVar( $this->mNumberHeadings, $x ); }
1793 function setShowToc( $x ) { return wfSetVar( $this->mShowToc, $x ); }
1794
1795 /* static */ function newFromUser( &$user )
1796 {
1797 $popts = new ParserOptions;
1798 $popts->initialiseFromUser( &$user );
1799 return $popts;
1800 }
1801
1802 function initialiseFromUser( &$userInput )
1803 {
1804 global $wgUseTeX, $wgUseCategoryMagic, $wgUseDynamicDates, $wgInterwikiMagic, $wgAllowExternalImages;
1805
1806 if ( !$userInput ) {
1807 $user = new User;
1808 } else {
1809 $user =& $userInput;
1810 }
1811
1812 $this->mUseTeX = $wgUseTeX;
1813 $this->mUseCategoryMagic = $wgUseCategoryMagic;
1814 $this->mUseDynamicDates = $wgUseDynamicDates;
1815 $this->mInterwikiMagic = $wgInterwikiMagic;
1816 $this->mAllowExternalImages = $wgAllowExternalImages;
1817 $this->mSkin =& $user->getSkin();
1818 $this->mDateFormat = $user->getOption( "date" );
1819 $this->mEditSection = $user->getOption( "editsection" );
1820 $this->mEditSectionOnRightClick = $user->getOption( "editsectiononrightclick" );
1821 $this->mNumberHeadings = $user->getOption( "numberheadings" );
1822 $this->mShowToc = $user->getOption( "showtoc" );
1823 }
1824
1825
1826 }
1827
1828 # Regex callbacks, used in Parser::replaceVariables
1829 function wfBraceSubstitution( $matches )
1830 {
1831 global $wgCurParser;
1832 return $wgCurParser->braceSubstitution( $matches );
1833 }
1834
1835 ?>
Wiklou, le Wiki du Wiklou