lib/transform.php

   1 <?php rcs_id('$Id: transform.php,v 1.27 2001-11-16 22:59:02 dairiki Exp $');
   2 require_once('lib/WikiPlugin.php');
   3
   4 define('WT_SIMPLE_MARKUP', 0);
   5 define('WT_TOKENIZER', 1);
   6 define('WT_MODE_MARKUP', 2);
   7
   8 define("ZERO_LEVEL", 0);
   9 define("NESTED_LEVEL", 1);
  10
  11 class WikiTransform
  12 {
  13    // public variables (only meaningful during do_transform)
  14    var $linenumber;     // current linenumber
  15    var $replacements;   // storage for tokenized strings of current line
  16    var $user_data;      // can be used by the transformer functions
  17                         // to store miscellaneous data.
  18
  19    // private variables
  20    var $content;        // wiki markup, array of lines
  21    var $mode_set;       // stores if a HTML mode for this line has been set
  22    var $trfrm_func;     // array of registered functions
  23    var $stack;          // stack for SetHTMLMode (keeping track of open tags)
  24
  25    /** init function */
  26    function WikiTransform()
  27    {
  28       $this->trfrm_func = array();
  29       $this->stack = new Stack;
  30    }
  31
  32    /**
  33     * Register transformation functions
  34     *
  35     * This should be done *before* calling do_transform
  36     *
  37     * @param $type enum  <dl>
  38     * <dt>WT_MODE_MARKUP</dt>
  39     * <dd>If one WT_MODE_MARKUP really sets the html mode, then
  40     *     all successive WT_MODE_MARKUP functions are skipped.</dd>
  41     * <dt>WT_TOKENIZER</dt>
  42     * <dd> The transformer function is called once for each match
  43     *      of the $regexp in the line.  The matched values are tokenized
  44     *      to protect them from further transformation.</dd>
  45     *
  46     * @param $function string  Function name
  47     * @param $regexp string  Required for WT_TOKENIZER functions.
  48     * Optional for others. If given, the transformer function will only be
  49     * called if the line matches the $regexp.
  50     */
  51    function register($type, $function, $regexp = false)
  52    {
  53       $this->trfrm_func[] = array ($type, $function, $regexp);
  54    }
  55
  56    /**
  57     * Sets current mode like list, preformatted text, plain text
  58     *
  59     * Takes care of closing (open) tags
  60     *
  61     * This is a helper function used to keep track of what HTML
  62     * block-level element we are currently processing.
  63     * Block-level elements are things like paragraphs "<p>",
  64     * pre-formatted text "<pre>", and the various list elements:
  65     * "<ul>", "<ol>" and "<dl>".  Now, SetHTMLMode is also used to
  66     * keep track of "<li>" and "<dd>" elements. Note that some of these elements
  67     * can be nested, while others can not.  (In particular, according to
  68     * the HTML 4.01 specification,  a paragraph "<p>" element is not
  69     * allowed to contain any other block-level elements.  Also <pre>,
  70     * <li>,  <dt>, <dd>, <h1> ... have this same restriction.)
  71     *
  72     * SetHTMLMode generates whatever HTML is necessary to get us into
  73     * the requested element type at the requested nesting level.
  74     *
  75     * @param $tag string Type of HTML element to open.
  76     *
  77     * If $tag is an array, $tag[0] gives the element type,
  78     * and $tag[1] should be a hash containing attribute-value
  79     * pairs for the element.
  80     *
  81     * If $tag is the empty string, all open elements (down to the
  82     * level requested by $level) are closed.  Use
  83     * SetHTMLMode('',0) to close all open block-level elements.
  84     *
  85     * @param $level string  Rrequested nesting level for current element.
  86     * The nesting level for top level block is one (which is
  87     * the default).
  88     * Nesting is arbitrary limited to 20 levels.
  89     *
  90     * @return string Returns the HTML markup to open the specified element.
  91     */
  92    function SetHTMLMode($tag, $level = 1)
  93    {
  94       if (is_array($tag)) {
  95          $args = $tag[1];
  96          $tag = $tag[0];
  97       }
  98       else {
  99          $args = array();
 100       }
 101
 102       $this->mode_set = 1;      // in order to prevent other mode markup
 103                                 // to be executed
 104       $retvar = '';
 105
 106       if ($level > 20) {
 107          // arbitrarily limit tag nesting
 108          ExitWiki(gettext ("Lists nested too deep in SetHTMLOutputMode"));
 109       }
 110
 111       if ($level <= $this->stack->cnt()) {
 112          // $tag has fewer nestings (old: tabs) than stack,
 113          // reduce stack to that tab count
 114          while ($this->stack->cnt() > $level) {
 115             $closetag = $this->stack->pop();
 116             assert('$closetag != false');
 117             $retvar .= "</$closetag>\n";
 118          }
 119
 120          // if list type isn't the same,
 121          // back up one more and push new tag
 122          if ($tag && $tag != $this->stack->top()) {
 123             $closetag = $this->stack->pop();
 124             $retvar .= "</$closetag>" . StartTag($tag, $args) . "\n";
 125             $this->stack->push($tag);
 126          }
 127
 128       }
 129       else {// $level > $this->stack->cnt()
 130          // Test for and close top level elements which are not allowed to contain
 131          // other block-level elements.
 132          if ($this->stack->cnt() == 1 and
 133              preg_match('/^(p|pre|h\d)$/i', $this->stack->top()))
 134          {
 135             $closetag = $this->stack->pop();
 136             $retvar .= "</$closetag>";
 137          }
 138
 139          // we add the diff to the stack
 140          // stack might be zero
 141          if ($this->stack->cnt() < $level) {
 142             while ($this->stack->cnt() < $level - 1) {
 143                // This is a bit of a hack:
 144                //
 145                // We're not nested deep enough, and have to make up some kind of block
 146                // element to nest within.
 147                //
 148                // Currently, this can only happen for nested list element
 149                // (either <ul> <ol> or <dl>).  What we used to do here is
 150                // to open extra lists of whatever type was requested.
 151                // This would result in invalid HTML, since and list is
 152                // not allowed to contain another list without first containing
 153                // a list item.  ("<ul><ul><li>Item</ul></ul>" is invalid.)
 154                //
 155                // So now, when we need extra list elements, we use a <dl>, and
 156                // open it with an empty <dd>.
 157                $el =  $this->stack->cnt() % 2 == 0 ? 'dl' : 'dd';
 158                $retvar .= "<$el>";
 159                $this->stack->push($el);
 160             }
 161
 162             $retvar .= StartTag($tag, $args) . "\n";
 163             $this->stack->push($tag);
 164          }
 165       }
 166
 167       return $this->token($retvar);
 168    }
 169
 170    /**
 171     * Start new list item element.
 172     *
 173     * This closes any currently open list items at the specified level or deeper,
 174     * then opens a new list item element.
 175     *
 176     * @param $list_type string  Type of list element to open.  This should
 177     * be one of 'dl', 'ol', or 'ul'.
 178     *
 179     * @param $level integer  Nesting depth for list item.  Should be a positive integer.
 180     *
 181     * @param $defn_term string  Definition term.  Specifies the contents for the
 182     * &lt;dt&gt; element.  Only used if $list_type is 'dl'.
 183     *
 184     * @return string HTML
 185     */
 186    function ListItem($list_type, $level, $defn_term = '')
 187    {
 188        $retval = $this->SetHTMLMode($list_type, 2 * $level - 1);
 189        if ($list_type == 'dl') {
 190            $retval .= Element('dt', $defn_term);
 191            $retval .= $this->SetHTMLMode('dd', 2 * $level);
 192        }
 193        else {
 194            $retval .= $this->SetHTMLMode('li', 2 * $level);
 195        }
 196        return $retval;
 197    }
 198
 199
 200    /** Work horse and main loop.
 201     *
 202     * This function does the transform from wiki markup to HTML.
 203     *
 204     * Contains main-loop and calls transformer functions.
 205     *
 206     * @param $html string  HTML header (if needed, otherwise '')
 207     * (This string is prepended to the return value.)
 208     *
 209     * @param $content array  Wiki markup as array of lines
 210     *
 211     * @return string HTML
 212     */
 213    function do_transform($html, $content)
 214    {
 215       global $FieldSeparator;
 216
 217       $this->content = $content;
 218       $this->replacements = array();
 219       $this->user_data = array();
 220
 221       // Loop over all lines of the page and apply transformation rules
 222       $numlines = count($this->content);
 223       for ($lnum = 0; $lnum < $numlines; $lnum++)
 224       {
 225
 226          $this->linenumber = $lnum;
 227          $line = $this->content[$lnum];
 228
 229          // blank lines clear the current mode (to force new paragraph)
 230          if (!strlen($line) || $line == "\r") {
 231             $html .= $this->SetHTMLMode('', 0);
 232             continue;
 233          }
 234
 235          $this->mode_set = 0;
 236
 237          // main loop applying all registered functions
 238          // tokenizers, markup, html mode, ...
 239          // functions are executed in order of registering
 240          for (reset($this->trfrm_func);
 241               list($flags, $func, $regexp) = current($this->trfrm_func);
 242               next($this->trfrm_func)) {
 243
 244             // if HTMLmode is already set then skip all following
 245             // WT_MODE_MARKUP functions
 246             if ($this->mode_set && ($flags & WT_MODE_MARKUP) != 0)
 247                continue;
 248
 249             if (!empty($regexp) && !preg_match("/$regexp/", $line))
 250                continue;
 251
 252             // call registered function
 253             if (($flags & WT_TOKENIZER) != 0)
 254                $line = $this->tokenize($line, $regexp, $func);
 255             else
 256                $line = $func($line, $this);
 257          }
 258
 259          $html .= $line . "\n";
 260       }
 261       // close all tags
 262       $html .= $this->SetHTMLMode('', 0);
 263
 264       return $this->untokenize($html);
 265    }
 266    // end do_transfrom()
 267
 268    // Register a new token.
 269    function token($repl) {
 270       global $FieldSeparator;
 271       $tok = $FieldSeparator . sizeof($this->replacements) . $FieldSeparator;
 272       $this->replacements[] = $repl;
 273       return $tok;
 274    }
 275
 276    // helper function which does actual tokenizing
 277    function tokenize($str, $pattern, $func) {
 278       // Find any strings in $str that match $pattern and
 279       // store them in $orig, replacing them with tokens
 280       // starting at number $ntokens - returns tokenized string
 281       $new = '';
 282       while (preg_match("/^(.*?)($pattern)/", $str, $matches)) {
 283          $str = substr($str, strlen($matches[0]));
 284          $new .= $matches[1] . $this->token($func($matches[2], $this));
 285       }
 286       return $new . $str;
 287    }
 288
 289    function untokenize($line) {
 290       global $FieldSeparator;
 291
 292       $chunks = explode ($FieldSeparator, "$line ");
 293       $line = $chunks[0];
 294       for ($i = 1; $i < count($chunks); $i += 2)
 295       {
 296          $tok = $chunks[$i];
 297          $line .= $this->replacements[$tok] . $chunks[$i + 1];
 298       }
 299       return $line;
 300    }
 301 }
 302 // end class WikiTransform
 303
 304
 305 //////////////////////////////////////////////////////////
 306
 307 function do_transform ($lines) {
 308    global $WikiNameRegexp, $AllowedProtocols, $InterWikiLinkRegexp;
 309
 310 if (is_string($lines))
 311     $lines = preg_split('/[ \t\r]*\n/', trim($lines));
 312
 313
 314 $transform = new WikiTransform;
 315
 316 // register functions
 317 // functions are applied in order of registering
 318
 319 $transform->register(WT_SIMPLE_MARKUP, 'wtm_plugin_link');
 320 $transform->register(WT_MODE_MARKUP, 'wtm_plugin');
 321
 322 $transform->register(WT_TOKENIZER, 'wtt_doublebrackets', '\[\[');
 323 $transform->register(WT_TOKENIZER, 'wtt_footnotes', '^\[\d+\]');
 324 $transform->register(WT_TOKENIZER, 'wtt_footnoterefs', '\[\d+\]');
 325 $transform->register(WT_TOKENIZER, 'wtt_bracketlinks', '\[.+?\]');
 326 $transform->register(WT_TOKENIZER, 'wtt_urls',
 327                      "!?\b($AllowedProtocols):[^\s<>\[\]\"'()]*[^\s<>\[\]\"'(),.?]");
 328
 329 if (function_exists('wtt_interwikilinks')) {
 330    $transform->register(WT_TOKENIZER, 'wtt_interwikilinks',
 331                         pcre_fix_posix_classes("!?(?<![[:alnum:]])") .
 332                         "$InterWikiLinkRegexp:[^\\s.,;?]+");
 333 }
 334 $transform->register(WT_TOKENIZER, 'wtt_bumpylinks', "!?$WikiNameRegexp");
 335
 336 if (function_exists('wtm_table')) {
 337    $transform->register(WT_MODE_MARKUP, 'wtm_table', '^\|');
 338 }
 339    $transform->register(WT_SIMPLE_MARKUP, 'wtm_htmlchars');
 340    $transform->register(WT_SIMPLE_MARKUP, 'wtm_linebreak');
 341    $transform->register(WT_SIMPLE_MARKUP, 'wtm_bold_italics');
 342
 343    $transform->register(WT_MODE_MARKUP, 'wtm_list_ul');
 344    $transform->register(WT_MODE_MARKUP, 'wtm_list_ol');
 345    $transform->register(WT_MODE_MARKUP, 'wtm_list_dl');
 346    $transform->register(WT_MODE_MARKUP, 'wtm_preformatted');
 347    $transform->register(WT_MODE_MARKUP, 'wtm_headings');
 348    $transform->register(WT_MODE_MARKUP, 'wtm_hr');
 349    $transform->register(WT_MODE_MARKUP, 'wtm_paragraph');
 350
 351 //$html = $transform->do_transform($html, $pagehash['content']);
 352    return $transform->do_transform('', $lines);
 353 }
 354
 355 /*
 356 Requirements for functions registered to WikiTransform:
 357
 358 Signature:  function wtm_xxxx($line, &$transform)
 359
 360 $line ... current line containing wiki markup
 361         (Note: it may already contain HTML from other transform functions)
 362 &$transform ... WikiTransform object -- public variables of this
 363         object and their use see above.
 364
 365 Functions have to return $line (doesn't matter if modified or not)
 366 All conversion should take place inside $line.
 367
 368 Tokenizer functions should use $transform->replacements to store
 369 the replacement strings. Also, they have to keep track of
 370 $transform->tokencounter. See functions below. Back substitution
 371 of tokenized strings is done by do_transform().
 372 */
 373
 374
 375
 376    //////////////////////////////////////////////////////////
 377    // Tokenizer functions
 378
 379
 380 function  wtt_doublebrackets($match, &$trfrm)
 381 {
 382    return '[';
 383 }
 384
 385 function wtt_footnotes($match, &$trfrm)
 386 {
 387    // FIXME: should this set HTML mode?
 388    $ftnt = trim(substr($match,1,-1)) + 0;
 389    $fntext = "[$ftnt]";
 390    $html = Element('br');
 391
 392    $fnlist = $trfrm->user_data['footnotes'][$ftnt];
 393    if (!is_array($fnlist))
 394       return $html . $fntext;
 395
 396    $trfrm->user_data['footnotes'][$ftnt] = 'footnote_seen';
 397
 398    while (list($k, $anchor) = each($fnlist))
 399    {
 400       $html .=  Element("a", array("name" => "footnote-$ftnt",
 401                                    "href" => "#$anchor",
 402                                    "class" => "footnote-rev"),
 403                         $fntext);
 404       $fntext = '+';
 405    }
 406    return $html;
 407 }
 408
 409 function wtt_footnoterefs($match, &$trfrm)
 410 {
 411    $ftnt = trim(substr($match,1,-1)) + 0;
 412
 413    $footnote_definition_seen = false;
 414
 415    if (empty($trfrm->user_data['footnotes']))
 416       $trfrm->user_data['footnotes'] = array();
 417    if (empty($trfrm->user_data['footnotes'][$ftnt]))
 418       $trfrm->user_data['footnotes'][$ftnt] = array();
 419    else if (!is_array($trfrm->user_data['footnotes'][$ftnt]))
 420       $footnote_definition_seen = true;
 421
 422
 423    $args['href'] = "#footnote-$ftnt";
 424    if (!$footnote_definition_seen)
 425    {
 426       $args['name'] = "footrev-$ftnt-" .
 427           count($trfrm->user_data['footnotes'][$ftnt]);
 428       $trfrm->user_data['footnotes'][$ftnt][] = $args['name'];
 429    }
 430
 431    return Element('sup', array('class' => 'footnote'),
 432                   QElement("a", $args, "[$ftnt]"));
 433 }
 434
 435 function wtt_bracketlinks($match, &$trfrm)
 436 {
 437    $link = ParseAndLink($match);
 438    if (strstr($link['link'], "</form>")) {
 439        // FIXME: BIG HACK: see note in wtm_plugin.
 440        return "</p>" . $link['link'] . "<p>";
 441    }
 442    return $link["link"];
 443 }
 444
 445
 446
 447 // replace all URL's with tokens, so we don't confuse them
 448 // with Wiki words later. Wiki words in URL's break things.
 449 // URLs preceeded by a '!' are not linked
 450 function wtt_urls($match, &$trfrm)
 451 {
 452    if ($match[0] == "!")
 453       return htmlspecialchars(substr($match,1));
 454    return LinkURL($match);
 455 }
 456
 457 // Link Wiki words (BumpyText)
 458 // Wikiwords preceeded by a '!' are not linked
 459 function wtt_bumpylinks($match, &$trfrm)
 460 {
 461    global $dbi;
 462    if ($match[0] == "!")
 463       return htmlspecialchars(substr($match,1));
 464    return LinkWikiWord($match);
 465 }
 466
 467 // end of tokenizer functions
 468 //////////////////////////////////////////////////////////
 469
 470
 471    //////////////////////////////////////////////////////////
 472    // basic simple markup functions
 473
 474    // escape HTML metachars
 475    function wtm_htmlchars($line, &$transformer)
 476    {
 477       $line = str_replace('&', '&amp;', $line);
 478       $line = str_replace('>', '&gt;', $line);
 479       $line = str_replace('<', '&lt;', $line);
 480       return($line);
 481    }
 482
 483
 484    // %%% are linebreaks
 485    function wtm_linebreak($line, &$transformer) {
 486       return str_replace('%%%', Element('br'), $line);
 487    }
 488
 489    // bold and italics
 490    function wtm_bold_italics($line, &$transformer) {
 491       $line = preg_replace('|(__)(.*?)(__)|', '<strong>\2</strong>', $line);
 492       $line = preg_replace("|('')(.*?)('')|", '<em>\2</em>', $line);
 493       return $line;
 494    }
 495
 496
 497
 498    //////////////////////////////////////////////////////////
 499    // some tokens to be replaced by (dynamic) content
 500
 501 // FIXME: some plugins are in-line (maybe?) and some are block level.
 502 // Here we treat them all as inline, which will probably
 503 // generate some minorly invalid HTML in some cases.
 504 //
 505 function wtm_plugin_link($line, &$transformer) {
 506     // FIXME: is this good syntax?
 507     global $dbi, $request;      // FIXME: make these non-global?
 508
 509     if (preg_match('/^(.*?)(<\?plugin-link\s+.*?\?>)(.*)$/', $line, $m)) {
 510         list(, $prematch, $plugin_pi, $postmatch) = $m;
 511         $loader = new WikiPluginLoader;
 512         $html = $loader->expandPI($plugin_pi, $dbi, $request);
 513         $line = $prematch . $transformer->token($html) . $postmatch;
 514     }
 515     return $line;
 516 }
 517
 518 function wtm_plugin($line, &$transformer) {
 519     // FIXME: is this good syntax?
 520     global $dbi, $request;      // FIXME: make these non-global?
 521
 522     if (preg_match('/^<\?plugin(-form)?\s.*\?>\s*$/', $line)) {
 523         $loader = new WikiPluginLoader;
 524         $html = $loader->expandPI($line, $dbi, $request);
 525         $line = $transformer->SetHTMLMode('', 0) . $transformer->token($html);
 526     }
 527     return $line;
 528 }
 529
 530
 531    //////////////////////////////////////////////////////////
 532    // mode markup functions
 533
 534
 535    // tabless markup for unordered, ordered, and dictionary lists
 536    // ul/ol list types can be mixed, so we only look at the last
 537    // character. Changes e.g. from "**#*" to "###*" go unnoticed.
 538    // and wouldn't make a difference to the HTML layout anyway.
 539
 540    // unordered lists <UL>: "*"
 541    // has to be registereed before list OL
 542    function wtm_list_ul($line, &$trfrm) {
 543       if (preg_match("/^([#*;]*\*)[^#]/", $line, $matches)) {
 544          $numtabs = strlen($matches[1]);
 545          $line = preg_replace("/^([#*]*\*)/", '', $line);
 546          $line = $trfrm->ListItem('ul', $numtabs) . $line;
 547       }
 548       return $line;
 549    }
 550
 551    // ordered lists <OL>: "#"
 552    function wtm_list_ol($line, &$trfrm) {
 553       if (preg_match("/^([#*;]*\#)/", $line, $matches)) {
 554          $numtabs = strlen($matches[1]);
 555          $line = preg_replace("/^([#*]*\#)/", "", $line);
 556          $line = $trfrm->ListItem('ol', $numtabs) . $line;
 557       }
 558       return $line;
 559    }
 560
 561
 562    // definition lists <DL>: ";text:text"
 563    function wtm_list_dl($line, &$trfrm) {
 564       if (preg_match("/^([#*;]*;)(.*?):(.*$)/", $line, $matches)) {
 565          $numtabs = strlen($matches[1]);
 566          $line = $trfrm->ListItem('dl', $numtabs, $matches[2]) . $matches[3];
 567       }
 568       return $line;
 569    }
 570
 571    // mode: preformatted text, i.e. <pre>
 572    function wtm_preformatted($line, &$trfrm) {
 573       if (preg_match("/^\s+/", $line)) {
 574          $line = $trfrm->SetHTMLMode('pre') . $line;
 575       }
 576       return $line;
 577    }
 578
 579    // mode: headings, i.e. <h1>, <h2>, <h3>
 580    // lines starting with !,!!,!!! are headings
 581    // Patch from steph/tara <tellme@climbtothestars.org>:
 582    //    use <h2>, <h3>, <h4> since <h1> is page title.
 583    function wtm_headings($line, &$trfrm) {
 584       if (preg_match("/^(!{1,3})[^!]/", $line, $whichheading)) {
 585          if($whichheading[1] == '!') $heading = 'h4';
 586          elseif($whichheading[1] == '!!') $heading = 'h3';
 587          elseif($whichheading[1] == '!!!') $heading = 'h2';
 588          $line = preg_replace("/^!+/", '', $line);
 589          $line = $trfrm->SetHTMLMode($heading) . $line;
 590       }
 591       return $line;
 592    }
 593
 594 // markup for tables
 595 function wtm_table($line, &$trfrm)
 596 {
 597    $row = '';
 598    while (preg_match('/^(\|+)(v*)([<>^]?)([^|]*)/', $line, $m))
 599    {
 600       $line = substr($line, strlen($m[0]));
 601       $td = array();
 602
 603       if (strlen($m[1]) > 1)
 604          $td['colspan'] = strlen($m[1]);
 605       if (strlen($m[2]) > 0)
 606          $td['rowspan'] = strlen($m[2]) + 1;
 607
 608       if ($m[3] == '^')
 609          $td['align'] = 'center';
 610       else if ($m[3] == '>')
 611          $td['align'] = 'right';
 612       else
 613          $td['align'] = 'left';
 614
 615       $row .= $trfrm->token(StartTag('td', $td) . "&nbsp;");
 616       $row .= trim($m[4]);
 617       $row .= $trfrm->token("&nbsp;</td>");
 618    }
 619    assert(empty($line));
 620    $row = $trfrm->token("<tr>") . $row . $trfrm->token("</tr>");
 621
 622    return $trfrm->SetHTMLMode(array('table',
 623                                     array(//'align' => 'left',
 624                                           'cellpadding' => 1,
 625                                           'cellspacing' => 1,
 626                                           'border' => 1))) .
 627       $row;
 628 }
 629
 630    // four or more dashes to <hr>
 631    // Note this is of type WT_MODE_MARKUP becuase <hr>'s aren't
 632    // allowed within <p>'s. (e.g. "<p><hr></p>" is not valid HTML.)
 633    function wtm_hr($line, &$trfrm) {
 634       if (preg_match('/^-{4,}(.*)$/', $line, $m)) {
 635          $line = $trfrm->SetHTMLMode('', 0) . Element('hr');
 636          if ($m[1])
 637             $line .= $trfrm->SetHTMLMode('p') . $m[1];
 638       }
 639       return $line;
 640    }
 641
 642    // default mode: simple text paragraph
 643    function wtm_paragraph($line, &$trfrm) {
 644       $line = $trfrm->SetHTMLMode('p') . $line;
 645       return $line;
 646    }
 647
 648 // (c-file-style: "gnu")
 649 // Local Variables:
 650 // mode: php
 651 // tab-width: 8
 652 // c-basic-offset: 4
 653 // c-hanging-comment-ender-p: nil
 654 // indent-tabs-mode: nil
 655 // End:
 656 ?>