<?php /* gakowiki

gakowiki is a wiki engine. It powers [[http://www.monperrus.net/martin/]]. What is really special in gakowiki is that source code documentation is considered as wiki content.

===== Documentation generator features  =====
 
gakowiki outputs HTML pages from source code **on the fly** (contrary to Javadoc or Doxygen ).
For instance, this page is directly generated from [[http://www.monperrus.net/martin/gakowiki.php.txt|gakowiki.php]].

gakowiki supports several kinds of source code (PHP, C, latex, etc.). For instance, [[page-de-garde-these-latex|this page]] is directly generated from the source code documentation of a latex style file.


===== Other features =====

* it reads and writes flat text files
* it is implemented in one single PHP file (such as [[http://www.pawfal.org/index.php?page=PawfalIki|PawfalIki]])
* it uses the [[gakowiki formatting syntax|wiki syntax]] of [[http://www.dokuwiki.org/|Dokuwiki]]
* it uses open [[fixed join point]]s for logging and authentification (such as [[simplephpauth]])
* it allows PHP code in wiki pages.
* it follows a liberal philosophy: **any kind of HTML, Javascript and even PHP code is allowed.**

===== Installation =====

[[gakowiki.php.txt|Download gakowiki here]].

In order to write and edit pages, the directory containing ''gakowiki.php'' must be writable by the server:
''$ chmod 775 .''

[[http://www.monperrus.net/martin/|Martin Monperrus]]

*/

error_reporting(E_ALL);
@ini_set('zlib.output_compression', 1);

// extension points


// a list of functions capable of listing logical names $logical => array of metadata
global $listing_functions;
$listing_functions = array();
/** enables to tailor gakowiki by adding a new function to list resources */
function register_listing_function($f) {
  global $listing_functions;
  $listing_functions[] = $f;
}

// functions capable of getting the function to get the content a given page
// those functions takes one string as parameter, the file name
// the default one is get_content_from_file
global $content_functions;
$content_functions = array();
/** enables to tailor gakowiki by adding a new function to list resources */
function register_content_function($f) {
  global $content_functions;
  $content_functions[] = $f;
}


// a list of functions capable of recognising a logical name and transforming it into a relative or absolute URL
global $url_building_functions;
$url_building_functions = array();
/** enables to tailor gakowiki by adding a new function to build urls. The function $f is expected to take one String argument (an resource indentifier) and to return a valid URL if the resource is known. Otherwise, $f must return null or the empty string 
*/
function register_url_building_function($f) {
  global $url_building_functions;
  $url_building_functions[] = $f;
}


// a list of functions capable of returning metadata
global $metadata_functions;
$metadata_functions = array();
/** enables to tailor gakowiki by adding a new function to retrieve metadata */
function register_metadata_function($f) {
  global $metadata_functions;
  $metadata_functions[] = $f;
}


/** returns all registered formats */
global $registered_formats;
$registered_formats = array();
function register_format($f) {
  global $registered_formats;
  $registered_formats[]=$f;
}
function get_registered_formats() {
  global $registered_formats;
  return $registered_formats;
}

/** returns all registered extensions */
function get_registered_extensions() {
  $result = array();
  $x = get_defined_functions();
  foreach($x['user'] as $f) {
    if(preg_match('/^(.*)_display$/', $f,$matches)) {
      $result[] = '.'.$matches[1];
    }
  }
  return $result;
}


// must appear after the definition of register_url_building_function
@include('gakowiki.local.php');


/** returns the current theme name */
function get_theme() {
  if (isset($_REQUEST['theme'])) return $_REQUEST['theme'];
  return THEME;
}

?><?php /* pp4php: including ./gakowiki-syntax.php (in gakowiki.php:121) */ ?><?php /** Gakowi syntax

The syntax of [[gakowiki]] is a wiki syntax inspired from the syntax of dokuwiki.
Here is a demonstration:

=====Demo=====
<?php global $cc;$cc=file_get_contents( 'gakowiki-syntax-example.txt' ); ?>

<table border="1">
  <tr>
<th>Before</th><th>After</th>
</tr>
  <tr>
<td>
<?php global $cc;echo '<pre>'.htmlentities($cc).'</pre>'; ?>
</td>

<td>
<?php global $cc;echo gk_wiki2html($cc); ?>
</td>
</tr>
</table>


=====Usage=====
You may download [[gakowiki-syntax.php.txt]] and use it as follows:
<pre>
require_once( 'gakowiki-syntax.php' );
global $parser;
$parser = create_wiki_parser();
echo $parser->parse('hhjjh **kkk** ');
// or 
echo gk_wiki2html('hhjjh **kkk** ');

</pre>
*/

/** returns an HTML version of the wiki text of $text, according to the syntax of [[http://www.monperrus.net/martin/gakowiki-syntax]] */
function gk_wiki2html($text) {
  global $parser;
  if ($parser==null) $parser = create_wiki_parser();
  return  $parser->parse($text);
}


?><?php /* pp4php: including ./gakoparser.php (in ./gakowiki-syntax.php:46) */ ?><?php /* Gakoparser

Gakoparser parses a family of markup language

Sunday, October 30 2011
impossible to handle both ===== sdf ===== and ==== sdfsdf ====
handling of space different

handling of >\n different

 */

if (defined('gakoparser.php')) return;
define('gakoparser.php',true);

class Delimiter{}

class GakoParserException extends Exception {}

class GakoParser {
  function __construct() {
    // an array of Delimiter objects
    $this->start_delimiters = array();
    $this->end_delimiters = array();
    $this->nonesting = array();
    $this->delegate = array();
  }
  
  function noNesting($tag) {
    $this->nonesting[] = $tag;
    return $this;
  }

  function setDelegate($obj) {
    $this->delegate = $obj;
    return $this;
  }

  function addDelim($name, $delim) {
    return $this->addDelimX($name, $delim, $delim);
  }

  /** setDelegate must be called before this method */
  function addDelimX($name, $start, $end) {
    if (!method_exists($this->delegate,$name)) {throw new GakoParserException('no method '.$method.' in delegate!');}

    $x = new Delimiter();
    $x->value = $start;
//     $x->type = 'start';
    $x->action = $name;
    
    $y = new Delimiter();
    $y->value = $end;
//     $y->type = 'end';
    $y->action = $name;
    
    // crossing links
    $y->startDelim = $x;
    $x->endDelim = $y;
    
    if (in_array($start, $this->get_start_delimiters())) {
      throw new GakoParserException("delimiter ".$start." already exists");
    }
    
    $this->start_delimiters[$start] = $x;
    $this->end_delimiters[$end] = $y;
    return $this;
  }

  function get_start_delimiters() {
    return array_keys($this->start_delimiters);
  }
  
  function get_end_delimiters() {
    return array_keys($this->end_delimiters);
  }
  
  function array_preg_quote($x) {
    $result = array();
    foreach($x as $k) { $result[] = preg_quote($k, '/'); }
    return $result;
  }
  
  function addDelimXML($name, $delim) {
    return $this->addDelimX($name, '<'.$delim.'>', '</'.$delim.'>');
  }

  function getCandidateDelimiters_man($str) {
    $result = array();
    
    for ( $i=0; $i < strlen( $str ); $i++) { 
      foreach(array_merge($this->get_start_delimiters(),$this->get_end_delimiters()) as $v) {
        $new_fragment = substr($str, $i, strlen($v));
        if ($new_fragment === $v) {
          $x = array();
          $x[0] = array();
          $x[0][0] = $v;
          $x[0][1] = $i;
          $result[] = $x;
        }
      }
    }
    //print_r($result);
    return $result;
  }

  function getCandidateDelimiters($str) {
    //return $this->getCandidateDelimiters_man($str);
    return $this->getCandidateDelimiters_preg($str);
  }

  function getCandidateDelimiters_preg($str) {
    // getting the start delimiters
    preg_match_all('/'.implode('|',array_merge($this->array_preg_quote($this->get_start_delimiters()),$this->array_preg_quote($this->get_end_delimiters()))).'/', $str, $matches, PREG_SET_ORDER | PREG_OFFSET_CAPTURE );
    return $matches;
  }
  
  function parse($str) {
//     echo "---------parse $str\n";
    $method = '__pre';
    if (method_exists($this->delegate,$method)) {
      $str = $this->delegate->$method($str);
    }
    
    $matches = $this->getCandidateDelimiters($str); 

//     print_r($matches);
    
    //echo 'parse '.$str.'<br>';
    // the stack contains the current markup environment
    $init = new Delimiter(); $init->action = '__init__'; $init->value = '__init__'; $init->endDelim = $init;
    $stack = array($init);
    $strings = array(1=>'');
    $last = 0;
    
//     if (count($matches) == 0) return $str;
    
//     print_r($matches);
    
//     $strings[1] = substr($str, 0, $matches[0][0][1]);
    
    foreach ( $matches as $_ ) { 
    
        list($v, $pos) = $_[0];
        
//         echo "studying ".$v." at ".$pos."  (last=".$last.")\n";

        // if $_ is a start delimiter,
        // we'll get '' in $k
        //echo $stack[0];
        if (isset($this->end_delimiters[$v]) 
//              && $stack[0] != '__init__'
             && $stack[0]->endDelim->value == $v  
             && $pos>=$last
            ) {
          $k = $stack[0]->endDelim->action;
        
          $strings[count($stack)] .= substr($str,$last, $pos-$last);

//           echo "popping ".$k." at ".$pos." with ".$v." (last=".$last.", stack=".count($stack).")\n";

          $closedtag = array_shift($stack);

          $method = $k;
//                  echo $method." ".$value. "\n";
          $value = $strings[count($stack)+1];
          $transformed = $this->delegate->$method($value);
//             echo $transformed ."---".$value." \n";              
          $strings[count($stack)] .= $transformed;
            
          $strings[count($stack)+1] = '';            
          $last = $pos+strlen($v);

        }
      
      // certain tags does not support nesting
      else if (!in_array($stack[0]->action, $this->nonesting)
                && in_array($v, $this->get_start_delimiters()) && $pos >= $last) 
      {      
        $delim = $this->start_delimiters[$v];
        $k = $delim->action;
        
//         echo "putting ".$k." at ".$pos." with ".$last."<br/>\n";
            
        if ($pos>$last) {
          $strings[count($stack)] .= substr($str, $last, $pos-$last);
        } 
        array_unshift($stack, $delim);
        // init the new stack
        $strings[count($stack)] = ''; 
        $last = $pos+strlen($v);
//             print_r($strings);
                       
      } else {
        //die('oops');
      }
      
    } // end foreach
    
    
    if ($stack[0]->action!="__init__") { throw new GakoParserException("parsing error: ending with ".$stack[0]->action); }
    
    $result = $strings[count($stack)];
    
    // adding the rest
    if ($last<strlen($str)) $result .= substr($str,$last,strlen($str)-$last);
    
    $method = '__post';
    if (method_exists($this->delegate,$method)) {
      $result = $this->delegate->$method($result);
    } 
    //echo "$$$$$ ".$result."\n";
    
    return $result;
    
  }
}


?><?php 

/** Delegate class for Gakoparser */
class GakoWikiDelegate {

  var $toc = array();

  function __pre($str) {
    $result = $str;

    // we often use nelines to have pretty HTML code
    // such as in tables
    // however, they are no "real" newlines to be transformed in <br/>
    $result = preg_replace("/>\s*(\n|\r\n)/",'>__newline__',$result);
    return $result;
  }

  function escape_newline($str) {
    return preg_replace("/(\n|\r\n)/","__newline__",$str);
  }

  function __post($str) {
    $result = $str;
    $result = preg_replace("/(\n|\r\n)/","<br/>\n",$result);

    // workaround to support the semantics change in pre mode
    // and the semantics of embedded HTML
    $result = preg_replace("/__newline__/","\n",$result);// must be at the end

    // cleaning the additional <br>
    // this is really nice
    $result = preg_replace("/(<\/h.>)<br\/>/i","\\1 ",$result);

    // adding the table of contents
    $result = str_replace('+++TOC+++',implode('<br/>',$this->toc),$result);

    return $result;
  }

  function pre($str) {
    return '<pre>'.$this->escape_newline($str).'</pre>';
  }

 function pre2($str) {
    return $this->pre($str);
  }

  function unwrap($str) {
    return $this->escape_newline($str);
  }

  function bold($str) {
    return '<b>'.$str.'</b>';
  }
  
  function italic($str) {
    return '<i>'.$str.'</i>';
  }

  function table($str) {
    $result = '';
    foreach(preg_split('/\n/',$str) as $line) {
      if (strlen(trim($line))>0) {
      $result .= '<tr>';
      foreach(preg_split('/&&/',$line) as $field) {
        $result .= '<td>'.$field.'</td>';

      }
      $result .= '</tr>';
      }
   }

    return '<table border="1">'.$result.'</table>';
  }


  function __create_anchor($m) {
    return preg_replace("/[^a-zA-Z]/","",$m);
  }
  function h2($str) {
    $tag = $this->__create_anchor($str);   
    $this->toc[] = "<a href=\"#".$tag."\">".$str."</a>";
    return '<a name="'.$tag.'"></a>'.'<h2>'.$str."</h2>";
  }

