The MD5 value for "+" is "+".
376 | 377 | * Now convert escaped characters to their numeric character 378 | references equivalent. 379 | 380 | This fix an integration issue with SmartyPants and backslash escapes. 381 | Since Markdown and SmartyPants have some escapable characters in common, 382 | it was sometime necessary to escape them twice. Previously, two 383 | backslashes were sometime required to prevent Markdown from "eating" the 384 | backslash before SmartyPants sees it: 385 | 386 | Here are two hyphens: \\-- 387 | 388 | Now, only one backslash will do: 389 | 390 | Here are two hyphens: \-- 391 | 392 | 393 | 1.0.1f (7 Feb 2007): 394 | 395 | * Fixed an issue with WordPress where manually-entered excerpts, but 396 | not the auto-generated ones, would contain nested paragraphs. 397 | 398 | * Fixed an issue introduced in 1.0.1d where headers and blockquotes 399 | preceded too closely by a paragraph (not separated by a blank line) 400 | where incorrectly put inside the paragraph. 401 | 402 | * Fixed an issue introduced in 1.0.1d in the tokenizeHTML method where 403 | two consecutive code spans would be merged into one when together they 404 | form a valid tag in a multiline paragraph. 405 | 406 | * Fixed an long-prevailing issue where blank lines in code blocks would 407 | be doubled when the code block is in a list item. 408 | 409 | This was due to the list processing functions relying on artificially 410 | doubled blank lines to correctly determine when list items should 411 | contain block-level content. The list item processing model was thus 412 | changed to avoid the need for double blank lines. 413 | 414 | * Fixed an issue with `<% asp-style %>` instructions used as inline 415 | content where the opening `<` was encoded as `<`. 416 | 417 | * Fixed a parse error occuring when PHP is configured to accept 418 | ASP-style delimiters as boundaries for PHP scripts. 419 | 420 | * Fixed a bug introduced in 1.0.1d where underscores in automatic links 421 | got swapped with emphasis tags. 422 | 423 | 424 | 1.0.1e (28 Dec 2006) 425 | 426 | * Added support for internationalized domain names for email addresses in 427 | automatic link. Improved the speed at which email addresses are converted 428 | to entities. Thanks to Milian Wolff for his optimisations. 429 | 430 | * Made deterministic the conversion to entities of email addresses in 431 | automatic links. This means that a given email address will always be 432 | encoded the same way. 433 | 434 | * PHP Markdown will now use its own function to calculate the length of an 435 | UTF-8 string in `detab` when `mb_strlen` is not available instead of 436 | giving a fatal error. 437 | 438 | 439 | 1.0.1d (1 Dec 2006) 440 | 441 | * Fixed a bug where inline images always had an empty title attribute. The 442 | title attribute is now present only when explicitly defined. 443 | 444 | * Link references definitions can now have an empty title, previously if the 445 | title was defined but left empty the link definition was ignored. This can 446 | be useful if you want an empty title attribute in images to hide the 447 | tooltip in Internet Explorer. 448 | 449 | * Made `detab` aware of UTF-8 characters. UTF-8 multi-byte sequences are now 450 | correctly mapped to one character instead of the number of bytes. 451 | 452 | * Fixed a small bug with WordPress where WordPress' default filter `wpautop` 453 | was not properly deactivated on comment text, resulting in hard line breaks 454 | where Markdown do not prescribes them. 455 | 456 | * Added a `TextileRestrited` method to the textile compatibility mode. There 457 | is no restriction however, as Markdown does not have a restricted mode at 458 | this point. This should make PHP Markdown work again in the latest 459 | versions of TextPattern. 460 | 461 | * Converted PHP Markdown to a object-oriented design. 462 | 463 | * Changed span and block gamut methods so that they loop over a 464 | customizable list of methods. This makes subclassing the parser a more 465 | interesting option for creating syntax extensions. 466 | 467 | * Also added a "document" gamut loop which can be used to hook document-level 468 | methods (like for striping link definitions). 469 | 470 | * Changed all methods which were inserting HTML code so that they now return 471 | a hashed representation of the code. New methods `hashSpan` and `hashBlock` 472 | are used to hash respectivly span- and block-level generated content. This 473 | has a couple of significant effects: 474 | 475 | 1. It prevents invalid nesting of Markdown-generated elements which 476 | could occur occuring with constructs like `*something [link*][1]`. 477 | 2. It prevents problems occuring with deeply nested lists on which 478 | paragraphs were ill-formed. 479 | 3. It removes the need to call `hashHTMLBlocks` twice during the the 480 | block gamut. 481 | 482 | Hashes are turned back to HTML prior output. 483 | 484 | * Made the block-level HTML parser smarter using a specially-crafted regular 485 | expression capable of handling nested tags. 486 | 487 | * Solved backtick issues in tag attributes by rewriting the HTML tokenizer to 488 | be aware of code spans. All these lines should work correctly now: 489 | 490 | bar 491 | bar 492 | `` tags for something like this:
548 |
549 | * this
550 |
551 | * sub
552 |
553 | that
554 |
555 | * Fixed some incorrect behaviour with emphasis. This will now work
556 | as it should:
557 |
558 | *test **thing***
559 | **test *thing***
560 | ***thing* test**
561 | ***thing** test*
562 |
563 | Name: __________
564 | Address: _______
565 |
566 | * Correct a small bug in `_TokenizeHTML` where a Doctype declaration
567 | was not seen as HTML.
568 |
569 | * Major rewrite of the WordPress integration code that should
570 | correct many problems by preventing default WordPress filters from
571 | tampering with Markdown-formatted text. More details here:
572 |
` tag. 659 | 660 | * `_HashHTMLBlocks()` now tolerates trailing spaces and tabs following 661 | HTML comments and `
` tags. 662 | 663 | * Changed special case pattern for hashing `
` tags in 664 | `_HashHTMLBlocks()` so that they must occur within three spaces 665 | of left margin. (With 4 spaces or a tab, they should be 666 | code blocks, but weren't before this fix.) 667 | 668 | * Auto-linked email address can now optionally contain 669 | a 'mailto:' protocol. I.e. these are equivalent: 670 | 671 |
` tags. 676 | 677 | * Changed `_StripLinkDefinitions()` so that link definitions must 678 | occur within three spaces of the left margin. Thus if you indent 679 | a link definition by four spaces or a tab, it will now be a code 680 | block. 681 | 682 | * You can now write empty links: 683 | 684 | [like this]() 685 | 686 | and they'll be turned into anchor tags with empty href attributes. 687 | This should have worked before, but didn't. 688 | 689 | * `***this***` and `___this___` are now turned into 690 | 691 | this 692 | 693 | Instead of 694 | 695 | this 696 | 697 | which isn't valid. 698 | 699 | * Fixed problem for links defined with urls that include parens, e.g.: 700 | 701 | [1]: http://sources.wikipedia.org/wiki/Middle_East_Policy_(Chomsky) 702 | 703 | "Chomsky" was being erroneously treated as the URL's title. 704 | 705 | * Double quotes in the title of an inline link used to give strange 706 | results (incorrectly made entities). Fixed. 707 | 708 | * Tabs are now correctly changed into spaces. Previously, only 709 | the first tab was converted. In code blocks, the second one was too, 710 | but was not always correctly aligned. 711 | 712 | * Fixed a bug where a tab character inserted after a quote on the same 713 | line could add a slash before the quotes. 714 | 715 | This is "before" [tab] and "after" a tab. 716 | 717 | Previously gave this result: 718 | 719 |
This is \"before\" [tab] and "after" a tab.
720 | 721 | * Removed a call to `htmlentities`. This fixes a bug where multibyte 722 | characters present in the title of a link reference could lead to 723 | invalid utf-8 characters. 724 | 725 | * Changed a regular expression in `_TokenizeHTML` that could lead to 726 | a segmentation fault with PHP 4.3.8 on Linux. 727 | 728 | * Fixed some notices that could show up if PHP error reporting 729 | E_NOTICE flag was set. 730 | 731 | 732 | Copyright and License 733 | --------------------- 734 | 735 | PHP Markdown 736 | Copyright (c) 2004-2009 Michel Fortin 737 |
'.$text.'
'; 122 | $text = preg_replace('{\n{2,}}', "\n\n", $text); 123 | } 124 | return $text; 125 | } 126 | 127 | function ajf_mdwp_strip_p($t) { return preg_replace('{}i', '', $t); } 128 | 129 | function ajf_mdwp_hide_tags($text) { 130 | global $mdwp_hidden_tags, $mdwp_placeholders; 131 | return str_replace($mdwp_hidden_tags, $mdwp_placeholders, $text); 132 | } 133 | function ajf_mdwp_show_tags($text) { 134 | global $mdwp_hidden_tags, $mdwp_placeholders; 135 | return str_replace($mdwp_placeholders, $mdwp_hidden_tags, $text); 136 | } 137 | } 138 | 139 | 140 | ### bBlog Plugin Info ### 141 | 142 | function AJF_identify_modifier_markdown() { 143 | return array( 144 | 'name' => 'markdown', 145 | 'type' => 'modifier', 146 | 'nicename' => 'Markdown', 147 | 'description' => 'A text-to-HTML conversion tool for web writers', 148 | 'authors' => 'Michel Fortin and John Gruber', 149 | 'licence' => 'BSD-like', 150 | 'version' => AJF_MARKDOWN_VERSION, 151 | 'help' => 'Markdown syntax allows you to write using an easy-to-read, easy-to-write plain text format. Based on the original Perl version by John Gruber. More...' 152 | ); 153 | } 154 | 155 | 156 | ### Smarty Modifier Interface ### 157 | 158 | function AJF_smarty_modifier_markdown($text) { 159 | return AJF_Markdown($text); 160 | } 161 | 162 | 163 | ### Textile Compatibility Mode ### 164 | 165 | # Rename this file to "classTextile.php" and it can replace Textile everywhere. 166 | 167 | if (strcasecmp(substr(__FILE__, -16), "classTextile.php") == 0) { 168 | # Try to include PHP SmartyPants. Should be in the same directory. 169 | @include_once 'smartypants.php'; 170 | # Fake Textile class. It calls Markdown instead. 171 | class Textile { 172 | function TextileThis($text, $lite='', $encode='') { 173 | if ($lite == '' && $encode == '') $text = AJF_Markdown($text); 174 | if (function_exists('SmartyPants')) $text = SmartyPants($text); 175 | return $text; 176 | } 177 | # Fake restricted version: restrictions are not supported for now. 178 | function TextileRestricted($text, $lite='', $noimage='') { 179 | return $this->TextileThis($text, $lite); 180 | } 181 | # Workaround to ensure compatibility with TextPattern 4.0.3. 182 | function blockLite($text) { return $text; } 183 | } 184 | } 185 | 186 | 187 | 188 | # 189 | # Markdown Parser Class 190 | # 191 | 192 | class AJF_Markdown_Parser { 193 | 194 | # Regex to match balanced [brackets]. 195 | # Needed to insert a maximum bracked depth while converting to PHP. 196 | var $nested_brackets_depth = 6; 197 | var $nested_brackets_re; 198 | 199 | var $nested_url_parenthesis_depth = 4; 200 | var $nested_url_parenthesis_re; 201 | 202 | # Table of hash values for escaped characters: 203 | var $escape_chars = '\`*_{}[]()>#+-.!'; 204 | var $escape_chars_re; 205 | 206 | # Change to ">" for HTML output. 207 | var $empty_element_suffix = MARKDOWN_EMPTY_ELEMENT_SUFFIX; 208 | var $tab_width = MARKDOWN_TAB_WIDTH; 209 | 210 | # Change to `true` to disallow markup or entities. 211 | var $no_markup = false; 212 | var $no_entities = false; 213 | 214 | # Predefined urls and titles for reference links and images. 215 | var $predef_urls = array(); 216 | var $predef_titles = array(); 217 | 218 | 219 | function AJF_Markdown_Parser() { 220 | # 221 | # Constructor function. Initialize appropriate member variables. 222 | # 223 | $this->_initDetab(); 224 | $this->prepareItalicsAndBold(); 225 | 226 | $this->nested_brackets_re = 227 | str_repeat('(?>[^\[\]]+|\[', $this->nested_brackets_depth). 228 | str_repeat('\])*', $this->nested_brackets_depth); 229 | 230 | $this->nested_url_parenthesis_re = 231 | str_repeat('(?>[^()\s]+|\(', $this->nested_url_parenthesis_depth). 232 | str_repeat('(?>\)))*', $this->nested_url_parenthesis_depth); 233 | 234 | $this->escape_chars_re = '['.preg_quote($this->escape_chars).']'; 235 | 236 | # Sort document, block, and span gamut in ascendent priority order. 237 | asort($this->document_gamut); 238 | asort($this->block_gamut); 239 | asort($this->span_gamut); 240 | } 241 | 242 | 243 | # Internal hashes used during transformation. 244 | var $urls = array(); 245 | var $titles = array(); 246 | var $html_hashes = array(); 247 | 248 | # Status flag to avoid invalid nesting. 249 | var $in_anchor = false; 250 | 251 | 252 | function setup() { 253 | # 254 | # Called before the transformation process starts to setup parser 255 | # states. 256 | # 257 | # Clear global hashes. 258 | $this->urls = $this->predef_urls; 259 | $this->titles = $this->predef_titles; 260 | $this->html_hashes = array(); 261 | 262 | $in_anchor = false; 263 | } 264 | 265 | function teardown() { 266 | # 267 | # Called after the transformation process to clear any variable 268 | # which may be taking up memory unnecessarly. 269 | # 270 | $this->urls = array(); 271 | $this->titles = array(); 272 | $this->html_hashes = array(); 273 | } 274 | 275 | 276 | function transform($text) { 277 | # 278 | # Main function. Performs some preprocessing on the input text 279 | # and pass it through the document gamut. 280 | # 281 | $this->setup(); 282 | 283 | # Remove UTF-8 BOM and marker character in input, if present. 284 | $text = preg_replace('{^\xEF\xBB\xBF|\x1A}', '', $text); 285 | 286 | # Standardize line endings: 287 | # DOS to Unix and Mac to Unix 288 | $text = preg_replace('{\r\n?}', "\n", $text); 289 | 290 | # Make sure $text ends with a couple of newlines: 291 | $text .= "\n\n"; 292 | 293 | # Convert all tabs to spaces. 294 | $text = $this->detab($text); 295 | 296 | # Turn block-level HTML blocks into hash entries 297 | $text = $this->hashHTMLBlocks($text); 298 | 299 | # Strip any lines consisting only of spaces and tabs. 300 | # This makes subsequent regexen easier to write, because we can 301 | # match consecutive blank lines with /\n+/ instead of something 302 | # contorted like /[ ]*\n+/ . 303 | $text = preg_replace('/^[ ]+$/m', '', $text); 304 | 305 | # Run document gamut methods. 306 | foreach ($this->document_gamut as $method => $priority) { 307 | $text = $this->$method($text); 308 | } 309 | 310 | $this->teardown(); 311 | 312 | return $text . "\n"; 313 | } 314 | 315 | var $document_gamut = array( 316 | # Strip link definitions, store in hashes. 317 | "stripLinkDefinitions" => 20, 318 | 319 | "runBasicBlockGamut" => 30, 320 | ); 321 | 322 | 323 | function stripLinkDefinitions($text) { 324 | # 325 | # Strips link definitions from text, stores the URLs and titles in 326 | # hash references. 327 | # 328 | $less_than_tab = $this->tab_width - 1; 329 | 330 | # Link defs are in the form: ^[id]: url "optional title" 331 | $text = preg_replace_callback('{ 332 | ^[ ]{0,'.$less_than_tab.'}\[(.+)\][ ]?: # id = $1 333 | [ ]* 334 | \n? # maybe *one* newline 335 | [ ]* 336 | (?: 337 | <(.+?)> # url = $2 338 | | 339 | (\S+?) # url = $3 340 | ) 341 | [ ]* 342 | \n? # maybe one newline 343 | [ ]* 344 | (?: 345 | (?<=\s) # lookbehind for whitespace 346 | ["(] 347 | (.*?) # title = $4 348 | [")] 349 | [ ]* 350 | )? # title is optional 351 | (?:\n+|\Z) 352 | }xm', 353 | array(&$this, '_stripLinkDefinitions_callback'), 354 | $text); 355 | return $text; 356 | } 357 | function _stripLinkDefinitions_callback($matches) { 358 | $link_id = strtolower($matches[1]); 359 | $url = $matches[2] == '' ? $matches[3] : $matches[2]; 360 | $this->urls[$link_id] = $url; 361 | $this->titles[$link_id] =& $matches[4]; 362 | return ''; # String that will replace the block 363 | } 364 | 365 | 366 | function hashHTMLBlocks($text) { 367 | if ($this->no_markup) return $text; 368 | 369 | $less_than_tab = $this->tab_width - 1; 370 | 371 | # Hashify HTML blocks: 372 | # We only want to do this for block-level HTML tags, such as headers, 373 | # lists, and tables. That's because we still want to wrap
s around 374 | # "paragraphs" that are wrapped in non-block-level tags, such as anchors, 375 | # phrase emphasis, and spans. The list of tags we're looking for is 376 | # hard-coded: 377 | # 378 | # * List "a" is made of tags which can be both inline or block-level. 379 | # These will be treated block-level when the start tag is alone on 380 | # its line, otherwise they're not matched here and will be taken as 381 | # inline later. 382 | # * List "b" is made of tags which are always block-level; 383 | # 384 | $block_tags_a_re = 'ins|del'; 385 | $block_tags_b_re = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|address|'. 386 | 'script|noscript|form|fieldset|iframe|math'; 387 | 388 | # Regular expression for the content of a block tag. 389 | $nested_tags_level = 4; 390 | $attr = ' 391 | (?> # optional tag attributes 392 | \s # starts with whitespace 393 | (?> 394 | [^>"/]+ # text outside quotes 395 | | 396 | /+(?!>) # slash not followed by ">" 397 | | 398 | "[^"]*" # text inside double quotes (tolerate ">") 399 | | 400 | \'[^\']*\' # text inside single quotes (tolerate ">") 401 | )* 402 | )? 403 | '; 404 | $content = 405 | str_repeat(' 406 | (?> 407 | [^<]+ # content without tag 408 | | 409 | <\2 # nested opening tag 410 | '.$attr.' # attributes 411 | (?> 412 | /> 413 | | 414 | >', $nested_tags_level). # end of opening tag 415 | '.*?'. # last level nested tag content 416 | str_repeat(' 417 | # closing nested tag 418 | ) 419 | | 420 | <(?!/\2\s*> # other tags with a different name 421 | ) 422 | )*', 423 | $nested_tags_level); 424 | $content2 = str_replace('\2', '\3', $content); 425 | 426 | # First, look for nested blocks, e.g.: 427 | #
. It was easier to make a special 467 | # case than to make the other regex more complicated. 468 | 469 | [ ]{0,'.$less_than_tab.'} 470 | <(hr) # start tag = $2 471 | '.$attr.' # attributes 472 | /?> # the matching end tag 473 | [ ]* 474 | (?=\n{2,}|\Z) # followed by a blank line or end of document 475 | 476 | | # Special case for standalone HTML comments: 477 | 478 | [ ]{0,'.$less_than_tab.'} 479 | (?s: 480 | 481 | ) 482 | [ ]* 483 | (?=\n{2,}|\Z) # followed by a blank line or end of document 484 | 485 | | # PHP and ASP-style processor instructions ( 492 | ) 493 | [ ]* 494 | (?=\n{2,}|\Z) # followed by a blank line or end of document 495 | 496 | ) 497 | )}Sxmi', 498 | array(&$this, '_hashHTMLBlocks_callback'), 499 | $text); 500 | 501 | return $text; 502 | } 503 | function _hashHTMLBlocks_callback($matches) { 504 | $text = $matches[1]; 505 | $key = $this->hashBlock($text); 506 | return "\n\n$key\n\n"; 507 | } 508 | 509 | 510 | function hashPart($text, $boundary = 'X') { 511 | # 512 | # Called whenever a tag must be hashed when a function insert an atomic 513 | # element in the text stream. Passing $text to through this function gives 514 | # a unique text-token which will be reverted back when calling unhash. 515 | # 516 | # The $boundary argument specify what character should be used to surround 517 | # the token. By convension, "B" is used for block elements that needs not 518 | # to be wrapped into paragraph tags at the end, ":" is used for elements 519 | # that are word separators and "X" is used in the general case. 520 | # 521 | # Swap back any tag hash found in $text so we do not have to `unhash` 522 | # multiple times at the end. 523 | $text = $this->unhash($text); 524 | 525 | # Then hash the block. 526 | static $i = 0; 527 | $key = "$boundary\x1A" . ++$i . $boundary; 528 | $this->html_hashes[$key] = $text; 529 | return $key; # String that will replace the tag. 530 | } 531 | 532 | 533 | function hashBlock($text) { 534 | # 535 | # Shortcut function for hashPart with block-level boundaries. 536 | # 537 | return $this->hashPart($text, 'B'); 538 | } 539 | 540 | 541 | var $block_gamut = array( 542 | # 543 | # These are all the transformations that form block-level 544 | # tags like paragraphs, headers, and list items. 545 | # 546 | "doHeaders" => 10, 547 | "doHorizontalRules" => 20, 548 | 549 | "doLists" => 40, 550 | "doCodeBlocks" => 50, 551 | "doBlockQuotes" => 60, 552 | ); 553 | 554 | function runBlockGamut($text) { 555 | # 556 | # Run block gamut tranformations. 557 | # 558 | # We need to escape raw HTML in Markdown source before doing anything 559 | # else. This need to be done for each block, and not only at the 560 | # begining in the Markdown function since hashed blocks can be part of 561 | # list items and could have been indented. Indented blocks would have 562 | # been seen as a code block in a previous pass of hashHTMLBlocks. 563 | $text = $this->hashHTMLBlocks($text); 564 | 565 | return $this->runBasicBlockGamut($text); 566 | } 567 | 568 | function runBasicBlockGamut($text) { 569 | # 570 | # Run block gamut tranformations, without hashing HTML blocks. This is 571 | # useful when HTML blocks are known to be already hashed, like in the first 572 | # whole-document pass. 573 | # 574 | foreach ($this->block_gamut as $method => $priority) { 575 | $text = $this->$method($text); 576 | } 577 | 578 | # Finally form paragraph and restore hashed blocks. 579 | $text = $this->formParagraphs($text); 580 | 581 | return $text; 582 | } 583 | 584 | 585 | function doHorizontalRules($text) { 586 | # Do Horizontal Rules: 587 | return preg_replace( 588 | '{ 589 | ^[ ]{0,3} # Leading space 590 | ([-*_]) # $1: First marker 591 | (?> # Repeated marker group 592 | [ ]{0,2} # Zero, one, or two spaces. 593 | \1 # Marker character 594 | ){2,} # Group repeated at least twice 595 | [ ]* # Tailing spaces 596 | $ # End of line. 597 | }mx', 598 | "\n".$this->hashBlock("
` blocks.
1082 | #
1083 | $text = preg_replace_callback('{
1084 | (?:\n\n|\A\n?)
1085 | ( # $1 = the code block -- one or more lines, starting with a space/tab
1086 | (?>
1087 | [ ]{'.$this->tab_width.'} # Lines must start with a tab or a tab-width of spaces
1088 | .*\n+
1089 | )+
1090 | )
1091 | ((?=^[ ]{0,'.$this->tab_width.'}\S)|\Z) # Lookahead for non-space at line-start, or end of doc
1092 | }xm',
1093 | array(&$this, '_doCodeBlocks_callback'), $text);
1094 |
1095 | return $text;
1096 | }
1097 | function _doCodeBlocks_callback($matches) {
1098 | $codeblock = $matches[1];
1099 |
1100 | $codeblock = $this->outdent($codeblock);
1101 | $codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);
1102 |
1103 | # trim leading newlines and trailing newlines
1104 | $codeblock = preg_replace('/\A\n+|\n+\z/', '', $codeblock);
1105 |
1106 | $codeblock = "$codeblock\n
";
1107 | return "\n\n".$this->hashBlock($codeblock)."\n\n";
1108 | }
1109 |
1110 |
1111 | function makeCodeSpan($code) {
1112 | #
1113 | # Create a code span markup for $code. Called from handleSpanToken.
1114 | #
1115 | $code = htmlspecialchars(trim($code), ENT_NOQUOTES);
1116 | return $this->hashPart("$code");
1117 | }
1118 |
1119 |
1120 | var $em_relist = array(
1121 | '' => '(?:(? '(?<=\S|^)(? '(?<=\S|^)(? '(?:(? '(?<=\S|^)(? '(?<=\S|^)(? '(?:(? '(?<=\S|^)(? '(?<=\S|^)(?em_relist as $em => $em_re) {
1143 | foreach ($this->strong_relist as $strong => $strong_re) {
1144 | # Construct list of allowed token expressions.
1145 | $token_relist = array();
1146 | if (isset($this->em_strong_relist["$em$strong"])) {
1147 | $token_relist[] = $this->em_strong_relist["$em$strong"];
1148 | }
1149 | $token_relist[] = $em_re;
1150 | $token_relist[] = $strong_re;
1151 |
1152 | # Construct master expression from list.
1153 | $token_re = '{('. implode('|', $token_relist) .')}';
1154 | $this->em_strong_prepared_relist["$em$strong"] = $token_re;
1155 | }
1156 | }
1157 | }
1158 |
1159 | function doItalicsAndBold($text) {
1160 | $token_stack = array('');
1161 | $text_stack = array('');
1162 | $em = '';
1163 | $strong = '';
1164 | $tree_char_em = false;
1165 |
1166 | while (1) {
1167 | #
1168 | # Get prepared regular expression for seraching emphasis tokens
1169 | # in current context.
1170 | #
1171 | $token_re = $this->em_strong_prepared_relist["$em$strong"];
1172 |
1173 | #
1174 | # Each loop iteration search for the next emphasis token.
1175 | # Each token is then passed to handleSpanToken.
1176 | #
1177 | $parts = preg_split($token_re, $text, 2, PREG_SPLIT_DELIM_CAPTURE);
1178 | $text_stack[0] .= $parts[0];
1179 | $token =& $parts[1];
1180 | $text =& $parts[2];
1181 |
1182 | if (empty($token)) {
1183 | # Reached end of text span: empty stack without emitting.
1184 | # any more emphasis.
1185 | while ($token_stack[0]) {
1186 | $text_stack[1] .= array_shift($token_stack);
1187 | $text_stack[0] .= array_shift($text_stack);
1188 | }
1189 | break;
1190 | }
1191 |
1192 | $token_len = strlen($token);
1193 | if ($tree_char_em) {
1194 | # Reached closing marker while inside a three-char emphasis.
1195 | if ($token_len == 3) {
1196 | # Three-char closing marker, close em and strong.
1197 | array_shift($token_stack);
1198 | $span = array_shift($text_stack);
1199 | $span = $this->runSpanGamut($span);
1200 | $span = "$span";
1201 | $text_stack[0] .= $this->hashPart($span);
1202 | $em = '';
1203 | $strong = '';
1204 | } else {
1205 | # Other closing marker: close one em or strong and
1206 | # change current token state to match the other
1207 | $token_stack[0] = str_repeat($token{0}, 3-$token_len);
1208 | $tag = $token_len == 2 ? "strong" : "em";
1209 | $span = $text_stack[0];
1210 | $span = $this->runSpanGamut($span);
1211 | $span = "<$tag>$span";
1212 | $text_stack[0] = $this->hashPart($span);
1213 | $$tag = ''; # $$tag stands for $em or $strong
1214 | }
1215 | $tree_char_em = false;
1216 | } else if ($token_len == 3) {
1217 | if ($em) {
1218 | # Reached closing marker for both em and strong.
1219 | # Closing strong marker:
1220 | for ($i = 0; $i < 2; ++$i) {
1221 | $shifted_token = array_shift($token_stack);
1222 | $tag = strlen($shifted_token) == 2 ? "strong" : "em";
1223 | $span = array_shift($text_stack);
1224 | $span = $this->runSpanGamut($span);
1225 | $span = "<$tag>$span";
1226 | $text_stack[0] .= $this->hashPart($span);
1227 | $$tag = ''; # $$tag stands for $em or $strong
1228 | }
1229 | } else {
1230 | # Reached opening three-char emphasis marker. Push on token
1231 | # stack; will be handled by the special condition above.
1232 | $em = $token{0};
1233 | $strong = "$em$em";
1234 | array_unshift($token_stack, $token);
1235 | array_unshift($text_stack, '');
1236 | $tree_char_em = true;
1237 | }
1238 | } else if ($token_len == 2) {
1239 | if ($strong) {
1240 | # Unwind any dangling emphasis marker:
1241 | if (strlen($token_stack[0]) == 1) {
1242 | $text_stack[1] .= array_shift($token_stack);
1243 | $text_stack[0] .= array_shift($text_stack);
1244 | }
1245 | # Closing strong marker:
1246 | array_shift($token_stack);
1247 | $span = array_shift($text_stack);
1248 | $span = $this->runSpanGamut($span);
1249 | $span = "$span";
1250 | $text_stack[0] .= $this->hashPart($span);
1251 | $strong = '';
1252 | } else {
1253 | array_unshift($token_stack, $token);
1254 | array_unshift($text_stack, '');
1255 | $strong = $token;
1256 | }
1257 | } else {
1258 | # Here $token_len == 1
1259 | if ($em) {
1260 | if (strlen($token_stack[0]) == 1) {
1261 | # Closing emphasis marker:
1262 | array_shift($token_stack);
1263 | $span = array_shift($text_stack);
1264 | $span = $this->runSpanGamut($span);
1265 | $span = "$span";
1266 | $text_stack[0] .= $this->hashPart($span);
1267 | $em = '';
1268 | } else {
1269 | $text_stack[0] .= $token;
1270 | }
1271 | } else {
1272 | array_unshift($token_stack, $token);
1273 | array_unshift($text_stack, '');
1274 | $em = $token;
1275 | }
1276 | }
1277 | }
1278 | return $text_stack[0];
1279 | }
1280 |
1281 |
1282 | function doBlockQuotes($text) {
1283 | $text = preg_replace_callback('/
1284 | ( # Wrap whole match in $1
1285 | (?>
1286 | ^[ ]*>[ ]? # ">" at the start of a line
1287 | .+\n # rest of the first line
1288 | (.+\n)* # subsequent consecutive lines
1289 | \n* # blanks
1290 | )+
1291 | )
1292 | /xm',
1293 | array(&$this, '_doBlockQuotes_callback'), $text);
1294 |
1295 | return $text;
1296 | }
1297 | function _doBlockQuotes_callback($matches) {
1298 | $bq = $matches[1];
1299 | # trim one level of quoting - trim whitespace-only lines
1300 | $bq = preg_replace('/^[ ]*>[ ]?|^[ ]+$/m', '', $bq);
1301 | $bq = $this->runBlockGamut($bq); # recurse
1302 |
1303 | $bq = preg_replace('/^/m', " ", $bq);
1304 | # These leading spaces cause problem with content,
1305 | # so we need to fix that:
1306 | $bq = preg_replace_callback('{(\s*.+?
)}sx',
1307 | array(&$this, '_doBlockQuotes_callback2'), $bq);
1308 |
1309 | return "\n". $this->hashBlock("\n$bq\n
")."\n\n";
1310 | }
1311 | function _doBlockQuotes_callback2($matches) {
1312 | $pre = $matches[1];
1313 | $pre = preg_replace('/^ /m', '', $pre);
1314 | return $pre;
1315 | }
1316 |
1317 |
1318 | function formParagraphs($text) {
1319 | #
1320 | # Params:
1321 | # $text - string to process with html tags
1322 | #
1323 | # Strip leading and trailing lines:
1324 | $text = preg_replace('/\A\n+|\n+\z/', '', $text);
1325 |
1326 | $grafs = preg_split('/\n{2,}/', $text, -1, PREG_SPLIT_NO_EMPTY);
1327 |
1328 | #
1329 | # Wrap
tags and unhashify HTML blocks
1330 | #
1331 | foreach ($grafs as $key => $value) {
1332 | if (!preg_match('/^B\x1A[0-9]+B$/', $value)) {
1333 | # Is a paragraph.
1334 | $value = $this->runSpanGamut($value);
1335 | $value = preg_replace('/^([ ]*)/', "
", $value);
1336 | $value .= "
";
1337 | $grafs[$key] = $this->unhash($value);
1338 | }
1339 | else {
1340 | # Is a block.
1341 | # Modify elements of @grafs in-place...
1342 | $graf = $value;
1343 | $block = $this->html_hashes[$graf];
1344 | $graf = $block;
1345 | // if (preg_match('{
1346 | // \A
1347 | // ( # $1 = tag
1348 | // ]*
1350 | // \b
1351 | // markdown\s*=\s* ([\'"]) # $2 = attr quote char
1352 | // 1
1353 | // \2
1354 | // [^>]*
1355 | // >
1356 | // )
1357 | // ( # $3 = contents
1358 | // .*
1359 | // )
1360 | // () # $4 = closing tag
1361 | // \z
1362 | // }xs', $block, $matches))
1363 | // {
1364 | // list(, $div_open, , $div_content, $div_close) = $matches;
1365 | //
1366 | // # We can't call Markdown(), because that resets the hash;
1367 | // # that initialization code should be pulled into its own sub, though.
1368 | // $div_content = $this->hashHTMLBlocks($div_content);
1369 | //
1370 | // # Run document gamut methods on the content.
1371 | // foreach ($this->document_gamut as $method => $priority) {
1372 | // $div_content = $this->$method($div_content);
1373 | // }
1374 | //
1375 | // $div_open = preg_replace(
1376 | // '{\smarkdown\s*=\s*([\'"]).+?\1}', '', $div_open);
1377 | //
1378 | // $graf = $div_open . "\n" . $div_content . "\n" . $div_close;
1379 | // }
1380 | $grafs[$key] = $graf;
1381 | }
1382 | }
1383 |
1384 | return implode("\n\n", $grafs);
1385 | }
1386 |
1387 |
1388 | function encodeAttribute($text) {
1389 | #
1390 | # Encode text for a double-quoted HTML attribute. This function
1391 | # is *not* suitable for attributes enclosed in single quotes.
1392 | #
1393 | $text = $this->encodeAmpsAndAngles($text);
1394 | $text = str_replace('"', '"', $text);
1395 | return $text;
1396 | }
1397 |
1398 |
1399 | function encodeAmpsAndAngles($text) {
1400 | #
1401 | # Smart processing for ampersands and angle brackets that need to
1402 | # be encoded. Valid character entities are left alone unless the
1403 | # no-entities mode is set.
1404 | #
1405 | if ($this->no_entities) {
1406 | $text = str_replace('&', '&', $text);
1407 | } else {
1408 | # Ampersand-encoding based entirely on Nat Irons's Amputator
1409 | # MT plugin:
1425 | $text = preg_replace_callback('{
1426 | <
1427 | (?:mailto:)?
1428 | (
1429 | (?:
1430 | [-!#$%&\'*+/=?^_`.{|}~\w\x80-\xFF]+
1431 | |
1432 | ".*?"
1433 | )
1434 | \@
1435 | (?:
1436 | [-a-z0-9\x80-\xFF]+(\.[-a-z0-9\x80-\xFF]+)*\.[a-z]+
1437 | |
1438 | \[[\d.a-fA-F:]+\] # IPv4 & IPv6
1439 | )
1440 | )
1441 | >
1442 | }xi',
1443 | array(&$this, '_doAutoLinks_email_callback'), $text);
1444 |
1445 | return $text;
1446 | }
1447 | function _doAutoLinks_url_callback($matches) {
1448 | $url = $this->encodeAttribute($matches[1]);
1449 | $link = "$url";
1450 | return $this->hashPart($link);
1451 | }
1452 | function _doAutoLinks_email_callback($matches) {
1453 | $address = $matches[1];
1454 | $link = $this->encodeEmailAddress($address);
1455 | return $this->hashPart($link);
1456 | }
1457 |
1458 |
1459 | function encodeEmailAddress($addr) {
1460 | #
1461 | # Input: an email address, e.g. "foo@example.com"
1462 | #
1463 | # Output: the email address as a mailto link, with each character
1464 | # of the address encoded as either a decimal or hex entity, in
1465 | # the hopes of foiling most address harvesting spam bots. E.g.:
1466 | #
1467 | #
1471 | #
1472 | # Based by a filter by Matthew Wickline, posted to BBEdit-Talk.
1473 | # With some optimizations by Milian Wolff.
1474 | #
1475 | $addr = "mailto:" . $addr;
1476 | $chars = preg_split('/(? $char) {
1480 | $ord = ord($char);
1481 | # Ignore non-ascii chars.
1482 | if ($ord < 128) {
1483 | $r = ($seed * (1 + $key)) % 100; # Pseudo-random function.
1484 | # roughly 10% raw, 45% hex, 45% dec
1485 | # '@' *must* be encoded. I insist.
1486 | if ($r > 90 && $char != '@') /* do nothing */;
1487 | else if ($r < 45) $chars[$key] = '&#x'.dechex($ord).';';
1488 | else $chars[$key] = '&#'.$ord.';';
1489 | }
1490 | }
1491 |
1492 | $addr = implode('', $chars);
1493 | $text = implode('', array_slice($chars, 7)); # text without `mailto:`
1494 | $addr = "$text";
1495 |
1496 | return $addr;
1497 | }
1498 |
1499 |
1500 | function parseSpan($str) {
1501 | #
1502 | # Take the string $str and parse it into tokens, hashing embeded HTML,
1503 | # escaped characters and handling code spans.
1504 | #
1505 | $output = '';
1506 |
1507 | $span_re = '{
1508 | (
1509 | \\\\'.$this->escape_chars_re.'
1510 | |
1511 | (?no_markup ? '' : '
1514 | |
1515 | # comment
1516 | |
1517 | <\?.*?\?> | <%.*?%> # processing instruction
1518 | |
1519 | <[/!$]?[-a-zA-Z0-9:_]+ # regular tags
1520 | (?>
1521 | \s
1522 | (?>[^"\'>]+|"[^"]*"|\'[^\']*\')*
1523 | )?
1524 | >
1525 | ').'
1526 | )
1527 | }xs';
1528 |
1529 | while (1) {
1530 | #
1531 | # Each loop iteration seach for either the next tag, the next
1532 | # openning code span marker, or the next escaped character.
1533 | # Each token is then passed to handleSpanToken.
1534 | #
1535 | $parts = preg_split($span_re, $str, 2, PREG_SPLIT_DELIM_CAPTURE);
1536 |
1537 | # Create token from text preceding tag.
1538 | if ($parts[0] != "") {
1539 | $output .= $parts[0];
1540 | }
1541 |
1542 | # Check if we reach the end.
1543 | if (isset($parts[1])) {
1544 | $output .= $this->handleSpanToken($parts[1], $parts[2]);
1545 | $str = $parts[2];
1546 | }
1547 | else {
1548 | break;
1549 | }
1550 | }
1551 |
1552 | return $output;
1553 | }
1554 |
1555 |
1556 | function handleSpanToken($token, &$str) {
1557 | #
1558 | # Handle $token provided by parseSpan by determining its nature and
1559 | # returning the corresponding value that should replace it.
1560 | #
1561 | switch ($token{0}) {
1562 | case "\\":
1563 | return $this->hashPart("&#". ord($token{1}). ";");
1564 | case "`":
1565 | # Search for end marker in remaining text.
1566 | if (preg_match('/^(.*?[^`])'.preg_quote($token).'(?!`)(.*)$/sm',
1567 | $str, $matches))
1568 | {
1569 | $str = $matches[2];
1570 | $codespan = $this->makeCodeSpan($matches[1]);
1571 | return $this->hashPart($codespan);
1572 | }
1573 | return $token; // return as text since no ending marker found.
1574 | default:
1575 | return $this->hashPart($token);
1576 | }
1577 | }
1578 |
1579 |
1580 | function outdent($text) {
1581 | #
1582 | # Remove one level of line-leading tabs or spaces
1583 | #
1584 | return preg_replace('/^(\t|[ ]{1,'.$this->tab_width.'})/m', '', $text);
1585 | }
1586 |
1587 |
1588 | # String length function for detab. `_initDetab` will create a function to
1589 | # hanlde UTF-8 if the default function does not exist.
1590 | var $utf8_strlen = 'mb_strlen';
1591 |
1592 | function detab($text) {
1593 | #
1594 | # Replace tabs with the appropriate amount of space.
1595 | #
1596 | # For each line we separate the line in blocks delemited by
1597 | # tab characters. Then we reconstruct every line by adding the
1598 | # appropriate number of space between each blocks.
1599 |
1600 | $text = preg_replace_callback('/^.*\t.*$/m',
1601 | array(&$this, '_detab_callback'), $text);
1602 |
1603 | return $text;
1604 | }
1605 | function _detab_callback($matches) {
1606 | $line = $matches[0];
1607 | $strlen = $this->utf8_strlen; # strlen function for UTF-8.
1608 |
1609 | # Split in blocks.
1610 | $blocks = explode("\t", $line);
1611 | # Add each blocks to the line.
1612 | $line = $blocks[0];
1613 | unset($blocks[0]); # Do not add first block twice.
1614 | foreach ($blocks as $block) {
1615 | # Calculate amount of space, insert spaces, insert block.
1616 | $amount = $this->tab_width -
1617 | $strlen($line, 'UTF-8') % $this->tab_width;
1618 | $line .= str_repeat(" ", $amount) . $block;
1619 | }
1620 | return $line;
1621 | }
1622 | function _initDetab() {
1623 | #
1624 | # Check for the availability of the function in the `utf8_strlen` property
1625 | # (initially `mb_strlen`). If the function is not available, create a
1626 | # function that will loosely count the number of UTF-8 characters with a
1627 | # regular expression.
1628 | #
1629 | if (function_exists($this->utf8_strlen)) return;
1630 | $this->utf8_strlen = create_function('$text', 'return preg_match_all(
1631 | "/[\\\\x00-\\\\xBF]|[\\\\xC0-\\\\xFF][\\\\x80-\\\\xBF]*/",
1632 | $text, $m);');
1633 | }
1634 |
1635 |
1636 | function unhash($text) {
1637 | #
1638 | # Swap back in all the tags hashed by _HashHTMLBlocks.
1639 | #
1640 | return preg_replace_callback('/(.)\x1A[0-9]+\1/',
1641 | array(&$this, '_unhash_callback'), $text);
1642 | }
1643 | function _unhash_callback($matches) {
1644 | return $this->html_hashes[$matches[0]];
1645 | }
1646 |
1647 | }
1648 |
1649 | /*
1650 |
1651 | PHP Markdown
1652 | ============
1653 |
1654 | Description
1655 | -----------
1656 |
1657 | This is a PHP translation of the original Markdown formatter written in
1658 | Perl by John Gruber.
1659 |
1660 | Markdown is a text-to-HTML filter; it translates an easy-to-read /
1661 | easy-to-write structured text format into HTML. Markdown's text format
1662 | is most similar to that of plain text email, and supports features such
1663 | as headers, *emphasis*, code blocks, blockquotes, and links.
1664 |
1665 | Markdown's syntax is designed not as a generic markup language, but
1666 | specifically to serve as a front-end to (X)HTML. You can use span-level
1667 | HTML tags anywhere in a Markdown document, and you can use block level
1668 | HTML tags (like and as well).
1669 |
1670 | For more information about Markdown's syntax, see:
1671 |
1672 |
1681 |
1682 | Please include with your report: (1) the example input; (2) the output you
1683 | expected; (3) the output Markdown actually produced.
1684 |
1685 |
1686 | Version History
1687 | ---------------
1688 |
1689 | See the readme file for detailed release notes for this version.
1690 |
1691 |
1692 | Copyright and License
1693 | ---------------------
1694 |
1695 | PHP Markdown
1696 | Copyright (c) 2004-2009 Michel Fortin
1697 |