home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 April / CMCD0404.ISO / Software / Freeware / Programare / groupoffice-com-2.01 / modules / wiki / parse / transforms.php < prev   
PHP Script  |  2004-03-08  |  20KB  |  701 lines
  1. <?php
  2. // $Id: transforms.php,v 1.1 2004/01/12 22:14:05 comsubvie Exp $
  3.  
  4. // The main parser components.  Each of these takes a line of text and scans it
  5. //   for particular wiki markup.  It converts markup elements to
  6. //   $FlgChr . x . $FlgChr, where x is an index into the global array $Entity,
  7. //   which contains descriptions of each markup entity.  Later, these will be
  8. //   converted back into HTML  (or, in the future, perhaps some other
  9. //   representation such as XML).
  10.  
  11. function parse_noop($text)
  12. {
  13.   return $text;
  14. }
  15.  
  16. // The following function "corrects" for PHP's odd preg_replace behavior.
  17. // Back-references have backslashes inserted before certain quotes
  18. // (specifically, whichever quote was used around the backreference); this
  19. // function removes remove those backslashes.
  20.  
  21. function q1($text)
  22.   { return str_replace('\\"', '"', $text); }
  23.  
  24. function validate_page($page)
  25. {
  26.   global $FlgChr;
  27.  
  28.   $p = parse_wikiname($page, 1);
  29.   if(preg_match('/^' . $FlgChr .'!?'. '\\d+' . $FlgChr . '$/', $p))
  30.     { return 1; }
  31.   $p = parse_freelink('((' . $page . '))', 1);
  32.   if(preg_match('/^' . $FlgChr . '!?'. '\\d+' . $FlgChr . '$/', $p))
  33.     { return 2; }
  34.   return 0;
  35. }
  36.  
  37. function pre_parser($text)
  38. {
  39. // Before parsing the whole text, do check for line continuation and forced
  40. // line breaks. To achieve this, and still have code-sections, code-sections
  41. // need to be parsed in this section as well
  42.  
  43.   // Parse the code sections, to escape them from the line control
  44.   $text = preg_replace("/\n\s*<((?:php)?code)>\s*\n(.*\n)\s*<\\/\\1>\s*(?=\n|$)/Usei", 
  45.                        "q1('\n').code_token('\\1',q1('\\2'))", $text); 
  46.  
  47.   // Concatenate lines ending in a single \
  48.   $text = preg_replace("/([^\\\])\\\\\n\s*/s", " ", $text);
  49.  
  50.   // Insert page breaks to lines ending in a double \
  51.   $text = preg_replace("/\\\\\\\\\n\s*/se", "new_entity(array('newline'))", 
  52.                        $text);
  53.   return $text;
  54. }
  55.  
  56. function code_token($codetype, $code) 
  57. {
  58.   global $FlgChr, $Entity;
  59.  
  60.   if (stristr("code", $codetype))
  61.     { $Entity[count($Entity)] = array('code', parse_htmlisms($code)); } 
  62.   else if (stristr("phpcode", $codetype))
  63.     { $Entity[count($Entity)] = array('phpcode', $code); }
  64.  
  65.   return $FlgChr . (count($Entity)-1) . $FlgChr; //Is a blockelement
  66. }
  67.  
  68. function parse_elem_flag($text)
  69. {
  70.   global $FlgChr;
  71.  
  72.   // Hide element flags (0xFF) from view.
  73.   return preg_replace('/' . $FlgChr . '/e', "new_entity(array('raw', '$FlgChr'))", $text, -1);
  74. }
  75.  
  76. function new_entity($array,$blockElem=true)
  77. {
  78.   global $Entity, $FlgChr;
  79.  
  80.   $Entity[count($Entity)] = $array;
  81.   return $FlgChr . ($blockElem ? '' : '!') . (count($Entity) - 1) . $FlgChr;
  82. }
  83.  
  84. function parse_wikiname($text, $validate = 0)
  85. {
  86.   global $LinkPtn, $EnableWikiLinks;
  87.  
  88.   if(!$EnableWikiLinks) { return $text; }
  89.  
  90.   if($validate)
  91.     { $ptn = "/(^|[^A-Za-z])(\\/?$LinkPtn)(())(\"\")?/e"; }
  92.   else
  93.     { $ptn = "/(^|[^A-Za-z])(!?\\/?$LinkPtn)((\#[A-Za-z]([-A-Za-z0-9_:.]*[-A-Za-z0-9_])?)?)(\"\")?/e"; }
  94.  
  95.   return preg_replace($ptn,
  96.                       "q1('\\1').wikiname_token(q1('\\2'),'\\3')",
  97.                       $text, -1);
  98. }
  99.  
  100. function wikiname_token($name, $anchor)
  101. {
  102.   global $ParseObject;
  103.   if($name[0] == '!')                   // No-link escape sequence.
  104.     { return substr($name, 1); }        // Trim leading '!'.
  105.   $link = $name;
  106.   // translate sub-page markup into a qualified wikiword
  107.   if ($name[0] == '/')
  108.     { 
  109.       if (preg_match("|(.*)\\/[^\\/]*|", $ParseObject, $path)) 
  110.         { $link = $path[1] . $name; }
  111.       else
  112.         { $link = substr($name,1); } 
  113.     }
  114.  
  115.   return new_entity(array('ref', $link, $name, '', $anchor, $anchor),false);
  116. }
  117.  
  118. function parse_freelink($text, $validate = 0)
  119. {
  120.   global $EnableFreeLinks;
  121.  
  122.   if(!$EnableFreeLinks) { return $text; }
  123.  
  124.   if($validate)
  125.   {
  126.     $ptn = "/\\(\\(([^\\|\\)]+)()()\\)\\)/e";
  127.   }
  128.   else
  129.   {
  130.     $ptn = "/(!?\\(\\(([^\\|\\)]+)(\\|[^\\)#]+)?(\\#[A-Za-z][-A-Za-z0-9_:.]*)?()\\)\\))/e";
  131.   }
  132.  
  133.   return preg_replace($ptn,
  134.                       "freelink_token(q1('\\2'), q1('\\3'), '\\4', '', '\\1')",
  135.                       $text, -1);
  136. }
  137.  
  138. function freelink_token($link, $appearance, $anchor, $anchor_appearance, $nolink)
  139. {
  140.   global $ParseObject, $FlgChr;
  141.   if($nolink[0] == '!')                              // No-link escape sequence.
  142.     { return new_entity(array('raw', substr($nolink, 1))); } // Trim leading '!'
  143.   
  144.   if($appearance == '')
  145.     { $appearance = $link; }
  146.   else
  147.   { 
  148.     $appearance = substr($appearance, 1);    // Trim leading '|'.
  149.     if (preg_match("/$FlgChr/", $appearance)) 
  150.       { $appearance = parse_elements($appearance); }
  151.   }
  152.  
  153.   // translate sub-page markup into a qualified wikiword
  154.   if ($link[0] == '/')
  155.     { 
  156.       if (preg_match("|(.*)\\/[^\\/]*|", $ParseObject, $path)) 
  157.         { $link = $path[1] . $link; }
  158.       else
  159.         { $link = substr($link,1); } 
  160.     }
  161.   if (preg_match("/$FlgChr/", $link)) 
  162.     { return $nolink; }
  163.   else 
  164.   {
  165.     return new_entity(array('ref', $link, $appearance, '',
  166.                           $anchor, $anchor_appearance), false);
  167.   }
  168. }
  169.  
  170. function parse_interwiki($text)
  171. {
  172.   global $InterwikiPtn;
  173.  
  174.   return preg_replace("/(^|[^A-Za-z])($InterwikiPtn)(?=\$|[^\\/=&~A-Za-z0-9])/e",
  175.                       "q1('\\1').interwiki_token(q1('\\3'),q1('\\4')).q1('\\5')",
  176.                       $text, -1);
  177. }
  178.  
  179. function interwiki_token($prefix, $ref)
  180. {
  181.   global $pagestore;
  182.  
  183.   if(($url = $pagestore->interwiki($prefix)) != '')
  184.   {
  185.     return new_entity(array('interwiki', $url . $ref, $prefix . ':' . $ref), false);
  186.   }
  187.  
  188.   return $prefix . ':' . $ref;
  189. }
  190.  
  191. function parse_hyperlink_ref($text)
  192. {
  193.   global $UrlPtn,$InterwikiPtn;
  194.  
  195.   return preg_replace("/\\[($UrlPtn|$InterwikiPtn)]/Ue",
  196.                       "url_token(q1('\\1'), '')", $text, -1);
  197. }
  198. function image_search($text) 
  199. {
  200.   global $ImgPtn, $ExtRef;
  201.   if (preg_match("/$ImgPtn$/", $text))
  202.     { return parse_elements(parse_hyperlink($text)); }
  203.   else 
  204.     { return $ExtRef[0] . $text . $ExtRef[1]; }
  205. }
  206. function parse_hyperlink_description($text)
  207. {
  208.   global $UrlPtn, $InterwikiPtn;
  209.   return preg_replace("/\\[($UrlPtn|$InterwikiPtn) ([^]]+)]/e",
  210.                       "url_token(q1('\\1'),image_search('\\4'))", 
  211.                       $text, -1);
  212. }
  213.  
  214. function parse_hyperlink($text)
  215. {
  216.   global $UrlPtn, $InterwikiPtn;
  217.  
  218.   return preg_replace("/(^|[^A-Za-z])($UrlPtn|$InterwikiPtn)(?=\$|[^\\/?=&~A-Za-z0-9])/e",
  219.                       "q1('\\1').url_token(q1('\\2'), q1('\\2')).q1('\\5')", $text, -1);
  220. }
  221.  
  222. function url_token($value, $display)
  223. {
  224.   global $pagestore, $InterwikiPtn, $UrlPtn, $RefList, $ImgPtn;
  225.   static $count = 1;
  226.   // Expand interwiki-entry, if necessary
  227.   if ((!preg_match("/$UrlPtn/", $value)) and
  228.       preg_match("/$InterwikiPtn/", $value, $match))  
  229.   {
  230.      $couldBeImage=($display==$value);
  231.      if (($url=$pagestore->interwiki($match[1])) != '') 
  232.        { $value = $url . $match[2];
  233.          if ($couldBeImage and preg_match("/$ImgPtn$/", $value)) 
  234.            { $display = $value; }
  235.        }
  236.      else
  237.        { $value = "[$match[1]:$match[2] $display]"; }
  238.   }
  239.  
  240.   if($display == '')
  241.     { $display = '[' . $count++ . ']';
  242.       $RefList[] = $value; }
  243.  
  244.   return new_entity(array('url', $value, $display), false);
  245. }
  246.  
  247. function parse_macros($text)
  248. {
  249.   return preg_replace('/\\[\\[([^] ]+( [^]]+)?)]]/e',
  250.                       "macro_token(q1('\\1'), q1('\\3'))", $text, -1);
  251.  
  252. }
  253.  
  254. function parse_no_macros($text)
  255. {
  256.   return preg_replace('/\\[\\[([^] ]+( [^]]+)?)]]/e',
  257.                       "", $text, -1);
  258.  
  259. }
  260.  
  261. function macro_token($macro, $trail)
  262. {
  263.   global $ViewMacroEngine;
  264.  
  265.   $cmd  = strtok($macro, ' ');
  266.   $args = strtok('');
  267.  
  268.   if($ViewMacroEngine[$cmd] != '')
  269.     { return new_entity(array('raw', $ViewMacroEngine[$cmd]($args))); }
  270.   else
  271.     { return '[[' . $macro . ']]' . ($trail == "\n" ? $trail : ''); }
  272. }
  273.  
  274. function parse_transclude($text)
  275. {
  276.   $text2 = preg_replace('/%%([^%]+)%%/e',
  277.                         "transclude_token(q1('\\1'))", $text, -1);
  278.   if($text2 != $text)
  279.     { $text2 = str_replace("\n", '', $text2); }
  280.   return $text2;
  281. }
  282.  
  283. function transclude_token($text)
  284. {
  285.   global $pagestore, $ParseEngine, $ParseObject;
  286.   static $visited_array = array();
  287.   static $visited_count = 0;
  288.  
  289.   if(!validate_page($text))
  290.     { return '%%' . $text . '%%'; }
  291.  
  292.   $visited_array[$visited_count++] = $ParseObject;
  293.   for($i = 0; $i < $visited_count; $i++)
  294.   {
  295.     if($visited_array[$i] == $text)
  296.     {
  297.       $visited_count--;
  298.       return '%%' . $text . '%%';
  299.     }
  300.   }
  301.  
  302.   $pg = $pagestore->page($text);
  303.   $pg->read();
  304.   if(!$pg->exists)
  305.   {
  306.     $visited_count--;
  307.     return '%%' . $text . '%%';
  308.   }
  309.  
  310.   $result = new_entity(array('raw', parseText($pg->text, $ParseEngine, $text)));
  311.   $visited_count--;
  312.   return $result;
  313. }
  314.  
  315. function parse_textenhance($text) 
  316. {
  317.   global $EnableTextEnhance;
  318.  
  319.   if ($EnableTextEnhance) 
  320.   {
  321.     if (preg_match("/^(\*+)([^*].*)$/", $text, $match)) 
  322.     {
  323.        // Special case, since *'s at start of line is markup for lists
  324.        $return = $match[1] . 
  325.                  preg_replace("/(\*\*)([^*]+)\\1/e", 
  326.                               "pair_tokens('bold', q1('\\2'))", $match[2], -1);
  327.     } 
  328.     else 
  329.     {
  330.        $return = preg_replace("/(\*\*)([^*]+)\\1/e", 
  331.                               "pair_tokens('bold', q1('\\2'))", $text, -1);
  332.     }
  333.     $return = preg_replace( "/(\/\/)([^\/]+)\\1/e", 
  334.                              "pair_tokens('italic', q1('\\2'))", $return, -1);
  335.     $return = preg_replace( "/(--)([^-]+)\\1/e", 
  336.                              "pair_tokens('del', q1('\\2'))", $return, -1);
  337.     $return = preg_replace( "/(\+\+)([^\+]+)\\1/e", 
  338.                              "pair_tokens('ins', q1('\\2'))", $return, -1);
  339.     $return = preg_replace( "/(\^\^)([^^]+)\\1/e", 
  340.                              "pair_tokens('superscript', q1('\\2'))", $return, -1);
  341.     $return = preg_replace( "/(,,)([^,]+)\\1/e", 
  342.                             "pair_tokens('subscript', q1('\\2'))", $return, -1);
  343.     return $return; 
  344.   } else { 
  345.     return $text; 
  346.   }
  347. } 
  348.  
  349. function parse_bold($text)
  350. {
  351.   return preg_replace("/'''(()|[^'].*)'''/Ue", "pair_tokens('bold', q1('\\1'))",
  352.                       $text, -1);
  353. }
  354.  
  355. function parse_italic($text)
  356. {
  357.   return preg_replace("/''(()|[^'].*)''/Ue", "pair_tokens('italic', q1('\\1'))",
  358.                       $text, -1);
  359. }
  360.  
  361. function parse_teletype($text)
  362. {
  363.   return preg_replace("/{{({*?.*}*?)}}/Ue",
  364.                       "pair_tokens('tt', q1('\\1'))", $text, -1);
  365. }
  366.  
  367. function pair_tokens($type, $text, $blockElem=false)
  368. {
  369.   global $Entity, $FlgChr;
  370.  
  371.   $Entity[count($Entity)] = array($type . '_start');
  372.   $Entity[count($Entity)] = array($type . '_end');
  373.  
  374.   return $FlgChr . ($blockElem ? '' : '!') . (count($Entity) - 2) . $FlgChr . $text .
  375.          $FlgChr . ($blockElem ? '' : '!') . (count($Entity) - 1) . $FlgChr;
  376. }
  377.  
  378. function parse_newline($text)
  379. {
  380.   global $FlgChr;
  381.   static $last = array('', '');
  382.  
  383.   // More than two consecutive newlines fold into two newlines.
  384.   if($last[0] == "\n" && $last[1] == "\n" && $text == "\n")
  385.     { return ''; }
  386.   $last[0] = $last[1];
  387.   $last[1] = $text;
  388.  
  389.   // Lines not beginning with $FlgChr or beginning with $FlgChr! are paragraps
  390.   return preg_replace("/^(([^$FlgChr]|$FlgChr!).+)$/e",
  391.                       "pair_tokens('paragraph', q1('\\1'), true)", $text, -1);
  392. }
  393.  
  394. function parse_horiz($text)
  395. {
  396.   return preg_replace("/-{4,}(\\n(\\r)?)?/e", "new_entity(array('hr'))",
  397.                       $text, -1);
  398. }
  399.  
  400. function parse_nowiki($text)
  401. {
  402.   return preg_replace("/```(.*)```/Ue",
  403.                       "new_entity(array('nowiki', parse_elements(q1('\\1'))))",
  404.                       $text, -1);
  405. }
  406.  
  407. function parse_raw_html($text)
  408. {
  409.   global $Entity, $FlgChr;
  410.   static $in_html = 0;
  411.   static $buffer  = '';
  412.  
  413.   if($in_html)
  414.   {
  415.     if(strtolower($text) == "</html>\n")
  416.     {
  417.       $Entity[count($Entity)] = array('raw', $buffer);
  418.       $buffer  = '';
  419.       $in_html = 0;
  420.       return $FlgChr . (count($Entity) - 1) . $FlgChr; //$blockElem=true
  421.     }
  422.  
  423.     $buffer = $buffer . parse_elements($text);
  424.     return '';
  425.   }
  426.   else
  427.   {
  428.     if(strtolower($text) == "<html>\n")
  429.     {
  430.       $in_html = 1;
  431.       return '';
  432.     }
  433.  
  434.     return $text;
  435.   }
  436. }
  437.  
  438. function parse_indents($text)
  439. {
  440.   global $MaxNesting;
  441.   static $last_prefix = '';             // Last line's prefix.
  442.  
  443. // Locate the indent prefix characters.
  444.  
  445.   preg_match('/^([:\\*#]*)(;([^:]*):)?(.*\\n?$)/', $text, $result);
  446.  
  447.   if($result[2] != '')                  // Definition list.
  448.     { $result[1] = $result[1] . ';'; }
  449.  
  450. // No list on last line, no list on this line.  Bail out:
  451.  
  452.   if($last_prefix == '' && $result[1] == '') 
  453.     { return $text; }                   // Common case fast.
  454.  
  455. // Remember lengths of strings.
  456.  
  457.   $last_len   = strlen($last_prefix);
  458.   $prefix_len = strlen($result[1]);
  459.  
  460.   $text = $result[4];
  461.  
  462.   $fixup = '';
  463.  
  464. // Loop through and look for prefix characters in common with the
  465. // previous line.
  466.  
  467.   for($i = 0;
  468.       $i < $MaxNesting && ($i < $last_len || $i < $prefix_len);
  469.       $i++)
  470.   {
  471.     // If equal, continue.
  472.     if($i < $last_len && $i < $prefix_len     // Neither past end.
  473.        && $last_prefix[$i] == $result[1][$i]) // Equal content.
  474.       { continue; }
  475.  
  476.     // If we've gone deeper than the previous line, we're done.
  477.     if($i >= $last_len)
  478.       { break; }
  479.  
  480.     // If last line goes further than us, end its dangling lists.
  481.     if($i >= $prefix_len                      // Current line ended.
  482.        || $last_prefix[$i] != $result[1][$i]) // Or not, but they differ.
  483.     {
  484.       for($j = $i; $j < $MaxNesting && $j < $last_len; $j++)
  485.       {
  486.         $fixup = entity_listitem($last_prefix[$j], 'end')
  487.                  . entity_list($last_prefix[$j], 'end')
  488.                  . $fixup;
  489.       }
  490.       break;
  491.     }
  492.   }
  493.  
  494. // End the preceding line's list item if we're starting another one
  495. // at the same level.
  496.  
  497.   if($i > 0 && $i >= $prefix_len)
  498.     { $fixup = $fixup . entity_listitem($last_prefix[$i - 1], 'end'); }
  499.  
  500. // Start fresh new lists for this line as needed.
  501. // We start all but the last one as *indents* (definition lists)
  502. // instead of what they really may appear as, since their function is
  503. // really just to indent.
  504.  
  505.   for(; $i < $MaxNesting - 1 && $i + 1 < $prefix_len; $i++)
  506.   {
  507.     $result[1][$i] = ':';             // Pretend to be an indent.
  508.     $fixup = $fixup
  509.              . entity_list(':', 'start')
  510.              . entity_listitem(':', 'start');
  511.   }
  512.   if($i < $prefix_len)                // Start the list itself.
  513.   {
  514.     $fixup = $fixup
  515.              . entity_list($result[1][$i], 'start');
  516.   }
  517.  
  518. // Start the list *item*.
  519.  
  520.   if($result[2] != '')                // Definition list.
  521.   {
  522.     $fixup = $fixup
  523.              . new_entity(array('term_item_start'))
  524.              . $result[3]
  525.              . new_entity(array('term_item_end'));
  526.   }
  527.  
  528.   if($result[1] != '')
  529.     { $text = entity_listitem(substr($result[1], -1), 'start') . $text; }
  530.  
  531.   $text = $fixup . $text;
  532.  
  533.   $last_prefix = $result[1];
  534.  
  535.   return $text;
  536. }
  537.  
  538. function entity_list($type, $fn, $attr='')
  539. {
  540.   if($type == '*')
  541.     { return new_entity(array('bullet_list_' . $fn, $attr)); }
  542.   else if($type == ':' || $type == ';')
  543.     { return new_entity(array('indent_list_' . $fn)); }
  544.   else if($type == '#')
  545.     { return new_entity(array('numbered_list_' . $fn)); }
  546. }
  547.  
  548. function entity_listitem($type, $fn)
  549. {
  550.   if($type == '*')
  551.     { return new_entity(array('bullet_item_' . $fn)); }
  552.   else if($type == ':' || $type == ';')
  553.     { return new_entity(array('indent_item_' . $fn)); }
  554.   else if($type == '#')
  555.     { return new_entity(array('numbered_item_' . $fn)); }
  556. }
  557.  
  558. function parse_heading($text)
  559. {
  560.   global $MaxHeading;
  561.  
  562.   if(!preg_match('/^\s*(=+) (.*) (=+)\s*$/', $text, $result))
  563.     { return $text; }
  564.  
  565.   if(strlen($result[1]) != strlen($result[3]))
  566.     { return $text; }
  567.  
  568.   if(($level = strlen($result[1])) > $MaxHeading)
  569.     { $level = $MaxHeading; }
  570.  
  571.   return new_entity(array('head_start', $level)) .
  572.          $result[2] .
  573.          new_entity(array('head_end', $level));
  574. }
  575.  
  576. function parse_htmlisms($text)
  577. {
  578.   $text = str_replace('&', '&', $text);
  579.   $text = str_replace('<', '<', $text);
  580.   return $text;
  581. }
  582.  
  583. function parse_elements($text)
  584. {
  585.   global $FlgChr;
  586.   return preg_replace("/$FlgChr!?(\\d+)$FlgChr/e", "generate_element(q1('\\1'))", $text, -1);
  587. }
  588.  
  589. function generate_element($text)
  590. {
  591.   global $Entity, $DisplayEngine;
  592.  
  593.   if(function_exists('call_user_func_array'))
  594.   {
  595.     return call_user_func_array($DisplayEngine[$Entity[$text][0]],
  596.                                 array_slice($Entity[$text], 1));
  597.   }
  598.   else
  599.   {
  600.     return $DisplayEngine[$Entity[$text][0]]($Entity[$text][1],
  601.                                              $Entity[$text][2],
  602.                                              $Entity[$text][3],
  603.                                              $Entity[$text][4],
  604.                                              $Entity[$text][5]);
  605.   }
  606. }
  607.  
  608. function parse_diff_skip($text)
  609. {
  610.   if(preg_match('/^--+/', $text))
  611.     { return ''; }
  612.   if(preg_match('/^\\\\ No newline/', $text))
  613.     { return ''; }
  614.   return $text;
  615. }
  616.  
  617. function parse_diff_color($text)
  618. {
  619.   static $in_old = 0;
  620.   static $in_new = 0;
  621.  
  622.   if(strlen($text) == 0)
  623.     { $this_old = $this_new = 0; }
  624.   else
  625.   {
  626.     $this_old = ($text[0] == '<');
  627.     $this_new = ($text[0] == '>');
  628.   }
  629.  
  630.   if($this_old || $this_new)
  631.     { $text = substr($text, 2); }
  632.  
  633.   if($this_old && !$in_old)
  634.     { $text = new_entity(array('diff_old_start')) . $text; }
  635.   else if($this_new && !$in_new)
  636.     { $text = new_entity(array('diff_new_start')) . $text; }
  637.  
  638.   if($in_old && !$this_old)
  639.     { $text = new_entity(array('diff_old_end')) . $text; }
  640.   else if($in_new && !$this_new)
  641.     { $text = new_entity(array('diff_new_end')) . $text; }
  642.  
  643.   $in_old = $this_old;
  644.   $in_new = $this_new;
  645.  
  646.   return $text;
  647. }
  648.  
  649. function parse_diff_message($text)
  650. {
  651.   global $FlgChr;
  652.  
  653.   $text = preg_replace('/(^(' . $FlgChr . '\\d+' . $FlgChr . ')?)\\d[0-9,]*c[0-9,]*$/e',
  654.                        "q1('\\1').new_entity(array('diff_change'))", $text, -1);
  655.   $text = preg_replace('/(^(' . $FlgChr . '\\d+' . $FlgChr . ')?)\\d[0-9,]*a[0-9,]*$/e',
  656.                        "q1('\\1').new_entity(array('diff_add'))", $text, -1);
  657.   $text = preg_replace('/(^(' . $FlgChr . '\\d+' . $FlgChr . ')?)\\d[0-9,]*d[0-9,]*$/e',
  658.                        "q1('\\1').new_entity(array('diff_delete'))", $text, -1);
  659.  
  660.   return $text;
  661. }
  662.  
  663. function parse_table($text)
  664. {
  665.   static $in_table = 0;
  666.  
  667.   $pre = '';
  668.   $post = '';
  669.   if(preg_match('/^(\|\|)+(\{([^{}]+)\})?.*(\|\|)\s*$/', $text, $args))  // Table.
  670.   {
  671.     if(!$in_table)
  672.     {
  673.       $pre = html_table_start($args[3]);
  674.       $in_table = 1;
  675.     }
  676.     $text = preg_replace('/\|\s+\|/e',
  677.                          "q1('|').new_entity(array('raw',' ')).q1('|')", 
  678.                          $text);
  679.     $text = preg_replace('/^((\|\|+)(\{([^{}]+)\})?)(.*)\|\|\s*$/e',
  680.                          "new_entity(array('raw',html_table_row_start('\\4').
  681.                                                  html_table_cell_start(strlen('\\2')/2, '\\4'))).".
  682.                          "q1('\\5').new_entity(array('raw',html_table_cell_end().html_table_row_end()))",
  683.                          $text, -1);
  684.     $text = preg_replace('/((\|\|+)(\{([^{}]+)\})?)/e',
  685.                          "new_entity(array('raw',html_table_cell_end().html_table_cell_start(strlen('\\2')/2, '\\4')))",
  686.                          $text, -1);
  687.   }
  688.   else if($in_table)                    // Have exited table.
  689.   {
  690.     $in_table = 0;
  691.     $pre = html_table_end();
  692.   }
  693.  
  694.   if($pre != '')
  695.     { $text = new_entity(array('raw', $pre)) . $text; }
  696.   if($post != '')
  697.     { $text = $text . new_entity(array('raw', $post)); }
  698.  
  699.   return $text;
  700. }
  701. ?>