  function h3($str) {
    $tag = $this->__create_anchor($str);
    $this->toc[] = "&nbsp;&nbsp;<a href=\"#".$tag."\">".$str."</a>";
    return '<a name="'.$tag.'"></a>'.'<h3>'.$str."</h3>";
  }

  function monotype($str) {
    return '<code>'.str_replace('<','&lt;',$str).'</code>';
  }

  function link($str) {
    
    if (preg_match('/(.*)\|(.*)/',$str, $matches)) {
      $rawurl =  $matches[1];
      $text =  $matches[2];
    } else {$rawurl=$str;$text=$str;}

    $url=$rawurl;

    if (!preg_match("/(#|^http)/",$rawurl)) {      
      $url=logical2url($rawurl);
    } 

    return '<a href="'.trim($url).'">'.trim($text).'</a>';
  }

  function phpcode($str) {
      ob_start();
      eval($str);
      return $this->escape_newline(ob_get_clean());
   }

  function phpcode2($str) {
      return wiki2html($this->phpcode($str));
   }

  function a($str) {
      return '<a'.$str.'</a>';
   }

  function script($str) {
      return '<script src="'.$str.'"></script>';
   }

  function html($str) {
      return '<'.$str.'>';
   }

  function comment($str) {
      return ''; // comments are discarded
   }

}

/** returns a parser object to parse wiki syntax.

The returned object may be used with the parse method:
<pre>
$parser = create_wiki_parser();
$html_text = $parser->parse($wiki_text);
</pre>
*/
function create_wiki_parser() {
  $x = new Gakoparser();
  return $x->setDelegate(new GakoWikiDelegate())
      ->addDelimX('comment','<!--','-->')->noNesting('comment')

     ->addDelim('bold','**')
     ->addDelim('italic','//')//->noNesting('italic')
     ->addDelim('monotype',"''")->noNesting('monotype')
     ->addDelim('h2',"=====") // the longest comes before, it has the highest priority
     ->addDelim('h3',"====")
     ->addDelim('table',"|||")
     ->addDelimXML('pre','pre')->noNesting('pre') // this is essential otherwise you have infinite loops      
     ->addDelimX('pre2','{{{','}}}')->noNesting('pre2') // à la Google Code wiki syntax      
     ->addDelimX('link','[[',']]')->noNesting('link')
     ->addDelimX('phpcode2','<?php2wiki','?>')->noNesting('phpcode2')
     ->addDelimX('phpcode','<?php','?>') ->noNesting('phpcode')
     ->addDelimX('unwrap','^^','^^')

      ->addDelimX('a','<a','</a>')->noNesting('a') // important to support cross tags
      ->addDelim('script','$$$')->noNesting('script')

      // this one is really not good
      //->addDelimX('html','<','>')->noNesting('html') // a links often contains // (e.g. http:// which clash with italics
      ;
} // end create_wiki_parser


?><?php 

if (function_exists('create_wiki_parser')) {
/** returns an HTML version of $str according to the syntax of [[http://www.monperrus.net/martin/gakowiki-syntax]] */
function wiki2html ($str) {


  $x = create_wiki_parser();
  return $x->parse($str);  
} }
else {
/** returns $str unmodified (default version) */
function wiki2html ($str) {
  return $str;
}
}


/** sanitizes data for textarea */
function textareaze($data) {

  // firefox replaces entities in textarea
  $data = preg_replace("/&/",'&#38;',  $data);
  // but firefox bugs with entitites after some html comment tags...
  $data = preg_replace("/<!--/",'&#60;!--',  $data);
  // we are able to edit PHP/HTML source that contains textarea tags
  $data = preg_replace('/<\s*(\/TEXTAREA)/','&#60;\1',  $data);
  return $data;

} // end function textareaze


/** is a bit smarter than PHP's urlencode since it encoded ascci > 128 w.r.t to RFC "internationalized URI hence URLs are correctly indexed and presented by Google*/
function myurlencode($str) {
  return urlencode($str);
}


/** handle saving of new data */
function handle_save() {
  @include('simplephpauth.php');

  // VERY IMPORTANT
  // platform configuration :-(
  if (get_magic_quotes_gpc()) $_POST['pagecontent']= stripslashes($_POST['pagecontent']);


  // handling the title
  if (get_magic_quotes_gpc()) $_REQUEST['title']= stripslashes($_REQUEST['title']);
  if (isset($_REQUEST['title']) && $_REQUEST['title']!= '' && $_REQUEST['title']!= LOGICALNAME) {
    saveMetaData('title', $_REQUEST['title']);
    //echo 'saving title'.$_REQUEST['title'];
  }


  if (isset($_REQUEST['visible']) && $_REQUEST['visible']!=getVisibleMetadata()) {
    saveMetaData('visible', $_REQUEST['visible']);
  }

  if (isset($_REQUEST['format']) && $_REQUEST['format']!=getFormatMetadata()) {
    saveMetaData('format', $_REQUEST['format']);
  }

  // creation of a new file, default metadata
  // should come after the metadatasetting above
  if (!is_file(PHYSICALNAME)) {
    saveMetaData('ctime', time());

    // what should be the default format?
    saveMetaData('format', 'gakowiki');
  }

  $file  = fopen (PHYSICALNAME, "w");
  fwrite($file,$_POST['pagecontent']);
  fclose ($file);

  $logical = LOGICALNAME;

  // renaming files
  if (get_magic_quotes_gpc()) $_REQUEST['newslug']= stripslashes($_REQUEST['newslug']);
  if (isset($_REQUEST['newslug']) && $_REQUEST['newslug']!= '' && $_REQUEST['newslug']!= LOGICALNAME) {
    rename(PHYSICALNAME,logical2physical($_REQUEST['newslug']));
    rename(metadataFileOf(LOGICALNAME),metadataFileOf($_REQUEST['newslug']));
    file_put_contents(LOGICALNAME.'.redirect', logical2url($_REQUEST['newslug']));
    $logical = $_REQUEST['newslug'];
  }

  header('Location: '.logical2url($logical));
  exit;
}

/** loads metadata from the file $resource metadata (encoded in JSON) */
function loadTags($contents) {
  // old version
  // $tags_data = json_decode(@file_get_contents(TAGS), true);
  // if (!is_array($tags_data)) { $tags_data = array(); };
  // return $tags_data;

  // new version
  $tags_data = array();
  foreach ($contents as $pagename => $metadata) {
    if (!isset($metadata['tags'])) { continue; }
    
    // we may replace the logical if it is present
    if (isset($metadata['logical'])) $pagename = $metadata['logical'];
    foreach($metadata['tags'] as $tag) {
      @$tags_data[$tag][] = $pagename;
    } 
  }
  return $tags_data;
} // end function 

/** adds the $tag (string) to the resource identifed by $logical */
function addTag($logical, $tag) {
  $fmetadata = metadataFileOf($logical);
  $metadata = getAllMetaData($logical);

  $resourcetags = $metadata['tags'];
  if (!is_array($resourcetags)) {
    $resourcetags=array();
  }

  if (!in_array($tag, $resourcetags)) {
    $resourcetags[] = $tag;
  }

  $metadata['tags'] = $resourcetags;
  
  file_put_contents($fmetadata, json_encode($metadata));
}

/** removes the $value from the $array (from php.net)*/
function array_remove(array $array, $value, $strict=false)
{
    return array_diff_key($array, array_flip(array_keys($array, $value, $strict)));
}

/** removes the $tag (string) from the resource identifed by $logical */
function removeTag($logical, $tag) {
  $fmetadata = metadataFileOf($logical);
  $metadata = getAllMetaData($logical);
  $resourcetags = $metadata['tags'];
  if (!is_array($resourcetags)) {
    $resourcetags=array();
  }
  $result = array();
  foreach($resourcetags as $v) {
    if ($tag!=$v) $result[] = $v;
  }
  //array_remove($resourcetags, $tag, true);
  $metadata['tags'] = $result;  
  file_put_contents($fmetadata, json_encode($metadata));
}


/** handles tagging of pages  */
function handle_tag() {
  @include('simplephpauth.php');

  $newtag = $_GET['tag'];
  touch($newtag.'.tag');
 
  // new tag file
  addTag(LOGICALNAME, $newtag);

  header('Location: '.logical2url($newtag));
  exit;
}

/** handles untagging of pages  */
function handle_untag() {
  @include('simplephpauth.php');

  $newtag = $_GET['untag'];

  removeTag(LOGICALNAME, $newtag);

  header('Location: '.logical2url($newtag));
  exit;
}


/** returns a list of metadata arrays for a given tag */
function getPagesForTag($tag) {

  // $contents is an array
  $contents = listWikiContent();
  $tags_data = loadTags($contents);
  $result = array();
  if (isset($tags_data[$tag])) { 
    foreach($tags_data[$tag] as $k) {
      $result[$k] = $contents[$k];
    }  
  }
  return  $result ;
}

/** returns an an array of tags for a given page */
function getTagsForPage($logical  = LOGICALNAME ) {
  $metadata = getAllMetaData($logical);
  if (isset($metadata['tags'])) return $metadata['tags'];
  return array();
}

/** returns a given metadata, if $key is not set return an empty string */
function getMetadata($key, $logical  = LOGICALNAME ) {
  $metadata = getAllMetaData($logical);
  if (isset($metadata[$key])) return $metadata[$key];
  return '';
}

/** returns the title metadata */
function getTitleMetadata($logical  = LOGICALNAME ) {
  $title = getMetadata('title', $logical);
  if ($title == '') $title = $logical;
  return $title;
}

/** returns the visible metadata */
function getVisibleMetadata($logical  = LOGICALNAME ) {
  $visible = getMetadata('visible', $logical);//if visible is not set return an empty string
  // by default everything is visible
  if ($visible == '') $visible = 'no';
  return $visible;
}

/** returns the format metadata */
function getFormatMetadata($logical  = LOGICALNAME ) {
  $result = getMetadata('format', $logical);//if format is not set return an empty string
  if ($result == '') $result = 'unset';
  return $result;
}


/** returns a list of pages for a given tag, typycally used in a theme template */
function getTags($logical  = LOGICALNAME) {  
  $tags = getTagsForPage($logical);
  $result = '<ul class="tags">';
  $n =0;
  foreach($tags as $tag) {
      $n++;
      // tag is already utf8 encodedfv
      $result .= '<li><a href="'.urlencode($tag).'">'.($tag)."</a></li>\n";
  }
  $result.='</ul>';
  if ($n == 0) $result='<!-- no tag -->';
  else  $result='('.'tagged as '.$result.')';
  //if ($n == 1) $result='tagged as ';
  return '<div class="tags">'.$result.'</div>';
}


/** returns a list of pages for a given tag in wiki syntax.
 
  Note that one can add &lt;?php2wiki echo lstag_wiki('linux'); ?> in a wiki page.
 */
function lstag_wiki($tag) {
  $result = '';
  //$result .= '===='.$tag."====\n";
  foreach(getPagesForTag($tag) as $v => $metadata) {
    $result .= '* [['.($metadata['logical'])."|".$metadata['title']."]] \n";
  }
  return $result;
}


/** handles edition of data */
function handle_edit()  {
@include('simplephpauth.php');
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
</head>
  <body>
<a href="http://www.monperrus.net/martin/gakowiki-syntax">Syntax specification</a>:<br/>
**<b>this is bold</b>**<br/>
//<i>this is italic</i>//<br/>
''<code>this is code</code>''<br/>
[[link to a page on this wiki]],[[http://www.google.fr|link to google]]<br/>
<h2>=====Section=====</h2>
<h3>====Subsection====</h3>

<form method="post" name='edit' action="?save&amp;page=<? echo myurlencode(LOGICALNAME); ?>">
<?php
$menu='<input type="submit" value="[save '.LOGICALNAME.']"/> <a href="'.$_SERVER['SCRIPT_NAME'].'?edit&amp;page='.myurlencode(LOGICALNAME).'">[cancel modifications]</a> <a href="'.logical2url(LOGICALNAME).'">[back to page]</a><br/>';
echo $menu;
?>

Title: <input name="title" value="<?php echo htmlspecialchars (getTitleMetadata());?>" size="83"/><br/>
Published: <select name="visible">
<option value="yes">visible</option>
<option value="no" <?=(getVisibleMetadata()=='no')?'selected':''?>>hidden</option>
</select><br/>
Format: <select name="format">
<option value="unset">unset</option>
<?php
foreach(get_registered_formats() as $f) {
echo '<option value="'.$f.'" '
.(getFormatMetadata(LOGICALNAME)==$f?'selected':'')
.'>'.$f.'</option>';
}
?>
</select><br/>

<textarea rows="40" cols="80" name="pagecontent" style="width:100%">
<?php $data =getRawContent(LOGICALNAME); echo textareaze($data);  ?>
</textarea><br/>
  <!-- This button lets you to save your work with the keyboard with [Tab] [Return]-->
<?php echo $menu; ?>
Slug: <input name="newslug" value="<? echo LOGICALNAME;?>" size="83"/><br/>
</form>
</body>
</html>
<?
exit;
}


/** returns the corresponding metadata file */
function metadataFileOf($k) {
  return METADATADIR.$k.'.metadata';
}


/** saves a metadata pair */
function saveMetaData($name, $value, $logical = LOGICALNAME ) {
  $newMetadataFile = metadataFileOf($logical);
  $oldMetadataFile = metadataFileOf(logical2physical($logical));

  // do we have the old and the new versions of the metdatafile?
  if (is_file($newMetadataFile) && is_file($oldMetadataFile)) {
    // delete the old one
    unlink($oldMetadataFile);
  }

  // loading metadata
  $result = getAllMetaData($logical);
  $result[$name] = $value;
  if (!is_dir(METADATADIR)) {mkdir(METADATADIR);}
  file_put_contents($newMetadataFile, json_encode($result));
}


/** gets the current URL */
function getFullUrl() {
  return 'http://'.$_SERVER['HTTP_HOST'].''.$_SERVER['REQUEST_URI'];
}


/** gets the metadata for a given resource (can be either physical or logical) */
function getAllMetaData($resource) {

  $result = null;
  global $metadata_functions;
  //print_r($metadata_functions);
  foreach ($metadata_functions as $func) {    
    $metadata = $func($resource);
    //echo $func;print_r($metadata);
    if ($result==null && is_array($metadata)) {
       $result = $metadata;
       break;
    } //else die('metadata not an array '.$resource);
  }
   
  if ($result==null) { 
    //die('ooops, you expect something here, please use hasMetadata for '.$resource);
    $result = array();
   }

  if (!isset($result['logical'])) {
    $result['logical'] = $resource;
  }

  if (!isset($result['title'])) {
    $result['title'] = $result['logical'];
  }

  return $result;
}

/** gets the metadata from the metadata directory */
function get_metadata_from_dir($resource) {
  $debug = '<pre>'.$resource."\n".metadataFileOf($resource)."\n".logical2physical($resource)."\n".metadataFileOf(logical2physical($resource)).'</pre>'; 
  //echo $debug;
  if (is_file(metadataFileOf($resource)))  { 
    //echo trim(file_get_contents(metadataFileOf($resource)));
    $r = json_decode(trim(file_get_contents(metadataFileOf($resource))), true);
    return $r;
  } else {
    $physical =logical2physical($resource);
    if (is_file(metadataFileOf($physical))) {
      $r = json_decode(trim(file_get_contents(metadataFileOf($physical))), true);
      return $r;
    }   
    //else die($debug);
  }
  return null;
}

/** gets the author of a given resource, */
function getAuthor($logical=LOGICALNAME) {
  $metadata = getAllMetaData($logical);
  if (isset($metadata['author'])) return $metadata['author'];
  else return AUTHOR_NAME;
}

/** gets the author of a given resource, */
function getEncoding($logical=LOGICALNAME) {
  $metadata = getAllMetaData($logical);
  if (isset($metadata['encoding'])) return $metadata['encoding'];
  else return 'utf-8';
}

/** gets additional stuff to put in <head> */
function getHeadContent() {
  if (defined('GAKOWIKI_HEAD')) {
    return GAKOWIKI_HEAD;
  }
  return '';
}

/** returns a human readable version of the date */
function gk_get_creation_time_human() {
  return getCreationTime2();
}

/** gets the title of a given resource */
function getTitle($logical=LOGICALNAME) {
  if (defined('GAKOWIKI_TITLE')) {
    return GAKOWIKI_TITLE;
  }
  $metadata = getAllMetaData($logical);
  if (isset($metadata['title'])) return $metadata['title'];
  else return $metadata['logical'];
}


/** returns the creation time of this resource as Unix time in seconds */
function getCreationTime($logical=LOGICALNAME) {
  $metadata = getAllMetaData($logical);
  if (isset($metadata['ctime'])) return $metadata['ctime'];
  $resource =logical2physical($logical);
  if (is_file($resource)) return filemtime($resource);
  return time();
}

/** returns the creation time of this resource as string */
function getCreationTime2($logical=LOGICALNAME) {
  $metadata = getAllMetaData($logical);
  if (isset($metadata['ctime2'])) return $metadata['ctime2'];
  if (isset($metadata['ctime'])) return date('F d, Y',getCreationTime($logical));
  return 'unknown';
}


/** returns the time of the last modification of this resource as Unix time in seconds */
function getLastModificationTime($logical=LOGICALNAME) {
  $metadata = getAllMetaData($logical);
  if (isset($metadata['mtime'])) return $metadata['mtime'];
  $resource =logical2physical($logical);
  if (is_file($resource)) return filemtime(logical2physical($resource));
  return time();
}

/** add a <link> tag if the page has a specific css */
function page_specific_css() {
  /* does the page have a special CSS associated with? */  
  if (is_file(LOGICALNAME.'.css')) return '<link rel="stylesheet" type="text/css" href="'.rawurlencode(LOGICALNAME).'.css"/>'; 
  return '';
}


/** Theme inspired by dokuwiki */
function theme_doku() {
 ?><?php /* pp4php: including ./theme_doku.php (in gakowiki.php:608) */ ?><!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=<?php echo getEncoding(); ?>"/>
<meta name="generator" content="gakowiki"/>
<meta name="DC.Title" content="<?php echo getTitle();?>"/>
<meta name="DC.Creator" content="<?php echo getAuthor();?>"/>
<meta name="DC.Date" scheme="W3CDTF"  content="<?php echo date(DATE_W3C,getCreationTime());?>"/>
<?php echo getHeadContent(); ?>
<link rel="stylesheet" type="text/css" href="<? echo get_css_url();?>"/>
<?php echo page_specific_css(); ?>

<title><?php echo getTitle();?></title>

</head>
<body>

<?php echo advertisement(); ?>

<h1 id="title"><?php echo getTitle();?></h1>
<div class="gakowiki_engage">by Martin Monperrus <?php echo getTags(); ?></div>

<div class="content">
<?php  echo CONTENT;; ?>
</div>
<!-- comments -->
<div class="js-kit-comments"></div>
<!-- footer -->
<div class="gakowiki_footer" >
Created on <?php echo gk_get_creation_time_human()?>.
Last modified on <?php echo date('F d, Y',getLastModificationTime());?>.
Share on <a href="http://twitter.com/home?status=<?php echo urlencode('Currently reading '.getFullUrl())?>"><img style="height:14px;vertical-align:middle" border="0" src="twitter.svg" alt="Twitter"/></a><a href="http://www.facebook.com/sharer.php?u=<?php echo urlencode(getFullUrl())?>"><img style="height:14px;vertical-align:middle" border="0" src="facebook.svg"  alt="Facebook"/></a>.

<!-- I use a form to avoid search engines indexing -->
<form method="get">
<input type="hidden" name= "edit"/>
<input class="button" type="submit" value="Edit"/>
</form>
</div>
</body>


<script src="http://js-kit.com/comments.js" type="text/javascript"></script>
<script type="text/javascript">

  var _gaq = _gaq || [];
  _gaq.push(['_setAccount', 'UA-16808512-2']);
  _gaq.push(['_trackPageview']);

  (function() {
    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
  })();

</script>
<!-- <script type="text/javascript" src="http://s7.addthis.com/js/250/addthis_widget.js#pubid=xa-4d9067636c4fc4be"></script> -->

</html><?php 
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////// DISPLAY
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/** redirects to the url contained in LOGICALNAME.redirect */
function redirect_display() {
  header('Location: '.trim(file_get_contents(PHYSICALNAME)));
  exit;
}

/** returns an HTML string containing all posts for a given tag  */
function tag_display() {
  // is it a tag?
  if (preg_match('/^tag:(.+)/',LOGICALNAME,$entries)) {
    $tag = $entries[1];
  } else { $tag = LOGICALNAME; }
  // tag must be utf8-encoded (because of json)
  $tagenc = $tag;
  define('GAKOWIKI_TITLE','Pages tagged with &quot;'.$tag.'&quot; on monperrus.net');
  echo '<!-- tag display -->';
  ob_start();
  archives(getPagesForTag($tagenc), -1, true);
  return ob_get_clean();
}

/** displays the documentation of a PHP file */
function php_display($filename) {
 return generic_code($filename);
}

/** displays the documentation of a KMT file (kermeta) */
function kmt_display($filename) {
 return generic_code($filename);
}

/** displays the documentation of a JS file (Javascript) */
function js_display($filename) {
 return generic_code($filename);
}

/** displays the documentation of a C file  */
function c_display($filename) {
 return generic_code($filename);
}


/** handles the display of embedded documentation */
function generic_code($filename) {
  $array=@file($filename);
  $documentation=array();
  $title=$filename; // default title
  // get the title
  if (preg_match('/\/\*\*?(.*)$/',$array[0],$matches)) {
   $title=$matches[1];
   array_shift($array);

  // skip leo headers
  while(preg_match('/^\/\//',$array[0])) array_shift($array);

  // searching beginning of code
  $documentation=array();
  foreach($array as $k) {
    if (!preg_match('/\*\//',$k)) $documentation[]=$k;
    else break;
  }
 }
  @define('GAKOWIKI_TITLE', $title);
  return (join('',$documentation));
}

/** handles the display of latex package */
function sty_display($filename) {
  $array=@file($filename);
  $title=$filename; // default title
  define('GAKOWIKI_TITLE', $title);
  // get the title
  ereg('^%+(.*)$',$array[0],$matches) and $title=$matches[1];
  unset($array[0]);
  // searching beginning of code
  $documentation=array();
  foreach($array as $k) {
    if (ereg('^%+(.*)$',$k,$matches)) $documentation[]=$matches[1];
    else break;
  }
  return (join('',$documentation));
}

/** handles the display of shell scripts */
function sh_display($filename) {
  $array=@file($filename);
  $title=$filename; // default title
  define('GAKOWIKI_TITLE', $title);
  // get the title
  array_shift($array); // drop #!bin/bash
  ereg('^#+(.*)$',$array[0],$matches) and $title=$matches[1];
  unset($array[0]);
  // searching beginning of code
  $documentation=array();
  foreach($array as $k) {
    if (ereg('^#+(.*)$',$k,$matches)) $documentation[]=$matches[1];
    else break;
  }
  return (join('',$documentation));
}


/** gakowiki */
function gakowiki_display($filename) {
  return (file_get_contents($filename));
}

/** markdown */
function md_display($filename) {
  return (file_get_contents($filename));
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////   NOW THE FORMATS
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

/** gakowiki format */
function gakowiki_format($raw) {
  return wiki2html($raw);
}

/** text format */
function txt_format($raw) {
  return '<pre>'.$raw.'</pre>';
}

/** html format */
function html_format($raw) {
  return $raw;
}


/** interprets the $raw content as Markdown */
function markdown_format($raw) {
 ?><?php /* pp4php: including ./markdown.php (in gakowiki.php:749) */ ?><?php
#
# Markdown  -  A text-to-HTML conversion tool for web writers
#
# PHP Markdown
# Copyright (c) 2004-2009 Michel Fortin  
# <http://michelf.com/projects/php-markdown/>
#
# Original Markdown
# Copyright (c) 2004-2006 John Gruber  
# <http://daringfireball.net/projects/markdown/>
#


define( 'MARKDOWN_VERSION',  "1.0.1n" ); # Sat 10 Oct 2009


#
# Global default settings:
#

# Change to ">" for HTML output
@define( 'MARKDOWN_EMPTY_ELEMENT_SUFFIX',  " />");

# Define the width of a tab for code blocks.
@define( 'MARKDOWN_TAB_WIDTH',     4 );


#
# WordPress settings:
#

# Change to false to remove Markdown from posts and/or comments.
@define( 'MARKDOWN_WP_POSTS',      true );
@define( 'MARKDOWN_WP_COMMENTS',   true );


### Standard Function Interface ###

@define( 'MARKDOWN_PARSER_CLASS',  'Markdown_Parser' );

function Markdown($text) {
#
# Initialize the parser and return the result of its transform method.
#
	# Setup static parser variable.
	static $parser;
	if (!isset($parser)) {
		$parser_class = MARKDOWN_PARSER_CLASS;
		$parser = new $parser_class;
	}

	# Transform text using parser.
	return $parser->transform($text);
}


### WordPress Plugin Interface ###

/*
Plugin Name: Markdown
Plugin URI: http://michelf.com/projects/php-markdown/
Description: <a href="http://daringfireball.net/projects/markdown/syntax">Markdown syntax</a> allows you to write using an easy-to-read, easy-to-write plain text format. Based on the original Perl version by <a href="http://daringfireball.net/">John Gruber</a>. <a href="http://michelf.com/projects/php-markdown/">More...</a>
Version: 1.0.1n
Author: Michel Fortin
Author URI: http://michelf.com/
*/

if (isset($wp_version)) {
	# More details about how it works here:
	# <http://michelf.com/weblog/2005/wordpress-text-flow-vs-markdown/>
	
	# Post content and excerpts
	# - Remove WordPress paragraph generator.
	# - Run Markdown on excerpt, then remove all tags.
	# - Add paragraph tag around the excerpt, but remove it for the excerpt rss.
	if (MARKDOWN_WP_POSTS) {
		remove_filter('the_content',     'wpautop');
        remove_filter('the_content_rss', 'wpautop');
		remove_filter('the_excerpt',     'wpautop');
		add_filter('the_content',     'Markdown', 6);
        add_filter('the_content_rss', 'Markdown', 6);
		add_filter('get_the_excerpt', 'Markdown', 6);
		add_filter('get_the_excerpt', 'trim', 7);
		add_filter('the_excerpt',     'mdwp_add_p');
		add_filter('the_excerpt_rss', 'mdwp_strip_p');
		
		remove_filter('content_save_pre',  'balanceTags', 50);
		remove_filter('excerpt_save_pre',  'balanceTags', 50);
		add_filter('the_content',  	  'balanceTags', 50);
		add_filter('get_the_excerpt', 'balanceTags', 9);
	}
	
	# Comments
	# - Remove WordPress paragraph generator.
	# - Remove WordPress auto-link generator.
	# - Scramble important tags before passing them to the kses filter.
	# - Run Markdown on excerpt then remove paragraph tags.
	if (MARKDOWN_WP_COMMENTS) {
		remove_filter('comment_text', 'wpautop', 30);
		remove_filter('comment_text', 'make_clickable');
		add_filter('pre_comment_content', 'Markdown', 6);
		add_filter('pre_comment_content', 'mdwp_hide_tags', 8);
		add_filter('pre_comment_content', 'mdwp_show_tags', 12);
		add_filter('get_comment_text',    'Markdown', 6);
		add_filter('get_comment_excerpt', 'Markdown', 6);
		add_filter('get_comment_excerpt', 'mdwp_strip_p', 7);
	
		global $mdwp_hidden_tags, $mdwp_placeholders;
		$mdwp_hidden_tags = explode(' ',
			'<p> </p> <pre> </pre> <ol> </ol> <ul> </ul> <li> </li>');
		$mdwp_placeholders = explode(' ', str_rot13(
			'pEj07ZbbBZ U1kqgh4w4p pre2zmeN6K QTi31t9pre ol0MP1jzJR '.
			'ML5IjmbRol ulANi1NsGY J7zRLJqPul liA8ctl16T K9nhooUHli'));
	}
	
	function mdwp_add_p($text) {
		if (!preg_match('{^$|^<(p|ul|ol|dl|pre|blockquote)>}i', $text)) {
			$text = '<p>'.$text.'</p>';
			$text = preg_replace('{\n{2,}}', "</p>\n\n<p>", $text);
		}
		return $text;
	}
	
	function mdwp_strip_p($t) { return preg_replace('{</?p>}i', '', $t); }

	function mdwp_hide_tags($text) {
		global $mdwp_hidden_tags, $mdwp_placeholders;
		return str_replace($mdwp_hidden_tags, $mdwp_placeholders, $text);
	}
	function mdwp_show_tags($text) {
		global $mdwp_hidden_tags, $mdwp_placeholders;
		return str_replace($mdwp_placeholders, $mdwp_hidden_tags, $text);
	}
}


### bBlog Plugin Info ###

function identify_modifier_markdown() {
	return array(
		'name'			=> 'markdown',
		'type'			=> 'modifier',
		'nicename'		=> 'Markdown',
		'description'	=> 'A text-to-HTML conversion tool for web writers',
		'authors'		=> 'Michel Fortin and John Gruber',
		'licence'		=> 'BSD-like',
		'version'		=> MARKDOWN_VERSION,
		'help'			=> '<a href="http://daringfireball.net/projects/markdown/syntax">Markdown syntax</a> allows you to write using an easy-to-read, easy-to-write plain text format. Based on the original Perl version by <a href="http://daringfireball.net/">John Gruber</a>. <a href="http://michelf.com/projects/php-markdown/">More...</a>'
	);
}


### Smarty Modifier Interface ###

function smarty_modifier_markdown($text) {
	return Markdown($text);
}


### Textile Compatibility Mode ###

# Rename this file to "classTextile.php" and it can replace Textile everywhere.

if (strcasecmp(substr(__FILE__, -16), "classTextile.php") == 0) {
	# Try to include PHP SmartyPants. Should be in the same directory.
	@include_once 'smartypants.php';
	# Fake Textile class. It calls Markdown instead.
	class Textile {
		function TextileThis($text, $lite='', $encode='') {
			if ($lite == '' && $encode == '')    $text = Markdown($text);
			if (function_exists('SmartyPants'))  $text = SmartyPants($text);
			return $text;
		}
		# Fake restricted version: restrictions are not supported for now.
		function TextileRestricted($text, $lite='', $noimage='') {
			return $this->TextileThis($text, $lite);
		}
		# Workaround to ensure compatibility with TextPattern 4.0.3.
		function blockLite($text) { return $text; }
	}
}


#
# Markdown Parser Class
#

class Markdown_Parser {

	# Regex to match balanced [brackets].
	# Needed to insert a maximum bracked depth while converting to PHP.
	var $nested_brackets_depth = 6;
	var $nested_brackets_re;
	
	var $nested_url_parenthesis_depth = 4;
	var $nested_url_parenthesis_re;

	# Table of hash values for escaped characters:
	var $escape_chars = '\`*_{}[]()>#+-.!';
	var $escape_chars_re;

	# Change to ">" for HTML output.
	var $empty_element_suffix = MARKDOWN_EMPTY_ELEMENT_SUFFIX;
	var $tab_width = MARKDOWN_TAB_WIDTH;
	
	# Change to `true` to disallow markup or entities.
	var $no_markup = false;
	var $no_entities = false;
	
	# Predefined urls and titles for reference links and images.
	var $predef_urls = array();
	var $predef_titles = array();


	function Markdown_Parser() {
	#
	# Constructor function. Initialize appropriate member variables.
	#
		$this->_initDetab();
		$this->prepareItalicsAndBold();
	
		$this->nested_brackets_re = 
			str_repeat('(?>[^\[\]]+|\[', $this->nested_brackets_depth).
			str_repeat('\])*', $this->nested_brackets_depth);
	
		$this->nested_url_parenthesis_re = 
			str_repeat('(?>[^()\s]+|\(', $this->nested_url_parenthesis_depth).
			str_repeat('(?>\)))*', $this->nested_url_parenthesis_depth);
		
		$this->escape_chars_re = '['.preg_quote($this->escape_chars).']';
		
		# Sort document, block, and span gamut in ascendent priority order.
		asort($this->document_gamut);
		asort($this->block_gamut);
		asort($this->span_gamut);
	}


	# Internal hashes used during transformation.
	var $urls = array();
	var $titles = array();
	var $html_hashes = array();
	
	# Status flag to avoid invalid nesting.
	var $in_anchor = false;
	
	
	function setup() {
	#
	# Called before the transformation process starts to setup parser 
	# states.
	#
		# Clear global hashes.
		$this->urls = $this->predef_urls;
		$this->titles = $this->predef_titles;
		$this->html_hashes = array();
		
		$in_anchor = false;
	}
	
	function teardown() {
	#
	# Called after the transformation process to clear any variable 
	# which may be taking up memory unnecessarly.
	#
		$this->urls = array();
		$this->titles = array();
		$this->html_hashes = array();
	}


	function transform($text) {
	#
	# Main function. Performs some preprocessing on the input text
	# and pass it through the document gamut.
	#
		$this->setup();
	
		# Remove UTF-8 BOM and marker character in input, if present.
		$text = preg_replace('{^\xEF\xBB\xBF|\x1A}', '', $text);

		# Standardize line endings:
		#   DOS to Unix and Mac to Unix
		$text = preg_replace('{\r\n?}', "\n", $text);

		# Make sure $text ends with a couple of newlines:
		$text .= "\n\n";

		# Convert all tabs to spaces.
		$text = $this->detab($text);

		# Turn block-level HTML blocks into hash entries
		$text = $this->hashHTMLBlocks($text);

		# Strip any lines consisting only of spaces and tabs.
		# This makes subsequent regexen easier to write, because we can
		# match consecutive blank lines with /\n+/ instead of something
		# contorted like /[ ]*\n+/ .
		$text = preg_replace('/^[ ]+$/m', '', $text);

		# Run document gamut methods.
		foreach ($this->document_gamut as $method => $priority) {
			$text = $this->$method($text);
		}
		
		$this->teardown();

		return $text . "\n";
	}
	
	var $document_gamut = array(
		# Strip link definitions, store in hashes.
		"stripLinkDefinitions" => 20,
		
		"runBasicBlockGamut"   => 30,
		);


	function stripLinkDefinitions($text) {
	#
	# Strips link definitions from text, stores the URLs and titles in
	# hash references.
	#
		$less_than_tab = $this->tab_width - 1;

		# Link defs are in the form: ^[id]: url "optional title"
		$text = preg_replace_callback('{
							^[ ]{0,'.$less_than_tab.'}\[(.+)\][ ]?:	# id = $1
							  [ ]*
							  \n?				# maybe *one* newline
							  [ ]*
							(?:
							  <(.+?)>			# url = $2
							|
							  (\S+?)			# url = $3
							)
							  [ ]*
							  \n?				# maybe one newline
							  [ ]*
							(?:
								(?<=\s)			# lookbehind for whitespace
								["(]
								(.*?)			# title = $4
								[")]
								[ ]*
							)?	# title is optional
							(?:\n+|\Z)
			}xm',
			array(&$this, '_stripLinkDefinitions_callback'),
			$text);
		return $text;
	}
	function _stripLinkDefinitions_callback($matches) {
		$link_id = strtolower($matches[1]);
		$url = $matches[2] == '' ? $matches[3] : $matches[2];
		$this->urls[$link_id] = $url;
		$this->titles[$link_id] =& $matches[4];
		return ''; # String that will replace the block
	}


	function hashHTMLBlocks($text) {
		if ($this->no_markup)  return $text;

		$less_than_tab = $this->tab_width - 1;

		# Hashify HTML blocks:
		# We only want to do this for block-level HTML tags, such as headers,
		# lists, and tables. That's because we still want to wrap <p>s around
		# "paragraphs" that are wrapped in non-block-level tags, such as anchors,
		# phrase emphasis, and spans. The list of tags we're looking for is
		# hard-coded:
		#
		# *  List "a" is made of tags which can be both inline or block-level.
		#    These will be treated block-level when the start tag is alone on 
		#    its line, otherwise they're not matched here and will be taken as 
		#    inline later.
		# *  List "b" is made of tags which are always block-level;
		#
		$block_tags_a_re = 'ins|del';
		$block_tags_b_re = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|address|'.
						   'script|noscript|form|fieldset|iframe|math';

		# Regular expression for the content of a block tag.
		$nested_tags_level = 4;
		$attr = '
			(?>				# optional tag attributes
			  \s			# starts with whitespace
			  (?>
				[^>"/]+		# text outside quotes
			  |
				/+(?!>)		# slash not followed by ">"
			  |
				"[^"]*"		# text inside double quotes (tolerate ">")
			  |
				\'[^\']*\'	# text inside single quotes (tolerate ">")
			  )*
			)?	
			';
		$content =
			str_repeat('
				(?>
				  [^<]+			# content without tag
				|
				  <\2			# nested opening tag
					'.$attr.'	# attributes
					(?>
					  />
					|
					  >', $nested_tags_level).	# end of opening tag
					  '.*?'.					# last level nested tag content
			str_repeat('
					  </\2\s*>	# closing nested tag
					)
				  |				
					<(?!/\2\s*>	# other tags with a different name
				  )
				)*',
				$nested_tags_level);
		$content2 = str_replace('\2', '\3', $content);

		# First, look for nested blocks, e.g.:
		# 	<div>
		# 		<div>
		# 		tags for inner block must be indented.
		# 		</div>
		# 	</div>
		#
		# The outermost tags must start at the left margin for this to match, and
		# the inner nested divs must be indented.
		# We need to do this before the next, more liberal match, because the next
		# match will start at the first `<div>` and stop at the first `</div>`.
		$text = preg_replace_callback('{(?>
			(?>
				(?<=\n\n)		# Starting after a blank line
				|				# or
				\A\n?			# the beginning of the doc
			)
			(						# save in $1

			  # Match from `\n<tag>` to `</tag>\n`, handling nested tags 
			  # in between.
					
						[ ]{0,'.$less_than_tab.'}
						<('.$block_tags_b_re.')# start tag = $2
						'.$attr.'>			# attributes followed by > and \n
						'.$content.'		# content, support nesting
						</\2>				# the matching end tag
						[ ]*				# trailing spaces/tabs
						(?=\n+|\Z)	# followed by a newline or end of document

			| # Special version for tags of group a.

						[ ]{0,'.$less_than_tab.'}
						<('.$block_tags_a_re.')# start tag = $3
						'.$attr.'>[ ]*\n	# attributes followed by >
						'.$content2.'		# content, support nesting
						</\3>				# the matching end tag
						[ ]*				# trailing spaces/tabs
						(?=\n+|\Z)	# followed by a newline or end of document
					
			| # Special case just for <hr />. It was easier to make a special 
			  # case than to make the other regex more complicated.
			
						[ ]{0,'.$less_than_tab.'}
						<(hr)				# start tag = $2
						'.$attr.'			# attributes
						/?>					# the matching end tag
						[ ]*
						(?=\n{2,}|\Z)		# followed by a blank line or end of document
			
			| # Special case for standalone HTML comments:
			
					[ ]{0,'.$less_than_tab.'}
					(?s:
						<!-- .*? -->
					)
					[ ]*
					(?=\n{2,}|\Z)		# followed by a blank line or end of document
			
			| # PHP and ASP-style processor instructions (<? and <%)
			
					[ ]{0,'.$less_than_tab.'}
					(?s:
						<([?%])			# $2
						.*?
						\2>
					)
					[ ]*
					(?=\n{2,}|\Z)		# followed by a blank line or end of document
					
			)
			)}Sxmi',
			array(&$this, '_hashHTMLBlocks_callback'),
			$text);

		return $text;
	}
	function _hashHTMLBlocks_callback($matches) {
		$text = $matches[1];
		$key  = $this->hashBlock($text);
		return "\n\n$key\n\n";
	}
	
	
	function hashPart($text, $boundary = 'X') {
	#
	# Called whenever a tag must be hashed when a function insert an atomic 
	# element in the text stream. Passing $text to through this function gives
	# a unique text-token which will be reverted back when calling unhash.
	#
	# The $boundary argument specify what character should be used to surround
	# the token. By convension, "B" is used for block elements that needs not
	# to be wrapped into paragraph tags at the end, ":" is used for elements
	# that are word separators and "X" is used in the general case.
	#
		# Swap back any tag hash found in $text so we do not have to `unhash`
		# multiple times at the end.
		$text = $this->unhash($text);
		
		# Then hash the block.
		static $i = 0;
		$key = "$boundary\x1A" . ++$i . $boundary;
		$this->html_hashes[$key] = $text;
		return $key; # String that will replace the tag.
	}


	function hashBlock($text) {
	#
	# Shortcut function for hashPart with block-level boundaries.
	#
		return $this->hashPart($text, 'B');
	}


	var $block_gamut = array(
	#
	# These are all the transformations that form block-level
	# tags like paragraphs, headers, and list items.
	#
		"doHeaders"         => 10,
		"doHorizontalRules" => 20,
		
		"doLists"           => 40,
		"doCodeBlocks"      => 50,
		"doBlockQuotes"     => 60,
		);

	function runBlockGamut($text) {
	#
	# Run block gamut tranformations.
	#
		# We need to escape raw HTML in Markdown source before doing anything 
		# else. This need to be done for each block, and not only at the 
		# begining in the Markdown function since hashed blocks can be part of
		# list items and could have been indented. Indented blocks would have 
		# been seen as a code block in a previous pass of hashHTMLBlocks.
		$text = $this->hashHTMLBlocks($text);
		
		return $this->runBasicBlockGamut($text);
	}
	
	function runBasicBlockGamut($text) {
	#
	# Run block gamut tranformations, without hashing HTML blocks. This is 
	# useful when HTML blocks are known to be already hashed, like in the first
	# whole-document pass.
	#
		foreach ($this->block_gamut as $method => $priority) {
			$text = $this->$method($text);
		}
		
		# Finally form paragraph and restore hashed blocks.
		$text = $this->formParagraphs($text);

		return $text;
	}
	
	
	function doHorizontalRules($text) {
		# Do Horizontal Rules:
		return preg_replace(
			'{
				^[ ]{0,3}	# Leading space
				([-*_])		# $1: First marker
				(?>			# Repeated marker group
					[ ]{0,2}	# Zero, one, or two spaces.
					\1			# Marker character
				){2,}		# Group repeated at least twice
				[ ]*		# Tailing spaces
				$			# End of line.
			}mx',
			"\n".$this->hashBlock("<hr$this->empty_element_suffix")."\n", 
			$text);
	}


	var $span_gamut = array(
	#
	# These are all the transformations that occur *within* block-level
	# tags like paragraphs, headers, and list items.
	#
		# Process character escapes, code spans, and inline HTML
		# in one shot.
		"parseSpan"           => -30,

		# Process anchor and image tags. Images must come first,
		# because ![foo][f] looks like an anchor.
		"doImages"            =>  10,
		"doAnchors"           =>  20,
		
		# Make links out of things like `<http://example.com/>`
		# Must come after doAnchors, because you can use < and >
		# delimiters in inline links like [this](<url>).
		"doAutoLinks"         =>  30,
		"encodeAmpsAndAngles" =>  40,

		"doItalicsAndBold"    =>  50,
		"doHardBreaks"        =>  60,
		);

	function runSpanGamut($text) {
	#
	# Run span gamut tranformations.
	#
		foreach ($this->span_gamut as $method => $priority) {
			$text = $this->$method($text);
		}

		return $text;
	}
	
	
	function doHardBreaks($text) {
		# Do hard breaks:
		return preg_replace_callback('/ {2,}\n/', 
			array(&$this, '_doHardBreaks_callback'), $text);
	}
	function _doHardBreaks_callback($matches) {
		return $this->hashPart("<br$this->empty_element_suffix\n");
	}


	function doAnchors($text) {
	#
	# Turn Markdown link shortcuts into XHTML <a> tags.
	#
		if ($this->in_anchor) return $text;
		$this->in_anchor = true;
		
		#
		# First, handle reference-style links: [link text] [id]
		#
		$text = preg_replace_callback('{
			(					# wrap whole match in $1
			  \[
				('.$this->nested_brackets_re.')	# link text = $2
			  \]

			  [ ]?				# one optional space
			  (?:\n[ ]*)?		# one optional newline followed by spaces

			  \[
				(.*?)		# id = $3
			  \]
			)
			}xs',
			array(&$this, '_doAnchors_reference_callback'), $text);

		#
		# Next, inline-style links: [link text](url "optional title")
		#
		$text = preg_replace_callback('{
			(				# wrap whole match in $1
			  \[
				('.$this->nested_brackets_re.')	# link text = $2
			  \]
			  \(			# literal paren
				[ \n]*
				(?:
					<(.+?)>	# href = $3
				|
					('.$this->nested_url_parenthesis_re.')	# href = $4
				)
				[ \n]*
				(			# $5
				  ([\'"])	# quote char = $6
				  (.*?)		# Title = $7
				  \6		# matching quote
				  [ \n]*	# ignore any spaces/tabs between closing quote and )
				)?			# title is optional
			  \)
			)
			}xs',
			array(&$this, '_doAnchors_inline_callback'), $text);

		#
		# Last, handle reference-style shortcuts: [link text]
		# These must come last in case you've also got [link text][1]
		# or [link text](/foo)
		#
		$text = preg_replace_callback('{
			(					# wrap whole match in $1
			  \[
				([^\[\]]+)		# link text = $2; can\'t contain [ or ]
			  \]
			)
			}xs',
			array(&$this, '_doAnchors_reference_callback'), $text);

		$this->in_anchor = false;
		return $text;
	}
	function _doAnchors_reference_callback($matches) {
		$whole_match =  $matches[1];
		$link_text   =  $matches[2];
		$link_id     =& $matches[3];

		if ($link_id == "") {
			# for shortcut links like [this][] or [this].
			$link_id = $link_text;
		}
		
		# lower-case and turn embedded newlines into spaces
		$link_id = strtolower($link_id);
		$link_id = preg_replace('{[ ]?\n}', ' ', $link_id);

		if (isset($this->urls[$link_id])) {
			$url = $this->urls[$link_id];
			$url = $this->encodeAttribute($url);
			
			$result = "<a href=\"$url\"";
			if ( isset( $this->titles[$link_id] ) ) {
				$title = $this->titles[$link_id];
				$title = $this->encodeAttribute($title);
				$result .=  " title=\"$title\"";
			}
		
			$link_text = $this->runSpanGamut($link_text);
			$result .= ">$link_text</a>";
			$result = $this->hashPart($result);
		}
		else {
			$result = $whole_match;
		}
		return $result;
	}
	function _doAnchors_inline_callback($matches) {
		$whole_match	=  $matches[1];
		$link_text		=  $this->runSpanGamut($matches[2]);
		$url			=  $matches[3] == '' ? $matches[4] : $matches[3];
		$title			=& $matches[7];

		$url = $this->encodeAttribute($url);

		$result = "<a href=\"$url\"";
		if (isset($title)) {
			$title = $this->encodeAttribute($title);
			$result .=  " title=\"$title\"";
		}
		
		$link_text = $this->runSpanGamut($link_text);
		$result .= ">$link_text</a>";

		return $this->hashPart($result);
	}


	function doImages($text) {
	#
	# Turn Markdown image shortcuts into <img> tags.
	#
		#
		# First, handle reference-style labeled images: ![alt text][id]
		#
		$text = preg_replace_callback('{
			(				# wrap whole match in $1
			  !\[
				('.$this->nested_brackets_re.')		# alt text = $2
			  \]

			  [ ]?				# one optional space
			  (?:\n[ ]*)?		# one optional newline followed by spaces

			  \[
				(.*?)		# id = $3
			  \]

			)
			}xs', 
			array(&$this, '_doImages_reference_callback'), $text);

		#
		# Next, handle inline images:  ![alt text](url "optional title")
		# Don't forget: encode * and _
		#
		$text = preg_replace_callback('{
			(				# wrap whole match in $1
			  !\[
				('.$this->nested_brackets_re.')		# alt text = $2
			  \]
			  \s?			# One optional whitespace character
			  \(			# literal paren
				[ \n]*
				(?:
					<(\S*)>	# src url = $3
				|
					('.$this->nested_url_parenthesis_re.')	# src url = $4
				)
				[ \n]*
				(			# $5
				  ([\'"])	# quote char = $6
				  (.*?)		# title = $7
				  \6		# matching quote
				  [ \n]*
				)?			# title is optional
			  \)
			)
			}xs',
			array(&$this, '_doImages_inline_callback'), $text);

		return $text;
	}
	function _doImages_reference_callback($matches) {
		$whole_match = $matches[1];
		$alt_text    = $matches[2];
		$link_id     = strtolower($matches[3]);

		if ($link_id == "") {
			$link_id = strtolower($alt_text); # for shortcut links like ![this][].
		}

		$alt_text = $this->encodeAttribute($alt_text);
		if (isset($this->urls[$link_id])) {
			$url = $this->encodeAttribute($this->urls[$link_id]);
			$result = "<img src=\"$url\" alt=\"$alt_text\"";
			if (isset($this->titles[$link_id])) {
				$title = $this->titles[$link_id];
				$title = $this->encodeAttribute($title);
				$result .=  " title=\"$title\"";
			}
			$result .= $this->empty_element_suffix;
			$result = $this->hashPart($result);
		}
		else {
			# If there's no such link ID, leave intact:
			$result = $whole_match;
		}

		return $result;
	}
	function _doImages_inline_callback($matches) {
		$whole_match	= $matches[1];
		$alt_text		= $matches[2];
		$url			= $matches[3] == '' ? $matches[4] : $matches[3];
		$title			=& $matches[7];

		$alt_text = $this->encodeAttribute($alt_text);
		$url = $this->encodeAttribute($url);
		$result = "<img src=\"$url\" alt=\"$alt_text\"";
		if (isset($title)) {
			$title = $this->encodeAttribute($title);
			$result .=  " title=\"$title\""; # $title already quoted
		}
		$result .= $this->empty_element_suffix;

		return $this->hashPart($result);
	}


	function doHeaders($text) {
		# Setext-style headers:
		#	  Header 1
		#	  ========
		#  
		#	  Header 2
		#	  --------
		#
		$text = preg_replace_callback('{ ^(.+?)[ ]*\n(=+|-+)[ ]*\n+ }mx',
			array(&$this, '_doHeaders_callback_setext'), $text);

		# atx-style headers:
		#	# Header 1
		#	## Header 2
		#	## Header 2 with closing hashes ##
		#	...
		#	###### Header 6
		#
		$text = preg_replace_callback('{
				^(\#{1,6})	# $1 = string of #\'s
				[ ]*
				(.+?)		# $2 = Header text
				[ ]*
				\#*			# optional closing #\'s (not counted)
				\n+
			}xm',
			array(&$this, '_doHeaders_callback_atx'), $text);

		return $text;
	}
	function _doHeaders_callback_setext($matches) {
		# Terrible hack to check we haven't found an empty list item.
		if ($matches[2] == '-' && preg_match('{^-(?: |$)}', $matches[1]))
			return $matches[0];
		
		$level = $matches[2]{0} == '=' ? 1 : 2;
		$block = "<h$level>".$this->runSpanGamut($matches[1])."</h$level>";
		return "\n" . $this->hashBlock($block) . "\n\n";
	}
	function _doHeaders_callback_atx($matches) {
		$level = strlen($matches[1]);
		$block = "<h$level>".$this->runSpanGamut($matches[2])."</h$level>";
		return "\n" . $this->hashBlock($block) . "\n\n";
	}


	function doLists($text) {
	#
	# Form HTML ordered (numbered) and unordered (bulleted) lists.
	#
		$less_than_tab = $this->tab_width - 1;

		# Re-usable patterns to match list item bullets and number markers:
		$marker_ul_re  = '[*+-]';
		$marker_ol_re  = '\d+[.]';
		$marker_any_re = "(?:$marker_ul_re|$marker_ol_re)";

		$markers_relist = array(
			$marker_ul_re => $marker_ol_re,
			$marker_ol_re => $marker_ul_re,
			);

		foreach ($markers_relist as $marker_re => $other_marker_re) {
			# Re-usable pattern to match any entirel ul or ol list:
			$whole_list_re = '
				(								# $1 = whole list
				  (								# $2
					([ ]{0,'.$less_than_tab.'})	# $3 = number of spaces
					('.$marker_re.')			# $4 = first list item marker
					[ ]+
				  )
				  (?s:.+?)
				  (								# $5
					  \z
					|
					  \n{2,}
					  (?=\S)
					  (?!						# Negative lookahead for another list item marker
						[ ]*
						'.$marker_re.'[ ]+
					  )
					|
					  (?=						# Lookahead for another kind of list
					    \n
						\3						# Must have the same indentation
						'.$other_marker_re.'[ ]+
					  )
				  )
				)
			'; // mx
			
			# We use a different prefix before nested lists than top-level lists.
			# See extended comment in _ProcessListItems().
		
			if ($this->list_level) {
				$text = preg_replace_callback('{
						^
						'.$whole_list_re.'
					}mx',
					array(&$this, '_doLists_callback'), $text);
			}
			else {
				$text = preg_replace_callback('{
						(?:(?<=\n)\n|\A\n?) # Must eat the newline
						'.$whole_list_re.'
					}mx',
					array(&$this, '_doLists_callback'), $text);
			}
		}

		return $text;
	}
	function _doLists_callback($matches) {
		# Re-usable patterns to match list item bullets and number markers:
		$marker_ul_re  = '[*+-]';
		$marker_ol_re  = '\d+[.]';
		$marker_any_re = "(?:$marker_ul_re|$marker_ol_re)";
		
		$list = $matches[1];
		$list_type = preg_match("/$marker_ul_re/", $matches[4]) ? "ul" : "ol";
		
		$marker_any_re = ( $list_type == "ul" ? $marker_ul_re : $marker_ol_re );
		
		$list .= "\n";
		$result = $this->processListItems($list, $marker_any_re);
		
		$result = $this->hashBlock("<$list_type>\n" . $result . "</$list_type>");
		return "\n". $result ."\n\n";
	}

	var $list_level = 0;

	function processListItems($list_str, $marker_any_re) {
	#
	#	Process the contents of a single ordered or unordered list, splitting it
	#	into individual list items.
	#
		# The $this->list_level global keeps track of when we're inside a list.
		# Each time we enter a list, we increment it; when we leave a list,
		# we decrement. If it's zero, we're not in a list anymore.
		#
		# We do this because when we're not inside a list, we want to treat
		# something like this:
		#
		#		I recommend upgrading to version
		#		8. Oops, now this line is treated
		#		as a sub-list.
		#
		# As a single paragraph, despite the fact that the second line starts
		# with a digit-period-space sequence.
		#
		# Whereas when we're inside a list (or sub-list), that line will be
		# treated as the start of a sub-list. What a kludge, huh? This is
		# an aspect of Markdown's syntax that's hard to parse perfectly
		# without resorting to mind-reading. Perhaps the solution is to
		# change the syntax rules such that sub-lists must start with a
		# starting cardinal number; e.g. "1." or "a.".
		
		$this->list_level++;

		# trim trailing blank lines:
		$list_str = preg_replace("/\n{2,}\\z/", "\n", $list_str);

		$list_str = preg_replace_callback('{
			(\n)?							# leading line = $1
			(^[ ]*)							# leading whitespace = $2
			('.$marker_any_re.'				# list marker and space = $3
				(?:[ ]+|(?=\n))	# space only required if item is not empty
			)
			((?s:.*?))						# list item text   = $4
			(?:(\n+(?=\n))|\n)				# tailing blank line = $5
			(?= \n* (\z | \2 ('.$marker_any_re.') (?:[ ]+|(?=\n))))
			}xm',
			array(&$this, '_processListItems_callback'), $list_str);

		$this->list_level--;
		return $list_str;
	}
	function _processListItems_callback($matches) {
		$item = $matches[4];
		$leading_line =& $matches[1];
		$leading_space =& $matches[2];
		$marker_space = $matches[3];
		$tailing_blank_line =& $matches[5];

		if ($leading_line || $tailing_blank_line || 
			preg_match('/\n{2,}/', $item))
		{
			# Replace marker with the appropriate whitespace indentation
			$item = $leading_space . str_repeat(' ', strlen($marker_space)) . $item;
			$item = $this->runBlockGamut($this->outdent($item)."\n");
		}
		else {
			# Recursion for sub-lists:
			$item = $this->doLists($this->outdent($item));
			$item = preg_replace('/\n+$/', '', $item);
			$item = $this->runSpanGamut($item);
		}

		return "<li>" . $item . "</li>\n";
	}


	function doCodeBlocks($text) {
	#
	#	Process Markdown `<pre><code>` blocks.
	#
		$text = preg_replace_callback('{
				(?:\n\n|\A\n?)
				(	            # $1 = the code block -- one or more lines, starting with a space/tab
				  (?>
					[ ]{'.$this->tab_width.'}  # Lines must start with a tab or a tab-width of spaces
					.*\n+
				  )+
				)
				((?=^[ ]{0,'.$this->tab_width.'}\S)|\Z)	# Lookahead for non-space at line-start, or end of doc
			}xm',
			array(&$this, '_doCodeBlocks_callback'), $text);

		return $text;
	}
	function _doCodeBlocks_callback($matches) {
		$codeblock = $matches[1];

		$codeblock = $this->outdent($codeblock);
		$codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);

		# trim leading newlines and trailing newlines
		$codeblock = preg_replace('/\A\n+|\n+\z/', '', $codeblock);

		$codeblock = "<pre><code>$codeblock\n</code></pre>";
		return "\n\n".$this->hashBlock($codeblock)."\n\n";
	}


	function makeCodeSpan($code) {
	#
	# Create a code span markup for $code. Called from handleSpanToken.
	#
		$code = htmlspecialchars(trim($code), ENT_NOQUOTES);
		return $this->hashPart("<code>$code</code>");
	}


	var $em_relist = array(
		''  => '(?:(?<!\*)\*(?!\*)|(?<!_)_(?!_))(?=\S|$)(?![.,:;]\s)',
		'*' => '(?<=\S|^)(?<!\*)\*(?!\*)',
		'_' => '(?<=\S|^)(?<!_)_(?!_)',
		);
	var $strong_relist = array(
		''   => '(?:(?<!\*)\*\*(?!\*)|(?<!_)__(?!_))(?=\S|$)(?![.,:;]\s)',
		'**' => '(?<=\S|^)(?<!\*)\*\*(?!\*)',
		'__' => '(?<=\S|^)(?<!_)__(?!_)',
		);
	var $em_strong_relist = array(
		''    => '(?:(?<!\*)\*\*\*(?!\*)|(?<!_)___(?!_))(?=\S|$)(?![.,:;]\s)',
		'***' => '(?<=\S|^)(?<!\*)\*\*\*(?!\*)',
		'___' => '(?<=\S|^)(?<!_)___(?!_)',
		);
	var $em_strong_prepared_relist;
	
	function prepareItalicsAndBold() {
	#
	# Prepare regular expressions for searching emphasis tokens in any
	# context.
	#
		foreach ($this->em_relist as $em => $em_re) {
			foreach ($this->strong_relist as $strong => $strong_re) {
				# Construct list of allowed token expressions.
				$token_relist = array();
				if (isset($this->em_strong_relist["$em$strong"])) {
					$token_relist[] = $this->em_strong_relist["$em$strong"];
				}
				$token_relist[] = $em_re;
				$token_relist[] = $strong_re;
				
				# Construct master expression from list.
				$token_re = '{('. implode('|', $token_relist) .')}';
				$this->em_strong_prepared_relist["$em$strong"] = $token_re;
			}
		}
	}
	
	function doItalicsAndBold($text) {
		$token_stack = array('');
		$text_stack = array('');
		$em = '';
		$strong = '';
		$tree_char_em = false;
		
		while (1) {
			#
			# Get prepared regular expression for seraching emphasis tokens
			# in current context.
			#
			$token_re = $this->em_strong_prepared_relist["$em$strong"];
			
			#
			# Each loop iteration search for the next emphasis token. 
			# Each token is then passed to handleSpanToken.
			#
			$parts = preg_split($token_re, $text, 2, PREG_SPLIT_DELIM_CAPTURE);
			$text_stack[0] .= $parts[0];
			$token =& $parts[1];
			$text =& $parts[2];
			
			if (empty($token)) {
				# Reached end of text span: empty stack without emitting.
				# any more emphasis.
				while ($token_stack[0]) {
					$text_stack[1] .= array_shift($token_stack);
					$text_stack[0] .= array_shift($text_stack);
				}
				break;
			}
			
			$token_len = strlen($token);
			if ($tree_char_em) {
				# Reached closing marker while inside a three-char emphasis.
				if ($token_len == 3) {
					# Three-char closing marker, close em and strong.
					array_shift($token_stack);
					$span = array_shift($text_stack);
					$span = $this->runSpanGamut($span);
					$span = "<strong><em>$span</em></strong>";
					$text_stack[0] .= $this->hashPart($span);
					$em = '';
					$strong = '';
				} else {
					# Other closing marker: close one em or strong and
					# change current token state to match the other
					$token_stack[0] = str_repeat($token{0}, 3-$token_len);
					$tag = $token_len == 2 ? "strong" : "em";
					$span = $text_stack[0];
					$span = $this->runSpanGamut($span);
					$span = "<$tag>$span</$tag>";
					$text_stack[0] = $this->hashPart($span);
					$$tag = ''; # $$tag stands for $em or $strong
				}
				$tree_char_em = false;
			} else if ($token_len == 3) {
				if ($em) {
					# Reached closing marker for both em and strong.
					# Closing strong marker:
					for ($i = 0; $i < 2; ++$i) {
						$shifted_token = array_shift($token_stack);
						$tag = strlen($shifted_token) == 2 ? "strong" : "em";
						$span = array_shift($text_stack);
						$span = $this->runSpanGamut($span);
						$span = "<$tag>$span</$tag>";
						$text_stack[0] .= $this->hashPart($span);
						$$tag = ''; # $$tag stands for $em or $strong
					}
				} else {
					# Reached opening three-char emphasis marker. Push on token 
					# stack; will be handled by the special condition above.
					$em = $token{0};
					$strong = "$em$em";
					array_unshift($token_stack, $token);
					array_unshift($text_stack, '');
					$tree_char_em = true;
				}
			} else if ($token_len == 2) {
				if ($strong) {
					# Unwind any dangling emphasis marker:
					if (strlen($token_stack[0]) == 1) {
						$text_stack[1] .= array_shift($token_stack);
						$text_stack[0] .= array_shift($text_stack);
					}
					# Closing strong marker:
					array_shift($token_stack);
					$span = array_shift($text_stack);
					$span = $this->runSpanGamut($span);
					$span = "<strong>$span</strong>";
					$text_stack[0] .= $this->hashPart($span);
					$strong = '';
				} else {
					array_unshift($token_stack, $token);
					array_unshift($text_stack, '');
					$strong = $token;
				}
			} else {
				# Here $token_len == 1
				if ($em) {
					if (strlen($token_stack[0]) == 1) {
						# Closing emphasis marker:
						array_shift($token_stack);
						$span = array_shift($text_stack);
						$span = $this->runSpanGamut($span);
						$span = "<em>$span</em>";
						$text_stack[0] .= $this->hashPart($span);
						$em = '';
					} else {
						$text_stack[0] .= $token;
					}
				} else {
					array_unshift($token_stack, $token);
					array_unshift($text_stack, '');
					$em = $token;
				}
			}
		}
		return $text_stack[0];
	}


	function doBlockQuotes($text) {
		$text = preg_replace_callback('/
			  (								# Wrap whole match in $1
				(?>
				  ^[ ]*>[ ]?			# ">" at the start of a line
					.+\n					# rest of the first line
				  (.+\n)*					# subsequent consecutive lines
				  \n*						# blanks
				)+
			  )
			/xm',
			array(&$this, '_doBlockQuotes_callback'), $text);

		return $text;
	}
	function _doBlockQuotes_callback($matches) {
		$bq = $matches[1];
		# trim one level of quoting - trim whitespace-only lines
		$bq = preg_replace('/^[ ]*>[ ]?|^[ ]+$/m', '', $bq);
		$bq = $this->runBlockGamut($bq);		# recurse

		$bq = preg_replace('/^/m', "  ", $bq);
		# These leading spaces cause problem with <pre> content, 
		# so we need to fix that:
		$bq = preg_replace_callback('{(\s*<pre>.+?</pre>)}sx', 
			array(&$this, '_doBlockQuotes_callback2'), $bq);

		return "\n". $this->hashBlock("<blockquote>\n$bq\n</blockquote>")."\n\n";
	}
	function _doBlockQuotes_callback2($matches) {
		$pre = $matches[1];
		$pre = preg_replace('/^  /m', '', $pre);
		return $pre;
	}


	function formParagraphs($text) {
	#
	#	Params:
	#		$text - string to process with html <p> tags
	#
		# Strip leading and trailing lines:
		$text = preg_replace('/\A\n+|\n+\z/', '', $text);

		$grafs = preg_split('/\n{2,}/', $text, -1, PREG_SPLIT_NO_EMPTY);

		#
		# Wrap <p> tags and unhashify HTML blocks
		#
		foreach ($grafs as $key => $value) {
			if (!preg_match('/^B\x1A[0-9]+B$/', $value)) {
				# Is a paragraph.
				$value = $this->runSpanGamut($value);
				$value = preg_replace('/^([ ]*)/', "<p>", $value);
				$value .= "</p>";
				$grafs[$key] = $this->unhash($value);
			}
			else {
				# Is a block.
				# Modify elements of @grafs in-place...
				$graf = $value;
				$block = $this->html_hashes[$graf];
				$graf = $block;
//				if (preg_match('{
//					\A
//					(							# $1 = <div> tag
//					  <div  \s+
//					  [^>]*
//					  \b
//					  markdown\s*=\s*  ([\'"])	#	$2 = attr quote char
//					  1
//					  \2
//					  [^>]*
//					  >
//					)
//					(							# $3 = contents
//					.*
//					)
//					(</div>)					# $4 = closing tag
//					\z
//					}xs', $block, $matches))
//				{
//					list(, $div_open, , $div_content, $div_close) = $matches;
//
//					# We can't call Markdown(), because that resets the hash;
//					# that initialization code should be pulled into its own sub, though.
//					$div_content = $this->hashHTMLBlocks($div_content);
//					
//					# Run document gamut methods on the content.
//					foreach ($this->document_gamut as $method => $priority) {
//						$div_content = $this->$method($div_content);
//					}
//
//					$div_open = preg_replace(
//						'{\smarkdown\s*=\s*([\'"]).+?\1}', '', $div_open);
//
//					$graf = $div_open . "\n" . $div_content . "\n" . $div_close;
//				}
				$grafs[$key] = $graf;
			}
		}

		return implode("\n\n", $grafs);
	}


	function encodeAttribute($text) {
	#
	# Encode text for a double-quoted HTML attribute. This function
	# is *not* suitable for attributes enclosed in single quotes.
	#
		$text = $this->encodeAmpsAndAngles($text);
		$text = str_replace('"', '&quot;', $text);
		return $text;
	}
	
	
	function encodeAmpsAndAngles($text) {
	#
	# Smart processing for ampersands and angle brackets that need to 
	# be encoded. Valid character entities are left alone unless the
	# no-entities mode is set.
	#
		if ($this->no_entities) {
			$text = str_replace('&', '&amp;', $text);
		} else {
			# Ampersand-encoding based entirely on Nat Irons's Amputator
			# MT plugin: <http://bumppo.net/projects/amputator/>
			$text = preg_replace('/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/', 
								'&amp;', $text);;
		}
		# Encode remaining <'s
		$text = str_replace('<', '&lt;', $text);

		return $text;
	}


	function doAutoLinks($text) {
		$text = preg_replace_callback('{<((https?|ftp|dict):[^\'">\s]+)>}i', 
			array(&$this, '_doAutoLinks_url_callback'), $text);

		# Email addresses: <address@domain.foo>
		$text = preg_replace_callback('{
			<
			(?:mailto:)?
			(
				(?:
					[-!#$%&\'*+/=?^_`.{|}~\w\x80-\xFF]+
				|
					".*?"
				)
				\@
				(?:
					[-a-z0-9\x80-\xFF]+(\.[-a-z0-9\x80-\xFF]+)*\.[a-z]+
				|
					\[[\d.a-fA-F:]+\]	# IPv4 & IPv6
				)
			)
			>
			}xi',
			array(&$this, '_doAutoLinks_email_callback'), $text);

		return $text;
	}
	function _doAutoLinks_url_callback($matches) {
		$url = $this->encodeAttribute($matches[1]);
		$link = "<a href=\"$url\">$url</a>";
		return $this->hashPart($link);
	}
	function _doAutoLinks_email_callback($matches) {
		$address = $matches[1];
		$link = $this->encodeEmailAddress($address);
		return $this->hashPart($link);
	}


	function encodeEmailAddress($addr) {
	#
	#	Input: an email address, e.g. "foo@example.com"
	#
	#	Output: the email address as a mailto link, with each character
	#		of the address encoded as either a decimal or hex entity, in
	#		the hopes of foiling most address harvesting spam bots. E.g.:
	#
	#	  <p><a href="&#109;&#x61;&#105;&#x6c;&#116;&#x6f;&#58;&#x66;o&#111;
	#        &#x40;&#101;&#x78;&#97;&#x6d;&#112;&#x6c;&#101;&#46;&#x63;&#111;
	#        &#x6d;">&#x66;o&#111;&#x40;&#101;&#x78;&#97;&#x6d;&#112;&#x6c;
	#        &#101;&#46;&#x63;&#111;&#x6d;</a></p>
	#
	#	Based by a filter by Matthew Wickline, posted to BBEdit-Talk.
	#   With some optimizations by Milian Wolff.
	#
		$addr = "mailto:" . $addr;
		$chars = preg_split('/(?<!^)(?!$)/', $addr);
		$seed = (int)abs(crc32($addr) / strlen($addr)); # Deterministic seed.
		
		foreach ($chars as $key => $char) {
			$ord = ord($char);
			# Ignore non-ascii chars.
			if ($ord < 128) {
				$r = ($seed * (1 + $key)) % 100; # Pseudo-random function.
				# roughly 10% raw, 45% hex, 45% dec
				# '@' *must* be encoded. I insist.
				if ($r > 90 && $char != '@') /* do nothing */;
				else if ($r < 45) $chars[$key] = '&#x'.dechex($ord).';';
				else              $chars[$key] = '&#'.$ord.';';
			}
		}
		
		$addr = implode('', $chars);
		$text = implode('', array_slice($chars, 7)); # text without `mailto:`
		$addr = "<a href=\"$addr\">$text</a>";

		return $addr;
	}


	function parseSpan($str) {
	#
	# Take the string $str and parse it into tokens, hashing embeded HTML,
	# escaped characters and handling code spans.
	#
		$output = '';
		
		$span_re = '{
				(
					\\\\'.$this->escape_chars_re.'
				|
					(?<![`\\\\])
					`+						# code span marker
			'.( $this->no_markup ? '' : '
				|
					<!--    .*?     -->		# comment
				|
					<\?.*?\?> | <%.*?%>		# processing instruction
				|
					<[/!$]?[-a-zA-Z0-9:_]+	# regular tags
					(?>
						\s
						(?>[^"\'>]+|"[^"]*"|\'[^\']*\')*
					)?
					>
			').'
				)
				}xs';

		while (1) {
			#
			# Each loop iteration seach for either the next tag, the next 
			# openning code span marker, or the next escaped character. 
			# Each token is then passed to handleSpanToken.
			#
			$parts = preg_split($span_re, $str, 2, PREG_SPLIT_DELIM_CAPTURE);
			
			# Create token from text preceding tag.
			if ($parts[0] != "") {
				$output .= $parts[0];
			}
			
			# Check if we reach the end.
			if (isset($parts[1])) {
				$output .= $this->handleSpanToken($parts[1], $parts[2]);
				$str = $parts[2];
			}
			else {
				break;
			}
		}
		
		return $output;
	}
	
	
	function handleSpanToken($token, &$str) {
	#
	# Handle $token provided by parseSpan by determining its nature and 
	# returning the corresponding value that should replace it.
	#
		switch ($token{0}) {
			case "\\":
				return $this->hashPart("&#". ord($token{1}). ";");
			case "`":
				# Search for end marker in remaining text.
				if (preg_match('/^(.*?[^`])'.preg_quote($token).'(?!`)(.*)$/sm', 
					$str, $matches))
				{
					$str = $matches[2];
					$codespan = $this->makeCodeSpan($matches[1]);
					return $this->hashPart($codespan);
				}
				return $token; // return as text since no ending marker found.
			default:
				return $this->hashPart($token);
		}
	}


	function outdent($text) {
	#
	# Remove one level of line-leading tabs or spaces
	#
		return preg_replace('/^(\t|[ ]{1,'.$this->tab_width.'})/m', '', $text);
	}


	# String length function for detab. `_initDetab` will create a function to 
	# hanlde UTF-8 if the default function does not exist.
	var $utf8_strlen = 'mb_strlen';
	
	function detab($text) {
	#
	# Replace tabs with the appropriate amount of space.
	#
		# For each line we separate the line in blocks delemited by
		# tab characters. Then we reconstruct every line by adding the 
		# appropriate number of space between each blocks.
		
		$text = preg_replace_callback('/^.*\t.*$/m',
			array(&$this, '_detab_callback'), $text);

		return $text;
	}
	function _detab_callback($matches) {
		$line = $matches[0];
		$strlen = $this->utf8_strlen; # strlen function for UTF-8.
		
		# Split in blocks.
		$blocks = explode("\t", $line);
		# Add each blocks to the line.
		$line = $blocks[0];
		unset($blocks[0]); # Do not add first block twice.
		foreach ($blocks as $block) {
			# Calculate amount of space, insert spaces, insert block.
			$amount = $this->tab_width - 
				$strlen($line, 'UTF-8') % $this->tab_width;
			$line .= str_repeat(" ", $amount) . $block;
		}
		return $line;
	}
	function _initDetab() {
	#
	# Check for the availability of the function in the `utf8_strlen` property
	# (initially `mb_strlen`). If the function is not available, create a 
	# function that will loosely count the number of UTF-8 characters with a
	# regular expression.
	#
		if (function_exists($this->utf8_strlen)) return;
		$this->utf8_strlen = create_function('$text', 'return preg_match_all(
			"/[\\\\x00-\\\\xBF]|[\\\\xC0-\\\\xFF][\\\\x80-\\\\xBF]*/", 
			$text, $m);');
	}


	function unhash($text) {
	#
	# Swap back in all the tags hashed by _HashHTMLBlocks.
	#
		return preg_replace_callback('/(.)\x1A[0-9]+\1/', 
			array(&$this, '_unhash_callback'), $text);
	}
	function _unhash_callback($matches) {
		return $this->html_hashes[$matches[0]];
	}

}

/*

PHP Markdown
============

Description
-----------

This is a PHP translation of the original Markdown formatter written in
Perl by John Gruber.

Markdown is a text-to-HTML filter; it translates an easy-to-read /
easy-to-write structured text format into HTML. Markdown's text format
is most similar to that of plain text email, and supports features such
as headers, *emphasis*, code blocks, blockquotes, and links.

Markdown's syntax is designed not as a generic markup language, but
specifically to serve as a front-end to (X)HTML. You can use span-level
HTML tags anywhere in a Markdown document, and you can use block level
HTML tags (like <div> and <table> as well).

For more information about Markdown's syntax, see:

<http://daringfireball.net/projects/markdown/>


Bugs
----

To file bug reports please send email to:

<michel.fortin@michelf.com>

Please include with your report: (1) the example input; (2) the output you
expected; (3) the output Markdown actually produced.


Version History
--------------- 

See the readme file for detailed release notes for this version.


Copyright and License
---------------------

PHP Markdown
Copyright (c) 2004-2009 Michel Fortin  
<http://michelf.com/>  
All rights reserved.

Based on Markdown
Copyright (c) 2003-2006 John Gruber   
<http://daringfireball.net/>   
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

*	Redistributions of source code must retain the above copyright notice,
	this list of conditions and the following disclaimer.

*	Redistributions in binary form must reproduce the above copyright
	notice, this list of conditions and the following disclaimer in the
	documentation and/or other materials provided with the distribution.

*	Neither the name "Markdown" nor the names of its contributors may
	be used to endorse or promote products derived from this software
	without specific prior written permission.

This software is provided by the copyright holders and contributors "as
is" and any express or implied warranties, including, but not limited
to, the implied warranties of merchantability and fitness for a
particular purpose are disclaimed. In no event shall the copyright owner
or contributors be liable for any direct, indirect, incidental, special,
exemplary, or consequential damages (including, but not limited to,
procurement of substitute goods or services; loss of use, data, or
profits; or business interruption) however caused and on any theory of
liability, whether in contract, strict liability, or tort (including
negligence or otherwise) arising in any way out of the use of this
software, even if advised of the possibility of such damage.

*/
?><?php 
  return Markdown($raw);
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////


/** transforms a logical name to a real file containing the content */
function logical2physical($logical) {
  $physical = $logical.'.gakowiki'; // default value

  // set physical data file: strategy 1 the full name is given
  if (is_file($logical)) {
      $physical = $logical;
  }

  foreach(get_registered_extensions() as $k ) {
    if (is_file($logical.$k)) {
      return $logical.$k;
    }
  }
  return $physical;
}


/** sends a nice 404 page */
function send404() {


      // then return a nice 404
      header('HTTP/1.1 404 Not found');
      define('GAKOWIKI_TITLE','404 Not found');
      define('CONTENT', 'HTTP/1.1 404 Not found<br/>Do you want to create <a href="'.$_SERVER['SCRIPT_NAME'].'?page='.myurlencode(LOGICALNAME).'&amp;edit">'.LOGICALNAME.'</a>?');

  // well we could continue this way and output a nice 404 page
  // but then we would add the logical name to the list to
  // so let's die now
  die(CONTENT);
}

/** outputs the raw content */
function theme_default() {
  echo '<h1>'.getTitle().'</h1>';
  echo CONTENT;
}

/** puts the content of this wiki in an array logical => metadata */
function listWikiContent() {
  $result = array();
  global $listing_functions;
  foreach($listing_functions as $f) {
    $list_resources = $f();
    foreach($list_resources as $r) {
      $metadata = getAllMetaData($r); 
      if (!isset($metadata['visible']) || $metadata['visible']!='no') {
        $result[$r] = $metadata; 
      }
    }
  }
  return $result;
}

/** returns all pages with at least a metadata file */
function list_resources_with_metadata() {
  $result = array();
  foreach(glob(METADATADIR.'/*') as $k) {
    if (preg_match('/\/([^.\/]+)/',$k, $matches)) {
      $result[] = $matches[1];
    }
  }
  return $result;
}

/** returns all pages with a registered extension */
function list_resources_with_registered_extensions() {
  $result = array();
  foreach (get_registered_extensions() as $ext) {
  foreach (glob('*'.$ext) as $file) {
    // removing the ext
    if (preg_match('/^(.+)'.preg_quote($ext).'/',$file, $matches)) {
    $result[] = $matches[1];
    }
  }
  }
  return   $result; // a dictionnary name -> metadata
} // end function


/** gets a preview of a given resource */
function getPreview($logical) {
  $filename = logical2physical($logical);
  $content = strip_tags(getFormattedContent($logical));
  // m and s are important modifiers in this regular expression
  preg_match('/^.{0,300}\./ms', $content, $entries);
  if (count($entries)==0) return 'No preview available'; 
  $preview = $entries[0];
  return $preview;
}

/** outputs the 10 latest posts of this bliki */
function special_blog() {
  define('GAKOWIKI_TITLE', 'Last posts');
  $pages = listWikiContent();
  archives($pages, 10, true);
  echo '<a href="archives">Archives</a>';
}

/** outputs the list of pages of this bliki */
function special_meta() {
// historically, this is the very first extension point of gakowiki
global $content_functions;
echo '<h2>Getting the content of pages</h2>';  
foreach ($content_functions as $f) {
  echo '<div>';
  echo '<b>'.$f.'</b>: ';
  //$f_doc = $f.'_doc';
  //if (function_exists($f_doc)) { $f_doc(); }
  $funcdeclared = new ReflectionFunction($f);
  echo substr($funcdeclared->getDocComment(),3,-2);
  echo '</div>';
}


echo '<h2>Registered formats</h2>';  
foreach (get_registered_formats() as $f) {
  $funcdeclared = new ReflectionFunction($f.'_format');
  echo '<div>'.'<b>'.$f.'</b>'.substr($funcdeclared->getDocComment(),3,-2).'</div>';
}


global $listing_functions;
echo '<h2>Getting lists of pages</h2>';  
foreach ($listing_functions as $f) {
  $funcdeclared = new ReflectionFunction($f);
  echo '<div>'.'<b>'.$f.'</b>: '.substr($funcdeclared->getDocComment(),3,-2).'</div>';
}

echo '<h2>Registered extensions</h2>';  
foreach (get_registered_extensions() as $f) {
  echo '<div>';
  echo '<b>'.$f.'</b>';
  echo '</div>';  
}

global $metadata_functions;
echo '<h2>Getting metadata</h2>';  
foreach ($metadata_functions as $f) {
  //$f_doc = $f.'_doc';
  //if (function_exists($f_doc)) { $f_doc(); }
  $funcdeclared = new ReflectionFunction($f);
  echo '<div>'.'<b>'.$f.'</b>: '.substr($funcdeclared->getDocComment(),3,-2).'</div>';
}

global $url_building_functions;
echo '<h2>Transforming page names into URLs</h2>';  
foreach ($url_building_functions as $f) {
  echo '<b>'.$f.'</b>: ';
  //$f_doc = $f.'_doc';
  //if (function_exists($f_doc)) { $f_doc(); }
  $funcdeclared = new ReflectionFunction($f);
  echo '<div>'.substr($funcdeclared->getDocComment(),3,-2).'</div>';
  echo '<div>Example: '.$f('a page').'</div>';
  
}


}

/** outputs the list of pages of this bliki */
function special_archives() {
  @define('GAKOWIKI_TITLE', 'Archives');
  $pages = listWikiContent();
  archives($pages);
}

/** outputs the list of pages of this bliki */
function special_archives2() {
  @define('GAKOWIKI_TITLE', 'Archives');
  $pages = listWikiContent();
  header('Content-type: text/plain');
  foreach($pages as $k=>$v) echo 'http://www.monperrus.net/'.logical2url($k)."\n";
  exit;
}


/** returns true if there is more posts to handle (inspired from wordpress) */
function gk_have_posts() {
  global $archives_list, $archives_current;
  return $archives_current < count($archives_list)-1;
}

/** loads the next post (that can then be used with the_title(), the_content(); etc. */
function gk_the_post() {
  global $archives_list, $archives_current;
  $archives_current++;
}

/** transforms the $list of posts into HTML */
function archives($list, $max = -1, $with_preview = false) {
  $pages = array();
  foreach ($list as $metadata) {
    $pagename = $metadata['logical'];
    if (!isset($metadata['ctime'])) $ctime = mktime(0,0,0,1,1,1970);
    else     $ctime = $metadata['ctime'];
    $pages[$pagename] = $ctime;
  }
  arsort($pages);

  $n = count($pages);
  $n2=1;

  foreach($pages as $k=>$v) {
    $metadata = $list[$k];

    // determining the url
    $theurl = '404';
    if (isset($metadata['url'])) { $theurl = $metadata['url']; }
    else { $theurl = logical2url($k); }

    echo '<div class="archive-entry">';
    echo '<span class="archive-number">#'.($n--).'</span> <a class="archive-post-title" href="'.$theurl.'">'.getTitleMetadata($k).'</a> ';
    echo '(<span class="archive-date">'.getCreationTime2($k).'</span>)';
    if ( $with_preview ) {
        echo '<div class="archive-preview">'.getPreview($k).' <a href="'.$theurl.'">&gt;&gt;&gt; read more</a>'.'</div>';
    }
    echo '</div>'."\n";
    if ($max>0 && $n2 > $max) { break; }
    $n2++;
  }
}

/** returns the content of $logical (formatted) */
function getFormattedContent($logical = LOGICALNAME) {
  //echo $logical;
  $raw = getRawContent($logical);

  $format = getFormatMetadata($logical); 
  if ($format=='unset') {
    $format = 'gakowiki';
  }
  
  //echo $raw;
  return format($raw, $format);
}

/** formats the string given as parameter (e.g. transforms wiki text to HTML) */
function format($raw, $format = 'gakowiki') {

  $functionName = $format .'_format';  
  if (function_exists($functionName)) {
    return $functionName($raw);
  }
  else {
    return gakowiki_format($raw);
  }
}

/** gets the raw content of a resource (generally text with wiki markup) */
function getRawContent($logical) {
  global $content_functions;

  foreach($content_functions as $f) {
    $v = $f($logical);
    if ($v!=NULL) { return $v; } 
  }

  return NULL;
}

/** returns the content from files ending with certain extensions (meant to be registered with register_content_function) */
function get_content_based_on_extension($logical) {
  // set physical data file: strategy 2, for sake of nice urls, the extension is removed
  foreach(get_registered_extensions() as $k ) {
    if (is_file($logical.$k)) {
      $fun = substr($k,1).'_display';
      return $fun($logical.$k);
    }
  }
  return NULL;
}

/** returns the content from of $logical  (meant to be registered with register_content_function) */
function get_content_from_file($logical) {
  if (is_file($logical)) {
    return file_get_contents($logical);
  }
  return NULL;
}


/** sets the CONTENT constant */
function setCONTENT($logical = LOGICALNAME) {

  if (defined('CONTENT')) { 
    if (!defined('GAKOWIKI_TITLE')) { define('GAKOWIKI_TITLE', LOGICALNAME); }
    return;
  }

  // getting the contents of this resource
  $c= getFormattedContent($logical);

  if ($c!=NULL) {
   // now we may transform this content

    define('CONTENT',$c);
    return;
  }
  
  // otherwise
  send404(); 

}

/** defines the constant LOGICALNAME, which represents the name of the resource (usually its title) */
function define_LOGICALNAME() {
  // already defined
  if (defined('LOGICALNAME')) return;

  // $_GET['page'] has been decoded by Apache directly
  // but not utf-8 decoded
  if (isset($_GET['page']) && strlen($_GET['page'])>0) {
    if (get_magic_quotes_gpc()) $_GET['page']= stripslashes($_GET['page']);
    define('LOGICALNAME',$_GET['page']);
    return;
  } 

  define('LOGICALNAME',DEFAULTPAGE);
}

/** sets up the PHYSICALNAME parameters, PHYSICALNAME is the file name that contains the wikified info */
function define_PHYSICALNAME() {
if (!defined('LOGICALNAME')) { die ('precondition failed'); }

// the content is already loaded
if (defined('CONTENT')) {
  define('PHYSICALNAME','__memory__');
  return;
}

$physical = logical2physical(LOGICALNAME);
define('PHYSICALNAME',$physical);

}


/** builds URL with ?page= */
function url_building_basic($logical) {
  if (is_file($logical)) { return $logical; }
  return $_SERVER['SCRIPT_NAME'].'?page='.myurlencode($logical);
}

/** transforms a $logical id (a string) as an URL */
function logical2url($logical) {
  global $url_building_functions;
  foreach ($url_building_functions as $func) {
    $url = $func($logical);
    if ($url!=null && $url!='') {
      //echo $func." ".$logical."\n";
      return $url;
    }
  }
}

function get_metadata_for_tags($logical) {
  if (file_exists($logical.'.tag')) { 
    $result = array('format' => 'html', 'ctime'=>filemtime($logical.'.tag')); 
    return $result;
  }
  return null;
}

/** initializes everything that needs to be */
function init() {
  //register_listing_function('list_resources_with_registered_extensions');
  register_listing_function('list_resources_with_metadata');
  register_format('gakowiki');
  register_format('txt');
  register_format('html');
  register_format('markdown');
  register_url_building_function('url_building_basic');
  register_content_function('get_content_based_on_extension');
  register_metadata_function('get_metadata_for_tags');
  register_metadata_function('get_metadata_from_dir');

  define_LOGICALNAME();

  define_PHYSICALNAME();

}
/** dispatches calls w.r.t to $_GET*/
function main() {


  init();

  // is is a special page?
  if (function_exists('special_'.LOGICALNAME)) {
    $f = 'special_'.LOGICALNAME;
    $f();
    return;
  } 

  if (isset($_GET['save']) && isset($_POST['pagecontent'])) {  handle_save(); }  // handle_save exits
  else if (isset($_GET['edit'])) { handle_edit();} // handle_edit exits
  else if (isset($_GET['tag'])) { handle_tag();} // handle_tag exits
  else if (isset($_GET['untag'])) { handle_untag();} // handle_tag exits

  handle_read();  

}

/** gets some formatter content */
function handle_read() {
  // otherwise we are in read mode
  setCONTENT();
  if (defined('CONTENT'))
  {


    //header('X-gakowiki-content: yes');
    $theme = 'theme_'.get_theme();
    @header('Content-type: text/html; charset='.getEncoding());
    @header('X-gakowiki-theme: '.$theme);

    if (defined('THEME') && file_exists($theme.'.php')) {
      include($theme.'.php');
    }
    else if (function_exists($theme)) {
      $theme();
    }
  }
  else { echo 'no content defined'; }
}


/** returns the absolute URL of the CSS */ 
function get_css_url() {
    $theme_file = 'theme_'.get_theme().'.css';
    if (defined('THEME') && file_exists($theme_file)) {
       return GK_HOME_URL.$theme_file;
    }
    else return GK_HOME_URL.'gakowiki.css';
}


// the following parameters could be set in in gakowiki.local.php
// not that gakowiki works even if gakowiki.local.php is not present
@define('THEME','default');
@define('GK_WIKI_TITLE','Yet another gakowiki blog');
@define('GK_WIKI_DESCRIPTION','with no description');
@define('GK_HOME_URL','http://localhost/');
@define('DEFAULTPAGE','default');
@define('AUTHOR_NAME','admin');
@define('AUTHOR_URL','');
@define('TAGS','tags.json');
@define('METADATADIR','metadata/');


main();

?>