phpDocumentor phpDocumentor
[ class tree: phpDocumentor ] [ index: phpDocumentor ] [ all elements ]

Source for file IntermediateParser.inc

Documentation is available at IntermediateParser.inc

  1. <?php
  2. /**
  3.  * The phpDocumentor_IntermediateParser Class
  4.  *
  5.  * The Intermediary Data Parser (intermediate between Parse and Converter)
  6.  *
  7.  * phpDocumentor :: automatic documentation generator
  8.  * 
  9.  * PHP versions 4 and 5
  10.  *
  11.  * Copyright (c) 2002-2006 Gregory Beaver
  12.  * 
  13.  * LICENSE:
  14.  * 
  15.  * This library is free software; you can redistribute it
  16.  * and/or modify it under the terms of the GNU Lesser General
  17.  * Public License as published by the Free Software Foundation;
  18.  * either version 2.1 of the License, or (at your option) any
  19.  * later version.
  20.  * 
  21.  * This library is distributed in the hope that it will be useful,
  22.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  24.  * Lesser General Public License for more details.
  25.  * 
  26.  * You should have received a copy of the GNU Lesser General Public
  27.  * License along with this library; if not, write to the Free Software
  28.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29.  *
  30.  * @package    phpDocumentor
  31.  * @author     Gregory Beaver <[email protected]>
  32.  * @copyright  2002-2006 Gregory Beaver
  33.  * @license    http://www.opensource.org/licenses/lgpl-license.php LGPL
  34.  * @version    CVS: $Id: IntermediateParser.inc,v 1.16 2006/10/18 18:52:12 cellog Exp $
  35.  * @filesource
  36.  * @link       http://www.phpdoc.org
  37.  * @link       http://pear.php.net/PhpDocumentor
  38.  * @since      1.1
  39.  */
  40. /** The phpDocumentor_IntermediateParser Class
  41.  *
  42.  * This class performs the work of organizing raw data from the parser in the
  43.  * format of descendants of the {@link parserElement} class.  This is also where
  44.  * processing of package pages occurs, in
  45.  * {@link phpDocumentor_IntermediateParser::handleClass()} for class-level
  46.  * packages and {@link phpDocumentor_IntermediateParser::handleDocBlock()} for
  47.  * page-level packages.
  48.  *
  49.  * Most of the work of this parser goes to matching up
  50.  * DocBlocks with the elements that they are documenting.  Since DocBlocks are
  51.  * passed before the element they document, the last DocBlock is stored in
  52.  * {@link phpDocumentor_IntermediateParser::$last} and then placed into the
  53.  * $docblock parameter of the parserElement
  54.  * descendant object.
  55.  *  @author Gregory Beaver
  56.  *  @version $Id: IntermediateParser.inc,v 1.16 2006/10/18 18:52:12 cellog Exp $
  57.  *  @copyright 2002 Gregory Beaver
  58.  *  @package     phpDocumentor
  59.  */
  60. {
  61.     /**
  62.      * @var parserDocBlock 
  63.      */
  64.     var $last;
  65.     
  66.     /**
  67.      * type of the last parser Element handled
  68.      *
  69.      * This is used in handleDocBlock to determine whether a DocBlock is a
  70.      * page-level DocBlock in conjunction with the {@link parserData::$clean}
  71.      * var.  A page-level DocBlock is alwaysthe first DocBlock in a file, and
  72.      * must be followed by another DocBlock.  The first test is handled by
  73.      * parserData::$clean, which is set to false on the first encounter of an
  74.      * element, and the second test is handled by this variable, which must be
  75.      * equal to "docblock"
  76.      * @see handleDocBlock()
  77.      * @var string 
  78.      */
  79.     var $lasttype = '';
  80.     
  81.     /**
  82.      * Name of the class currently being parsed.
  83.      * It is only used (and only valid) when phpDocumentor_IntermediateParser is
  84.      * parsing a class
  85.      * @var string 
  86.      */
  87.     var $cur_class = '';
  88.     
  89.     /**
  90.      * type of the current parser Element being handled
  91.      * 
  92.      * This is used by {@link HandleEvent()} to set the {@link $lasttype} var,
  93.      * which is used to detect page-level DocBlocks
  94.      * @var string 
  95.      */
  96.     var $type = '';
  97.     
  98.     /**
  99.      * set in {@link Setup.inc.php} to the value of the parseprivate commandline
  100.      * option.  If this option is true, elements with an @access private tag
  101.      * will be parsed and displayed
  102.      * @tutorial phpDocumentor.howto.pkg#using.command-line.parseprivate
  103.      * @var boolean 
  104.      */
  105.     var $parsePrivate = false;
  106.     
  107.     /**
  108.      * this variable is used to prevent parsing of elements with an @ignore tag
  109.      * @see $packageoutput
  110.      * @see $parsePrivate
  111.      */
  112.     var $private_class = false;
  113.     
  114.     /**
  115.      * used to set the output directory
  116.      * @see setTargetDir()
  117.      */
  118.     var $targetDir;
  119.     
  120.     /**
  121.      * used to set the template base directory
  122.      * @see setTemplateBase()
  123.      */
  124.     var $templateBase;
  125.     
  126.     /**
  127.      * array of parsed package pages
  128.      *
  129.      * used by {@link Convert()} to convert all package pages into output
  130.      * @var array 
  131.      */
  132.     var $package_pages = array();
  133.     
  134.     /**
  135.      * @var array array of all {@link parserData} containing page information
  136.      */
  137.     var $pages = array();
  138.     /**
  139.      * Put away a page that has been @ignored or @access private if
  140.      * !{@link $parsePrivate}
  141.      *
  142.      * When a page has @access private in its DocBlock, it is placed here
  143.      * instead of in {@link $pages}, to allow for proper Class parsing.  Since
  144.      * classes and pages are parsed as if they were separate, this array allows
  145.      * public classes on private pages to retrieve information needed about the
  146.      * page that holds the class and to {@link addPageIfNecessary()} to the
  147.      * $pages array
  148.      * @var array 
  149.      */
  150.     var $privatepages = array();
  151.     /**
  152.      * Keeps track of packages of classes that have parent classes in another
  153.      * package.  Used in automatic linking.
  154.      *
  155.      * This array is updated by {@link addPackageParent()}, which is called in
  156.      * {@link Classes::processChild()} to keep track of classes that descend
  157.      * from classes in different packages.  In other words, if class foo is in
  158.      * package one, and class bar is in package two, an entry
  159.      * $package_parents['two'] = 'one' will be made.
  160.      * @var array Format: packagename => parentpackagename
  161.      * @see Converter::getLink()
  162.      */
  163.     var $package_parents = array();
  164.     
  165.     /**
  166.      * Used to determine the category for tutorials.
  167.      *
  168.      * <b>WARNING:</b> If more than one category exists, the last category
  169.      * encountered will overwrite the previous and will raise a big warning
  170.      * @var array Format: packagename => categoryname
  171.      */
  172.     var $packagecategories = array();
  173.     
  174.     /**
  175.      * list of all packages encountered while documenting.  Used in automatic
  176.      * linking.
  177.      * 
  178.      * Converter::getLink() first checks if an ambiguous link is found in the
  179.      * current package.  If not, it then checks in parent packages, and if still
  180.      * not found, uses this array to check in the rest of the packages before
  181.      * giving up
  182.      * @var array Format: array(packagename => 1, packagename => 1,...)
  183.      * @see Converter::getLink()
  184.      */
  185.     var $all_packages = array();
  186.     
  187.     /**
  188.      * array of packages to parser and output documentation for, if not all
  189.      * packages should be documented
  190.      *
  191.      * Format:<br />
  192.      * array(package1,package2,...)<br />
  193.      * or false if not set
  194.      *
  195.      * Use this option to limit output similar to ignoring files.  If you have
  196.      * some temporary files that you don't want to specify by name but don't
  197.      * want included in output, set a package name for all the elements in your
  198.      * project, and set packageoutput to that name.  the default package will be
  199.      * ignored.  Parsing speed does not improve.  If you want to ignore files
  200.      * for speed reasons, use the ignore command-line option
  201.      * @tutorial phpDocumentor.howto.pkg#using.command-line.packageoutput
  202.      * @see Io
  203.      * @var false|array
  204.      */
  205.     var $packageoutput = false;
  206.     
  207.     /**
  208.      * the functions which handle output from the {@link Parser}
  209.      * @see handleEvent(), handleDocBlock(), handlePage(), handleClass()
  210.      * @see handleDefine(), handleFunction(), handleMethod(), handleVar()
  211.      * @see handlePackagePage(), handleInclude(), handleTutorial()
  212.      */
  213.     var $event_handlers = array(
  214.             'docblock' => 'handleDocBlock',
  215.             'page' => 'handlePage',
  216.             'class' => 'handleClass',
  217.             'define' => 'handleDefine',
  218.             'function' => 'handleFunction',
  219.             'method' => 'handleMethod',
  220.             'var' => 'handleVar',
  221.             'const' => 'handleConst',
  222.             'packagepage' => 'handlePackagePage',
  223.             'include' => 'handleInclude',
  224.             'global' => 'handleGlobal',
  225.             'tutorial' => 'handleTutorial',
  226.             );
  227.     
  228.     /**
  229.      * $data contains parsed structures for the current page being parsed
  230.      *
  231.      * In version 1.1+, $data is only used to store the current page information.
  232.      * All handling of documented elements is handled by the
  233.      * {@link ProceduralPages} and {@link Classes} classes.
  234.      * @var parserData 
  235.      */
  236.     var $data;
  237.     
  238.     /**
  239.      * set in {@link Setup.inc.php} to the value of the quitemode commandline
  240.      * option.
  241.      *
  242.      * If this option is true, informative output while parsing will not be
  243.      * displayed (documentation is unaffected)
  244.      * @var boolean 
  245.      * @tutorial phpDocumentor.howto.pkg#using.command-line.quiet
  246.      */
  247.     var $quietMode = false;
  248.     
  249.     /**
  250.      * used to keep track of inheritance at the smartest level possible for a
  251.      * dumb computer
  252.      * @var Classes 
  253.      */
  254.     var $classes = false;
  255.     
  256.     /**
  257.      * used to keep track of all elements in a procedural page.  Handles name
  258.      * conflicts with elegance
  259.      * @since 1.1
  260.      * @var ProceduralPages 
  261.      */
  262.     var $proceduralpages = false;
  263.     
  264.     /**
  265.      * an array of template names indexed by converter name
  266.      *
  267.      * For example, if the default HTMLframesConverter is using the DOM/l0l33t
  268.      * template, the array will be
  269.      * <code>$converters['frames'] = 'DOM/l0l33t'</code>
  270.      * @var array Format: array(Convertername1 => templatename)
  271.      * @see Converter
  272.      */
  273.     var $converters = false;
  274.     /** 
  275.      * @var string Title of generated documentation, passed to Converters
  276.      */
  277.     var $title = '';
  278.     
  279.     var $uses = array();
  280.  
  281.     var $db_template;
  282.     
  283.     /**
  284.      * Stores parsed CHANGELOG/INSTALL/README files
  285.      * @var array Format: array(CHANGELOG => contents,
  286.      *                           INSTALL => contents,
  287.      *                           README => contents)
  288.      */
  289.     var $ric = array();
  290.     
  291.     /**
  292.      * Flag used to determine whether the last docblock
  293.      * was a page-level docblock.
  294.      * @var boolean 
  295.      * @access private
  296.      */
  297.     var $_lastDocBlockWasPageLevel false;
  298.     
  299.     /**
  300.      * Flag used to determine whether the Page-level
  301.      * DocBlock was declared in old or new style
  302.      * @var boolean 
  303.      * @access private
  304.      */
  305.     var $_oldPageLevel false;
  306.  
  307.     /**
  308.      * sets up basic data structures
  309.      * @param string Title of generated documentation, passed to Converters
  310.      * @see $title, $data, $classes, $proceduralpages
  311.      */
  312.     function phpDocumentor_IntermediateParser($title='Generated Documentation')
  313.     {
  314.         $this->title = $title;
  315.         $this->data = new parserData;
  316.         $this->classes = new Classes;
  317.         $this->proceduralpages = new ProceduralPages;
  318.     }
  319.     
  320.     /**
  321.      * Retrieve the relative path.  If the path contains "pear/" it will
  322.      * be used as the base, otherwise the Program_Root string will be used.
  323.      * @global array uses 'Program_Root' option to replace it with '' for
  324.      *                retrieving the source location of a file
  325.      * @param string path to file
  326.      * @return string 
  327.      * @see $sourceLocation
  328.      * @access private
  329.      */
  330.     function _getSourceLocation($sl$sourceloc)
  331.     {
  332.         global $_phpDocumentor_options;
  333.         if (empty($sl)) return false;
  334.         $sl str_replace('\\','/',$sl);
  335.         if (strpos($sl,'pear/'))
  336.         {
  337.             $sl substr($sl,strpos($sl,'pear/'5);
  338.             if (dirname($sl== '.')
  339.             {
  340.                 return 'PEAR';
  341.             }
  342.             return dirname($sl);
  343.         else
  344.         {
  345.             if (strpos(str_replace($_phpDocumentor_options['Program_Root'PATH_DELIMITER,'',$sourceloc),PATH_DELIMITER=== false)
  346.                 return '';
  347.             return dirname(str_replace($_phpDocumentor_options['Program_Root'PATH_DELIMITER,'',$sourceloc));
  348.         }
  349.     }
  350.     
  351.     /**
  352.      * Guess the package/subpackage based on subdirectory if the --pear option
  353.      *
  354.      * A file in pear/dir/file.php will be in package "dir."  A file in
  355.      * pear/dir/subdir/file.php will be in package "dir," subpackage "subdir."
  356.      * @param string full path of file
  357.      * @param template-ready source location Program_Root/dir/file.php
  358.      * @global array uses the 'pear' option to determine whether to guess based
  359.      *                on subdirectory
  360.      * @tutorial phpDocumentor.howto.pkg#using.command-line.pear
  361.      */
  362.     function _guessPackage($path$sourceloc)
  363.     {
  364.         global $_phpDocumentor_setting;
  365.         if ($_phpDocumentor_setting['pear'])
  366.         {
  367.             $subpath explode(PATH_DELIMITER$this->_getSourceLocation($path$sourceloc));
  368.             if (!empty($subpath[0]))
  369.             // can only have package and subpackage in this version
  370.                 $package $subpath[0];
  371.                 $subpackage '';
  372.                 if (isset($subpath[1])) $subpackage $subpath[1];
  373.                 return array($package,$subpackage);
  374.             else return array($this->package$this->subpackage);
  375.         else return array($this->package$this->subpackage);
  376.     }
  377.     
  378.     /**
  379.      * handles post-parsing of include/require/include_once/include_once
  380.      *
  381.      * This function sets {@link $data}->clean to false to tell the
  382.      * phpDocumentor_IntermediateParser that a page-level DocBlock can't be
  383.      * found after this point on this page.  It then sets the package
  384.      * to be the same as the page, and adds itself to the
  385.      * {@link ProceduralPages} class
  386.      * @param integer $event Event number from {@link Parser.inc}
  387.      * @param parserInclude $data 
  388.      */
  389.     function handleInclude($event,$data)
  390.     {
  391.         if ($this->_lastDocBlockWasPageLevel)
  392.         {
  393.             addWarning(PDERROR_DOCBLOCK_CONFLICT$data->getName()$data->getFile());
  394.             if (!$this->_oldPageLevel)
  395.             {
  396.                 unset($this->last);
  397.             }
  398.         }
  399.         $this->_lastDocBlockWasPageLevel =
  400.         $this->data->clean = false;
  401.         // page was @ignored
  402.         if ($this->private_page)
  403.         {
  404.             unset($this->last);
  405.             return;
  406.         }
  407.         if (empty($this->last))
  408.         {
  409.             if (isset($this->db_template))
  410.             // use the docblock template
  411.             $this->last = phpDocumentor_clone($this->db_template);
  412.             else
  413.             // we don't have a docblock, create an empty one to get rid of errors
  414.             $this->last = new parserDocblock();
  415.         }
  416. //        $this->last->setLineNumber($data->getLineNumber());
  417.         if ($this->last->getKeyword('ignore'))
  418.         {
  419.             $this->last = false;
  420.             return;
  421. //            addWarning(PDERROR_IGNORE_TAG_IGNORED,'include',$data->getName().'('.$data->getValue().')');
  422.         }
  423.  
  424.         $this->last->overridePackage($this->category,$this->package,$this->subpackage,$data->getName(),'include');
  425.         $data->setDocBlock($this->last);
  426.         $this->proceduralpages->addInclude($data);
  427.         $this->last = false;
  428.     }
  429.     
  430.     /**
  431.      * handles post-parsing of global variables
  432.      *
  433.      * This function sets {@link $data}->clean to false to tell the
  434.      * phpDocumentor_IntermediateParser that a page-level DocBlock can't be
  435.      * found after this point on this page.  It then sets the package
  436.      * to be the same as the page, and adds itself to the
  437.      * {@link ProceduralPages} class
  438.      * @param integer $event Event number from {@link Parser.inc}
  439.      * @param parserGlobal $data 
  440.      */
  441.     function handleGlobal($event,$data)
  442.     {
  443.         if ($this->_lastDocBlockWasPageLevel)
  444.         {
  445.             addWarning(PDERROR_DOCBLOCK_CONFLICT'global variable'$data->getName());
  446.             if (!$this->_oldPageLevel)
  447.             {
  448.                 unset($this->last);
  449.             }
  450.         }
  451.         $this->_lastDocBlockWasPageLevel =
  452.         $this->data->clean = false;
  453.         if ($this->private_page)
  454.         {
  455.             unset($this->last);
  456.             return;
  457.         }
  458.         if (empty($this->last))
  459.         {
  460.             if (isset($this->db_template))
  461.             // use the docblock template
  462.             $this->last = phpDocumentor_clone($this->db_template);
  463.             else
  464.             // we don't have a docblock, create an empty one to get rid of errors
  465.             $this->last = new parserDocblock();
  466.         }
  467. //        $this->last->setLineNumber($data->getLineNumber());
  468.         if ($this->last->getKeyword('ignore'))
  469.         {
  470.             addWarning(PDERROR_IGNORE_TAG_IGNORED,'global variable - just don\'t document the',$data->getName());
  471.             $this->last = false;
  472.             return;
  473.         }
  474.         $this->last->overridePackage($this->category,$this->package,$this->subpackage,$data->getName(),'global');
  475.         $data->setDocBlock($this->last);
  476.         if ($data->docblock->getKeyword('name'))
  477.         {
  478.             $a $data->docblock->getKeyword('name');
  479.             if (is_object($a)) $a $a->value;
  480.             $data->setName($a);
  481.         }
  482.         $this->proceduralpages->addGlobal($data);
  483.         $this->last = false;
  484.     }
  485.     
  486.     /**
  487.      * handles post-parsing of Package-level documentation pages.
  488.      *
  489.      * sets the {@link $package_pages}[$data->package] to $data
  490.      * @param integer $event Event number from {@link Parser.inc}
  491.      * @param parserPackagePage $data 
  492.      */
  493.     function handlePackagePage($event,$data)
  494.     {
  495.         $this->package_pages[$data->package&$data;
  496.         $this->last = false;
  497.     }
  498.     
  499.     /**
  500.      * handle post-parsing of Tutorials.
  501.      *
  502.      * This adds the parsed tutorial to the tutorial tree
  503.      * @uses $tutorials sets the value of tutorials to parameter $data
  504.      * @param integer $event Event Number
  505.      * @param parserTutorial $data 
  506.      * @since 1.2
  507.      */
  508.     function handleTutorial($event,$data)
  509.     {
  510.         if (isset($this->packagecategories[$data->package]))
  511.         {
  512.             $data->category $this->packagecategories[$data->package];
  513.         else
  514.         {
  515.             $data->category $GLOBALS['phpDocumentor_DefaultCategoryName'];
  516.         }
  517.         $this->tutorials[$data->package][$data->subpackage][$data->tutorial_type][$data->name$data;
  518.     }
  519.     
  520.     /**
  521.      * handles post-parsing of class vars
  522.      *
  523.      * This function sets up a @var tag if none is found, and aligns $data's
  524.      * $path var and packages to match the parent object
  525.      * @param integer $event Event number from {@link Parser.inc}
  526.      * @param parserVar $data 
  527.      */
  528.     function handleVar($event,$data)
  529.     {
  530.         global $_phpDocumentor_setting;
  531.         if ($this->private_class)
  532.         {
  533.             unset($this->last);
  534.             return;
  535.         }
  536.         if (empty($this->last))
  537.         {
  538.             if (isset($this->db_template))
  539.             {
  540.                 // use the docblock template
  541.                 $this->last = phpDocumentor_clone($this->db_template);
  542.             else {
  543.                 // we don't have a docblock, create an empty one to get rid of errors
  544.                 $this->last = new parserDocblock();
  545.             }
  546.         }
  547. //        $this->last->setLineNumber($data->getLineNumber());
  548.         $this->last->overridePackage($this->category,$this->package,$this->subpackage,$data->getName(),'var');
  549.         $this->last->updateModifiers($data->getModifiers());
  550.  
  551.         if ($this->last->getKeyword('ignore'))
  552.         {
  553.             $this->last = false;
  554.             return;
  555. //            addWarning(PDERROR_IGNORE_TAG_IGNORED,'var',$this->cur_class.'::'.$data->getName());
  556.         }
  557.         if (!$this->last->var)
  558.         {
  559.             $this->last->addVar('mixed',new parserStringWithInlineTags);
  560.         }
  561.         
  562.         if ($_phpDocumentor_setting['pear'])
  563.         {
  564.             if (strpos($data->getName()'_'== && !$this->last->getKeyword('access'))
  565.             {
  566.                 addWarning(PDERROR_PRIVATE_ASSUMED,'class variable',$data->class.'::'.$data->getName());
  567.                 $this->last->addKeyword('access','private');
  568.                 $data->setDocBlock($this->last);
  569.             }
  570.         }
  571.         $data->setDocBlock($this->last);
  572.         $data->path $this->data->parent->path;
  573.         $this->classes->addVar($data);
  574.         $this->last = false;
  575.     }
  576.     
  577.     /**
  578.      * handles post-parsing of class constants
  579.      *
  580.      * This function aligns $data's
  581.      * $path var and packages to match the parent object
  582.      * @param integer $event Event number from {@link Parser.inc}
  583.      * @param parserVar $data 
  584.      */
  585.     function handleConst($event,$data)
  586.     {
  587.         global $_phpDocumentor_setting;
  588.         if ($this->private_class)
  589.         {
  590.             unset($this->last);
  591.             return;
  592.         }
  593.         if (empty($this->last))
  594.         {
  595.             if (isset($this->db_template))
  596.             // use the docblock template
  597.             $this->last = phpDocumentor_clone($this->db_template);
  598.             else
  599.             // we don't have a docblock, create an empty one to get rid of errors
  600.             $this->last = new parserDocblock();
  601.         }
  602. //        $this->last->setLineNumber($data->getLineNumber());
  603.         $this->last->overridePackage($this->category,$this->package,$this->subpackage,$data->getName(),'const');
  604.  
  605.         if ($this->last->getKeyword('ignore'))
  606.         {
  607.             $this->last = false;
  608.             return;
  609. //            addWarning(PDERROR_IGNORE_TAG_IGNORED,'var',$this->cur_class.'::'.$data->getName());
  610.         }
  611.         $data->setDocBlock($this->last);
  612.         $data->path $this->data->parent->path;
  613.         $this->classes->addConst($data);
  614.         $this->last = false;
  615.     }
  616.     
  617.     /**
  618.      * handles post-parsing of class methods
  619.      *
  620.      * This function first aligns $data's path and package to match the parent
  621.      * object, and also aligns the docblock's @param, @global, and @staticvar
  622.      * tags with the information parsed from the method source code.  It also
  623.      * checks to see if the method is a constructor and sets the $isConstructor
  624.      * flag.  If source code has been parsed by a {@}source} tag, the source is
  625.      * added to its docblock
  626.      *
  627.      * Finally, it adds the method to the {@link Classes} class.
  628.      * @param integer $event Event number from {@link Parser.inc}
  629.      * @param parserMethod $data 
  630.      */
  631.     function handleMethod($event,$data)
  632.     {
  633.         global $_phpDocumentor_setting;
  634.         if ($this->private_class)
  635.         {
  636.             unset($this->last);
  637.             return;
  638.         }
  639.  
  640.         if (empty($this->last))
  641.         {
  642.             if (isset($this->db_template))
  643.             // use the docblock template
  644.             $this->last = phpDocumentor_clone($this->db_template);
  645.             else
  646.             // we don't have a docblock, create an empty one to get rid of errors
  647.             $this->last = new parserDocblock();
  648.         }
  649. //        $this->last->setLineNumber($data->getLineNumber());
  650.         if ($this->last->getKeyword('ignore'))
  651.         {
  652.             $this->last = false;
  653.             return;
  654. //            addWarning(PDERROR_IGNORE_TAG_IGNORED,'method',$this->cur_class.'::'.$data->getName());
  655.         }
  656.         $this->last->overridePackage($this->category,$this->package,$this->subpackage,$data->getName(),'method');
  657.         if ($data->hasSource())
  658.         {
  659.             $this->last->setSource($data->getSource()$data->getClass());
  660.         }
  661.         foreach($data->listParams(as $key => $param)
  662.         {
  663.             $update_params[$key$param;
  664.         }
  665.         foreach($data->listGlobals(as $param)
  666.         {
  667.             $update_globals[$param[1];
  668.         }
  669.         foreach($data->listStatics(as $param)
  670.         {
  671.             $update_statics[$param[0];
  672.         }
  673.         if (isset($update_params))
  674.         $this->last->updateParams($update_params);
  675.         if (isset($update_globals))
  676.         $this->last->updateGlobals($update_globals);
  677.         if (isset($update_statics))
  678.         $this->last->updateStatics($update_statics);
  679.         $this->last->updateModifiers($data->getModifiers());
  680.         unset($update_params);
  681.         unset($update_globals);
  682.         unset($update_statics);
  683.  
  684.         if ($data->getName(== $this->cur_class$data->setConstructor();
  685.         if ($data->getName(== '__construct'{
  686.             $data->setConstructor();
  687.         }
  688.         if ($data->getName(== '__destruct'{
  689.             $data->setDestructor();
  690.         }
  691.  
  692.         if ($_phpDocumentor_setting['pear'])
  693.         {
  694.             if (strpos($data->getName()'_'=== && substr($data->getName()1== $data->class)
  695.             // is destructor
  696.                 $data->setDestructor();
  697.             elseif (strpos($data->getName()'_'=== && !$this->last->getKeyword('access'))
  698.             {
  699.                 if (strpos($data->getName()'__'!== 0{
  700.                     addWarning(PDERROR_PRIVATE_ASSUMED,'method',$data->class.'::'.$data->getName().'()');
  701.                     $this->last->addKeyword('access','private');
  702.                     $data->setDocBlock($this->last);
  703.                 }
  704.             }
  705.         }
  706.         $data->setDocBlock($this->last);
  707.         $data->path $this->data->parent->path;
  708.         $this->classes->addMethod($data);
  709.         $this->last = false;
  710.     }
  711.  
  712.     /**
  713.      * handles post-parsing of functions
  714.      *
  715.      * This function sets {@link $data}->clean to false to tell the
  716.      * phpDocumentor_IntermediateParser that a page-level DocBlock can't be
  717.      * found after this point on this page.  It then sets the package to be the
  718.      * same as the page, aligns the docblock's @param, @global, and @staticvar
  719.      * tags with the information parsed from the function source code.
  720.      *
  721.      * If source code has been parsed by a {@}source} tag, the source is added
  722.      * to its docblock, and then the parserFunction adds itself to the
  723.      * {@link ProceduralPages} class
  724.      * @param integer $event Event number from {@link Parser.inc}
  725.      * @param parserFunction $data 
  726.      */
  727.     function handleFunction($event,$data)
  728.     {
  729.         if ($this->_lastDocBlockWasPageLevel)
  730.         {
  731.             addWarning(PDERROR_DOCBLOCK_CONFLICT'function'$data->getName());
  732.             if (!$this->_oldPageLevel)
  733.             {
  734.                 unset($this->last);
  735.             }
  736.         }
  737.         $this->_lastDocBlockWasPageLevel =
  738.         $this->data->clean = false;
  739.         if ($this->private_page)
  740.         {
  741.             unset($this->last);
  742.             return;
  743.         }
  744.  
  745.         if (empty($this->last))
  746.         {
  747.             if (isset($this->db_template))
  748.             // use the docblock template
  749.             $this->last = phpDocumentor_clone($this->db_template);
  750.             else
  751.             // we don't have a docblock, create an empty one to get rid of errors
  752.             $this->last = new parserDocblock();
  753.         }
  754. //        $this->last->setLineNumber($data->getLineNumber());
  755.         if ($this->last->getKeyword('ignore'))
  756.         {
  757.             unset($this->last);
  758.             return;
  759.         }
  760.         $this->last->overridePackage($this->category,$this->package,$this->subpackage,$data->getName(),'function');
  761.  
  762.         foreach($data->listParams(as $key => $param)
  763.         {
  764.             $update_params[$key$param;
  765.         }
  766.         foreach($data->listGlobals(as $param)
  767.         {
  768.             $update_globals[$param[1];
  769.         }
  770.         foreach($data->listStatics(as $param)
  771.         {
  772.             $update_statics[$param[0];
  773.         }
  774.         if (isset($update_params))
  775.         $this->last->updateParams($update_params);
  776.         if (isset($update_globals))
  777.         $this->last->updateGlobals($update_globals);
  778.         if (isset($update_statics))
  779.         $this->last->updateStatics($update_statics);
  780.         unset($update_params);
  781.         unset($update_globals);
  782.         unset($update_statics);
  783.  
  784.         if ($data->hasSource())
  785.         {
  786.             $this->last->setSource($data->getSource());
  787.         }
  788.         if (count($this->last->params== && !count($data->listParams()))
  789.         {
  790.             // if the function has no parameters, and 1 @param, add it to the list as optional, default value is description from @param
  791.             $pars $this->last->listParams();
  792.             $data->addParam($pars[0]['var'],$pars[0]['data']->getString());
  793.         }
  794.         $data->setDocBlock($this->last);
  795.         $this->proceduralpages->addFunction($data);
  796.         $this->last = false;
  797.     }
  798.     
  799.     /**
  800.      * handles post-parsing of defines
  801.      *
  802.      * This function sets {@link $data}->clean to false to tell the
  803.      * phpDocumentor_IntermediateParser that a page-level DocBlock can't be
  804.      * found after this point on this page.  It then sets the package to be the
  805.      * same as the page and adds itself to the {@link ProceduralPages} class
  806.      * @param integer $event Event number from {@link Parser.inc}
  807.      * @param parserDefine $data 
  808.      */
  809.     function handleDefine($event,$data)
  810.     {
  811.         if ($this->_lastDocBlockWasPageLevel)
  812.         {
  813.             addWarning(PDERROR_DOCBLOCK_CONFLICT'define'$data->getName());
  814.             if (!$this->_oldPageLevel)
  815.             {
  816.                 unset($this->last);
  817.             }
  818.         }
  819.         $this->_lastDocBlockWasPageLevel =
  820.         $this->data->clean = false;
  821.         if ($this->private_page)
  822.         {
  823.             unset($this->last);
  824.             return;
  825.         }
  826.         if (empty($this->last))
  827.         {
  828.             if (isset($this->db_template))
  829.             // use the docblock template
  830.             $this->last = phpDocumentor_clone($this->db_template);
  831.             else
  832.             // we don't have a docblock, create an empty one to get rid of errors
  833.             $this->last = new parserDocblock();
  834.         }
  835. //        $this->last->setLineNumber($data->getLineNumber());
  836.         if ($this->last->getKeyword('ignore'))
  837.         {
  838.             unset($this->last);
  839.             return;
  840.         }
  841.  
  842.         $this->last->overridePackage($this->category,$this->package,$this->subpackage,$data->getName(),'define');
  843.         $data->setDocBlock($this->last);
  844.         $this->proceduralpages->addDefine($data);
  845.         $this->last = false;
  846.     }
  847.     
  848.     /**
  849.      * handles post-parsing of classes
  850.      *
  851.      * This function sets {@link $data}->clean to false to tell the
  852.      * phpDocumentor_IntermediateParser that a page-level DocBlock can't be
  853.      * found after this point on this page.  It sets {@link $cur_class} to its
  854.      * name, and if an @ignore tag is found in the DocBlock, it sets
  855.      * {@link $private_class} to true, to prevent post-parsing of any of the
  856.      * class's vars or methods.  Then it checks for the existence of a package
  857.      * page for the class's package
  858.      * @param integer $event Event number from {@link Parser.inc}
  859.      * @param parserClass $data 
  860.      */
  861.     function handleClass($event,$data)
  862.     {
  863.         global $_phpDocumentor_setting;
  864.         if ($this->_lastDocBlockWasPageLevel)
  865.         {
  866.             if (!$this->_oldPageLevel)
  867.             {
  868.                 addWarning(PDERROR_DOCBLOCK_GOES_CLASS$data->getName());
  869.                 $doc new parserDocBlock;
  870.                 $doc->category $this->category;
  871.                 $doc->package $this->package;
  872.                 $doc->subpackage $this->subpackage;
  873.                 if ($_phpDocumentor_setting['sourcecode']{
  874.                     $doc->canSource();
  875.                     $doc->addFileSource($this->data->parent->path$this->data->parent->source);
  876.                 }
  877.                 $this->data->setDocBlock($doc);
  878.                 unset($doc);
  879.                 if ($this->last{
  880.                     $this->last->cantSource();
  881.                 }
  882.             }
  883.         }
  884.         $this->_lastDocBlockWasPageLevel =
  885.         $this->data->clean = false;
  886.         if (empty($this->last))
  887.         {
  888.             if (isset($this->db_template))
  889.             // use the docblock template
  890.             $this->last = phpDocumentor_clone($this->db_template);
  891.             else
  892.             // we don't have a docblock, create an empty one to get rid of errors
  893.             $this->last = new parserDocblock();
  894.             list($this->last->package$this->last->subpackage$this->_guessPackage($this->data->parent->path$this->data->parent->getSourceLocation('dummy'));
  895.             addWarning(PDERROR_NO_PACKAGE_TAG,'class',$data->getName(),$this->last->package);
  896.         else
  897.         {
  898.             if (!$this->last->getExplicitPackage())
  899.             {
  900.                 list($this->last->package$this->last->subpackage$this->_guessPackage($this->data->parent->path$this->data->parent->getSourceLocation('dummy'));
  901.                 addWarning(PDERROR_NO_PACKAGE_TAG,'class',$data->getName(),$this->last->package);
  902.             else
  903.             {
  904.                 if (isset($this->packagecategories[$this->package])
  905.                     && $this->packagecategories[$this->package!= $this->category)
  906.                     addWarning(PDERROR_PACKAGECAT_SET,$this->package,
  907.                                 $this->packagecategories[$this->package],
  908.                                 $this->category);
  909.                 $this->packagecategories[$this->package$this->category;
  910.             }
  911.         }
  912.         $this->last->updateModifiers($data->getModifiers());
  913. //        $this->last->setLineNumber($data->getLineNumber());
  914.         $data->setDocBlock($this->last);
  915.         $this->cur_class = $name $data->getName();
  916.         if ($this->last->getKeyword('ignore'))
  917.         {
  918.             $this->private_class = true;
  919.             unset($this->last);
  920.             return;
  921.         }
  922.         $data->path $this->data->parent->path;
  923.         $this->classes->addClass($data);
  924.         $this->private_class = false;
  925.         if ($this->last->package)
  926.         {
  927.             $this->parsePackagePage($this->last->package$this->data->parent->getPath());
  928.         }
  929.         $this->last = false;
  930.     }
  931.     
  932.     /**
  933.      * handles post-parsing of procedural pages
  934.      *
  935.      * this event is called at the start of a new page, before the Parser knows
  936.      * whether the page will contain any procedural pages or not
  937.      * @param integer $event Event number from {@link Parser.inc}
  938.      * @param parserPage $data 
  939.      */
  940.     function handlePage($event,$data)
  941.     {
  942.         $type 'page';
  943.         $this->private_page false;
  944.         $this->data = new parserData;
  945.         $data->category $this->category $GLOBALS['phpDocumentor_DefaultCategoryName'];
  946.         $this->package $GLOBALS['phpDocumentor_DefaultPackageName'];
  947.         $this->subpackage '';
  948.         $this->proceduralpages->addPage($data);
  949.         $this->data->setParent($data);
  950.         $this->pages[$data->getPath()$this->data;
  951.         $this->classes->nextFile($data->getPath());
  952.         $this->packageoutput = $data->getPackageOutput();
  953.     }
  954.     
  955.     /**
  956.      * handles post-parsing of DocBlocks
  957.      *
  958.      * This function sets {@link $last} to the DocBlock represented by $data, to
  959.      * allow the next documentable element passed to
  960.      * phpDocumentor_IntermediateParser to link the DocBlock into its $docblock
  961.      * property.  This function also checks for two special cases of DocBlocks:
  962.      * <ol>
  963.      *    <li>First DocBlock in the file contains a @package tag</li>
  964.      *    <li>First DocBlock in the file is immediately followed by another
  965.      *        DocBlock</li>
  966.      * </ol>
  967.      * In both cases, the function extracts this tag and uses it as the
  968.      * page-level package.  If the @package tag is in the DocBlock of an
  969.      * element (function, global variable, whatever) that isn't a page-level
  970.      * DocBlock, a warning will be raised to notify the author that a @package
  971.      * tag belongs in a page-level DocBlock.
  972.      *
  973.      * <b>New</b> in version 1.2.2, if the first DocBlock in a file contains
  974.      * a @package tag, it is a page-level DocBlock.
  975.      *
  976.      * If the DocBlock is page-level, it is processed with
  977.      * {@link _processPageLevelDocBlock}
  978.      *
  979.      * Finally, the function replaces the old parserPage in
  980.      * {@link parserData::$data}->parent with the new one containing information
  981.      * from the DocBlock by calling {@link addPage()}, and checks for
  982.      * package-level docs.
  983.      * @param integer $event Event number from {@link Parser.inc}
  984.      * @param parserDocBlock $data 
  985.      */
  986.     function handleDocBlock($event,$data)
  987.     {
  988.         $type 'docblock';
  989.         $data->postProcess();
  990.         // Zend desc support
  991.         if ($tdesc $data->getKeyword('desc'))
  992.         {
  993.             $data->setShortDesc($tdesc);
  994.             unset($data->tags['desc']);
  995.         }
  996.         $this->_lastDocBlockWasPageLevel false;
  997.         // 1st docblock in file, check for @package
  998.         if ($this->data->isClean(&& !isset($this->last))
  999.         {
  1000.             if ($data->getExplicitPackage())
  1001.             {
  1002.                 // new with 1.2.2:
  1003.                 // if the first docblock in a file
  1004.                 // contains a @package tag, then it is
  1005.                 // a page-level docblock
  1006.                 $this->_processPageLevelDocBlock($data);
  1007.                 $this->_lastDocBlockWasPageLevel true;
  1008.                 $this->all_packages[$data->package1;
  1009.                 $this->last = $data;
  1010.                 return;
  1011.             }
  1012.             $doc new parserDocBlock;
  1013.             $doc->category $this->category;
  1014.             $doc->package $this->package;
  1015.             $doc->subpackage $this->subpackage;
  1016.             $this->data->setDocBlock($doc);
  1017.             $this->proceduralpages->addPagePackage($this->data->parent->getPath(),$this->package,$this->subpackage);
  1018.             unset($doc);
  1019.         }
  1020.         // 2nd docblock in a row, and it's at the top of the file, page-level docblock
  1021.         if ($this->lasttype == "docblock" && $this->data->isClean())
  1022.         {
  1023.             $this->_processPageLevelDocBlock($this->last);
  1024.             $this->_oldPageLevel true;
  1025.             $this->_lastDocBlockWasPageLevel false;
  1026.         }
  1027.         $this->all_packages[$data->package1;
  1028.         $this->last = $data;
  1029.     }
  1030.     
  1031.     /**
  1032.      * Process a Page-level DocBlock
  1033.      *
  1034.      * First, it checks for an @ignore tag,
  1035.      * and if found, calls {@link ProceduralPages::ignorePage()}.  An @ignore
  1036.      * tag in a page-level DocBlock will ignore all functions, defines, global
  1037.      * variables, and includes.  It will not ignore classes!  The function next
  1038.      * checks for an @access private, and if --parseprivate is off, performs the
  1039.      * same actions as @ignore.
  1040.      * Next, it checks for the @name tag, which is used to rename the page.
  1041.      * This is also a PEAR compatibility issue, and may not be very useful in
  1042.      * the long run.  Documentation is best when it refers to real entities in
  1043.      * the package, and not to aliases.
  1044.      * @access private
  1045.      */
  1046.     function _processPageLevelDocBlock($data)
  1047.     {
  1048.         global $_phpDocumentor_setting;
  1049.         // can only have 1 package-level docblock, others are ignored
  1050.         if (!$this->data->isClean())
  1051.         {
  1052.             return;
  1053.         }
  1054.         $this->data->clean = false;
  1055.         $this->data->explicitDocBlock();
  1056.         $data->canSource();
  1057.         if ($_phpDocumentor_setting['sourcecode'])
  1058.         {
  1059.             $data->addFileSource($this->data->parent->path$this->data->parent->source);
  1060.         }
  1061.         if (!$data->getExplicitPackage())
  1062.         {
  1063.             list($data->package,$data->subpackage$this->_guessPackage($this->data->parent->getPath()$this->data->parent->getSourceLocation('dummy'));
  1064.             addWarning(PDERROR_NO_PACKAGE_TAG,'file',$this->data->parent->getPath(),$this->last->package);
  1065.         }
  1066.         if (isset($this->packagecategories[$this->package])
  1067.             && $this->packagecategories[$this->package!= $this->category)
  1068.             addWarning(PDERROR_PACKAGECAT_SET,$this->package,
  1069.                         $this->packagecategories[$this->package],
  1070.                         $data->category);
  1071.         $this->packagecategories[$this->package$data->category;
  1072.         $this->category $this->data->parent->category $data->category;
  1073.         $this->packagecategories[$this->package$this->category;
  1074.         $this->subpackage $this->data->parent->subpackage $data->subpackage;
  1075.         $this->data->setDocBlock($data);
  1076.         if ($data->getKeyword('ignore'))
  1077.         {
  1078.             $this->proceduralpages->ignorePage($this->data->parent);
  1079.             $this->private_page true;
  1080.             unset($this->last);
  1081.             $this->privatepages[$this->data->parent->getPath()$this->data;
  1082.             unset($this->pages[$this->data->parent->getPath()]);
  1083.             return;
  1084.         }
  1085.         $this->package $this->data->parent->package $data->package;
  1086.         $this->subpackage $this->data->parent->subpackage $data->subpackage;
  1087.         $this->proceduralpages->addPagePackage($this->data->parent->getPath(),$this->package,$this->subpackage);
  1088.         if ($access $data->getKeyword('access'))
  1089.         {
  1090.             if (is_object($access&& ($access->getString(== 'private'&& (!$this->parsePrivate))
  1091.             {
  1092.                 $this->proceduralpages->ignorePage($this->data->parent);
  1093.                 $this->private_page true;
  1094.                 unset($this->last);
  1095.                 $this->privatepages[$this->data->parent->getPath()$this->data;
  1096.                 unset($this->pages[$this->data->parent->getPath()]);
  1097.                 return;
  1098.             }
  1099.         }
  1100.         if ($data->getKeyword('name'))
  1101.         {
  1102.             $a $data->getKeyword('name');
  1103.             if (is_object($a)) $a $a->value;
  1104.             $this->data->parent->setFile($a);
  1105.             $this->proceduralpages->setName($a);
  1106.         }
  1107.         $this->addPage($this->data->parent$this->data->parent->getPath());
  1108.         if ($this->package)
  1109.         {
  1110.             $this->parsePackagePage($this->package$this->data->parent->getPath());
  1111.         }
  1112.     }
  1113.     
  1114.     /**
  1115.      * Backward-compatibility only, use the new tutorials for more power
  1116.      * @tutorial tutorials.pkg
  1117.      * @param string package name of package file to parse
  1118.      * @param string directory of file that contains package name
  1119.      */
  1120.     function parsePackagePage($package$path)
  1121.     {
  1122.         if (!isset($this->package_pages[$package]))
  1123.         {
  1124.             if (file_exists(dirname($pathSMART_PATH_DELIMITER $package '.html'))
  1125.             {
  1126.                 if ($this->quietMode === false)
  1127.                 {
  1128.                     phpDocumentor_out("Reading package-level file ".$package '.html');
  1129.                           flush();
  1130.                 }
  1131.                 $fp fopen(dirname($pathSMART_PATH_DELIMITER $package '.html',"r");
  1132.                 $ret fread($fp,filesize(dirname($pathSMART_PATH_DELIMITER $package '.html'));
  1133.                 fclose($fp);
  1134.                 unset($fp);
  1135.                 if ($this->quietMode === false)
  1136.                 {
  1137.                     phpDocumentor_out(" -- Parsing File\n");
  1138.                           flush();
  1139.                 }
  1140.                 $pageParser new ppageParser;
  1141.                 $tempp $this->package;
  1142.                 $lp $this->last;
  1143.                 $pageParser->subscribe('*',$this);
  1144.                 $pageParser->parse($ret,false,$package);
  1145.                 $this->package $tempp;
  1146.                 $this->last = $lp;
  1147.                 unset($tempp);
  1148.                 unset($pageParser);
  1149.             }
  1150.         }
  1151.     }
  1152.     
  1153.     /**
  1154.      * called via {@link Parser::parse()} and Parser's inherited method
  1155.      * {@link Publisher::publishEvent()}
  1156.      *
  1157.      * $event is one of the PHPDOC constants from Parser.inc.  If it is not
  1158.      * PHPDOCUMENTOR_EVENT_NEWSTATE, then a function name is retrieved from the
  1159.      * {@link $event_handlers} array and called to handle the $data
  1160.      * @param integer $event event number from {@link Parser.inc}
  1161.      * @param mixed $data if $event is {@link PHPDOCUMENTOR_EVENT_NEWSTATE}, $data is a {@link PHP_DOC_EVENT_END_PAGE} or {@link STATE_END_CLASS},
  1162.      *                     otherwise $data is either a {@link parserDocBlock}{@link parserPage} or descendant of {@link parserElement}
  1163.      * @global array we use 'sourcecode' to determine whether to highlight the source
  1164.      *                of the current file if it has no file-level docblock
  1165.      */
  1166.     function HandleEvent($event,$data)
  1167.     {
  1168.         global $_phpDocumentor_setting;
  1169.         if (empty($this->packagecategories))
  1170.         $this->packagecategories[$phpDocumentor_DefaultPackageName$phpDocumentor_DefaultCategoryName;
  1171.         if ($event == PHPDOCUMENTOR_EVENT_NEWSTATE)
  1172.         {
  1173.             if ($data == STATE_END_CLASS)
  1174.             {
  1175.             elseif ($data == PHPDOCUMENTOR_EVENT_END_PAGE)
  1176.             {
  1177.                 if (!$this->private_page)
  1178.                 {
  1179.                     $this->all_packages[$this->package1;
  1180.                     if (!$this->data->hasExplicitDocBlock())
  1181.                     {
  1182.                         $doc $this->data->docblock;
  1183.                         if (!$this->data->docblock)
  1184.                         {
  1185.                             $doc new parserDocBlock;
  1186.                         }
  1187.                         if ($_phpDocumentor_setting['sourcecode'])
  1188.                         {
  1189.                             $doc->canSource();
  1190.                             $doc->addFileSource($this->data->parent->path$this->data->parent->source);
  1191.                         }
  1192.                         list($doc->package,$doc->subpackage$this->_guessPackage($this->data->parent->getPath()$this->data->parent->getSourceLocation('dummy'));
  1193.                         addWarning(PDERROR_NO_PAGE_LEVELDOCBLOCK,$this->data->parent->getPath());
  1194.                         $this->data->setDocBlock($doc);
  1195.                         $this->proceduralpages->addPage($this->data->parent,$doc->package,$doc->subpackage);
  1196.                     }
  1197.                     $this->pages[$this->data->parent->getPath()$this->data;
  1198.                 }
  1199.                 $this->private_page false;
  1200.                 $this->private_class = false;
  1201.                 if (isset($this->db_template))
  1202.                 {
  1203.                     addWarning(PDERROR_DB_TEMPLATE_UNTERMINATED);
  1204.                 }
  1205.                 unset($this->db_template);
  1206.                 unset($this->last);
  1207.             elseif ($data == PHPDOCUMENTOR_EVENT_END_DOCBLOCK_TEMPLATE)
  1208.             {
  1209.                 unset($this->db_template);
  1210.             }
  1211.             //echo $this->state_lookup[$data] . "\n";
  1212.             //echo $data."\n";
  1213.         
  1214.          else 
  1215.         {
  1216.             if ($event == PHPDOCUMENTOR_EVENT_README_INSTALL_CHANGELOG)
  1217.             {
  1218.                 $this->ric[$data[0]] $data[1];
  1219.                 return;
  1220.             }
  1221.             if ($event == PHPDOCUMENTOR_EVENT_DOCBLOCK_TEMPLATE)
  1222.             {
  1223.                 $data->postProcess();
  1224.                 $this->db_template = $data;
  1225.                 $this->_lastDocBlockWasPageLevel false;
  1226.                 // 2nd docblock in a row, and it's at the top of the file, page-level docblock
  1227.                 if ($this->type == "docblock" && $this->data->isClean())
  1228.                 {
  1229.                     // can only have 1 package-level docblock, others are ignored
  1230.                     $this->data->clean = false;
  1231.                     if ($this->last->getKeyword('ignore'))
  1232.                     {
  1233.                         $this->proceduralpages->ignorePage($this->data->parent);
  1234.                         $this->private_page true;
  1235.                         unset($this->last);
  1236.                         $this->privatepages[$this->data->parent->getPath()$this->data;
  1237.                         unset($this->pages[$this->data->parent->getPath()]);
  1238.                         return;
  1239.                     }
  1240.                     $this->data->setDocBlock($this->last);
  1241.                     $this->package $this->data->parent->package $this->last->package;
  1242.                     $this->subpackage $this->data->parent->subpackage $this->last->subpackage;
  1243.                     $this->proceduralpages->addPagePackage($this->data->parent->getPath(),$this->package,$this->subpackage);
  1244.                     if ($access $this->last->getKeyword('access'))
  1245.                     {
  1246.                         if (is_object($access&& ($access->getString(== 'private'&& (!$this->parsePrivate))
  1247.                         {
  1248.                             addWarning(PDERROR_PARSEPRIVATE$this->data->parent->getPath());
  1249.                             $this->proceduralpages->ignorePage($this->data->parent);
  1250.                             $this->private_page true;
  1251.                             unset($this->last);
  1252.                             $this->privatepages[$this->data->parent->getPath()$this->data;
  1253.                             unset($this->pages[$this->data->parent->getPath()]);
  1254.                             return;
  1255.                         }
  1256.                     }
  1257.                     if ($this->last->getKeyword('name'))
  1258.                     {
  1259.                         $a $this->last->getKeyword('name');
  1260.                         if (is_object($a)) $a $a->value;
  1261.                         $this->data->parent->setFile($a);
  1262.                         $this->proceduralpages->setName($a);
  1263.                     }
  1264.                     $this->addPage($this->data->parent$this->data->parent->getPath());
  1265.                     if ($this->package)
  1266.                     {
  1267.                         $this->parsePackagePage($this->package$this->data->parent->getPath());
  1268.                     }
  1269.                 }
  1270.                 unset($this->last);
  1271.             else
  1272.             {
  1273.                 $this->lasttype = $this->type;
  1274.                 $type $data->getType();
  1275. //                fancy_debug($type,$data);
  1276.                 if (($type != 'page'&& ($type != 'docblock'&& ($type != 'packagepage'&& ($type != 'tutorial'))
  1277.                 {
  1278.                     $data->setFile($this->data->parent->getFile());
  1279.                 }
  1280.                 $this->type = $type;
  1281.                 //echo $type . "\n";
  1282.                 
  1283.                 if (isset($this->event_handlers[$type]))
  1284.                 {
  1285.                     $handle $this->event_handlers[$type];
  1286.                     $this->$handle($event,$data);
  1287.                 }
  1288.             
  1289.         }
  1290.     }
  1291.     
  1292.     /**
  1293.      * Replaces the {@link parserPage} represented by $this->pages[$path] with
  1294.      * $page
  1295.      *
  1296.      * Called by {@link addPageIfNecessary(), handleDocBlock()} and
  1297.      * {@link ProceduralPages::setupPages()}, this method first checks to see if
  1298.      * the page has been added.  If not, it assumes that the page has either
  1299.      * been @ignored or set with @access private with --parseprivate off, and
  1300.      * returns {@link addPrivatePage()}.  Otherwise, it sets the pages[$path] to
  1301.      * be the parserPage $page and sets the package and subpackage to that of
  1302.      * $page
  1303.      * @see $pages
  1304.      * @param parserPage 
  1305.      * @param string full path to the file
  1306.      */
  1307.     function addPage($page$path)
  1308.     {
  1309.         if (!isset($this->pages[$path])) return $this->addPrivatePage($page$path);
  1310.         $this->pages[$path]->setParent($page);
  1311.         if ($page->package != $GLOBALS['phpDocumentor_DefaultPackageName'])
  1312.         {
  1313.             if (!$this->pages[$path]->docblock)
  1314.             {
  1315.                 $docblock new parserDocBlock;
  1316.                 $docblock->package $page->package;
  1317.                 $docblock->subpackage $page->subpackage;
  1318.                 $this->pages[$path]->docblock $docblock;
  1319.             else
  1320.             {
  1321.                 $this->pages[$path]->docblock->package $page->package;
  1322.                 $this->pages[$path]->docblock->subpackage $page->subpackage;
  1323.             }
  1324.         }
  1325.     }
  1326.     
  1327.     /**
  1328.      * add a new {@link parserPage} to the $pages array if none is found
  1329.      *
  1330.      * This method is used when a page has been @ignored or marked with @access
  1331.      * private, and a public class is in the page (a class with no @access
  1332.      * private in its DocBlock).  The method first creates a new page in the
  1333.      * {@link $pages} array and then copies path information, and calls
  1334.      * {@link addPage()} to set up packages
  1335.      * @param string full path of page
  1336.      */
  1337.     function addPageIfNecessary($path&$class)
  1338.     {
  1339.         global $_phpDocumentor_setting;
  1340.         if (!$this->parsePrivate)
  1341.         {
  1342.             if (!isset($this->pages[$path]))
  1343.             {
  1344.                 $this->pages[$pathnew parserData;
  1345.                 $this->pages[$path]->docblock new parserDocBlock;
  1346.                 $this->pages[$path]->docblock->package $this->privatepages[$path]->docblock->package;
  1347.                 $this->pages[$path]->docblock->subpackage $this->privatepages[$path]->docblock->subpackage;
  1348.                 $par $this->privatepages[$path]->parent;
  1349.                 $this->pages[$path]->setParent($par);
  1350.                 $this->proceduralpages->addPage($par);
  1351.             }
  1352.         }
  1353.         if (!empty($_phpDocumentor_setting['packageoutput']))
  1354.             $packages explode(',',$_phpDocumentor_setting['packageoutput']);
  1355.         if (!empty($_phpDocumentor_setting['packageoutput']&&
  1356.             $this->pages[$path]->parent->package != $class->docblock->package &&
  1357.             !in_array($this->pages[$path]->parent->package,$packages))
  1358.         {
  1359.             $this->pages[$path]->parent->package $class->docblock->package;
  1360.             $this->addPage($this->pages[$path]->parent$path);
  1361.             $this->proceduralpages->addPage($this->pages[$path]->parent);
  1362.         }
  1363.     }
  1364.     
  1365.     /**
  1366.      * Adds a {@link parserPage} element to the {@link parserData} element in
  1367.      * $this->privatepages[$path]
  1368.      *
  1369.      * Performs a similar function to addPage, but adds to the
  1370.      * {@link $privatePages} array
  1371.      * @param parserPage $page 
  1372.      * @param string $path full path to the page
  1373.      * @see addPage()
  1374.      */
  1375.     function addPrivatePage($page$path)
  1376.     {
  1377.         $this->privatepages[$path]->setParent($page);
  1378.         if ($page->package != $GLOBALS['phpDocumentor_DefaultPackageName'])
  1379.         {
  1380.             if (!$this->privatepages[$path]->docblock)
  1381.             {
  1382.                 $docblock new parserDocBlock;
  1383.                 $docblock->package $page->package;
  1384.                 $docblock->subpackage $page->subpackage;
  1385.                 $this->privatepages[$path]->docblock $docblock;
  1386.             else
  1387.             {
  1388.                 $this->privatepages[$path]->docblock->package $page->package;
  1389.                 $this->privatepages[$path]->docblock->subpackage $page->subpackage;
  1390.             }
  1391.         }
  1392.     }
  1393.     
  1394.     /**
  1395.      * adds a processed descendant of {@link parserElement} to the {@link $pages}
  1396.      * array or {@link $privatepages} array
  1397.      *
  1398.      * This function expects the page to exist in either $pages or $privatepages.  It calls the
  1399.      * {@link parserData::addElement()} method to add $element to the page.
  1400.      * @param parserElement $element this will actually be a descendant of parserElement
  1401.      * @param string $path 
  1402.      */
  1403.     function addElementToPage($element$path)
  1404.     {
  1405.         if (isset($this->privatepages[$path]))
  1406.         {
  1407.             if (isset($this->pages[$path]))
  1408.             {
  1409.                 if ($element->type == 'class' || $element->type == 'method'
  1410.                     || $element->type == 'var' || $element->type == 'const')
  1411.                 {
  1412.                     $this->pages[$path]->addElement($element);
  1413.                 else
  1414.                 $this->privatepages[$path]->addElement($element);
  1415.             else
  1416.             $this->privatepages[$path]->addElement($element);
  1417.         else
  1418.         {
  1419.             if (isset($this->pages[$path]))
  1420.             {
  1421.                 $this->pages[$path]->addElement($element);
  1422.             }
  1423.         }
  1424.     }
  1425.     
  1426.     /**
  1427.      * Add all the @uses tags from $element to the $uses array so that @usedby
  1428.      * virtual tags can be added
  1429.      * @uses parserUsesTag::getSeeElement() used to initialize {@link $uses}
  1430.      * @uses parserUsesTag::getDescription() used to initialize {@link $uses}
  1431.      * @param parserElement descendant of parserElement
  1432.      * @param string full path to the file
  1433.      */
  1434.     function addUses($element$path)
  1435.     {
  1436.         if ($element->type == 'page')
  1437.         {
  1438.             $element $this->pages[$element->path];
  1439.         }
  1440.         if (!$this->parsePrivate && $element->docblock->hasaccess)
  1441.         {
  1442.             $a =  $element->docblock->getKeyword('access');
  1443.             if (is_object($a&& $a->getString(== 'private'return;
  1444.         }
  1445.         if (isset($this->privatepages[$path]))
  1446.         {
  1447.             if (isset($this->pages[$path]))
  1448.             {
  1449. //                if ($element->type == 'function' || $element->type == 'method')
  1450.                 {
  1451.                     $uses $element->docblock->getKeyword('uses');
  1452.                     if ($uses)
  1453.                     {
  1454.                         if (!is_array($uses)) $uses array($uses);
  1455.                         foreach($uses as $use)
  1456.                         {
  1457.                             if (!is_object($use)) continue;
  1458.                             $el $use->getSeeElement();
  1459.                             $description $use->getDescription();
  1460.                             $this->uses[$el][array($element$description);
  1461.                         }
  1462.                     }
  1463.                 }
  1464.             }
  1465.         else
  1466.         {
  1467.             if (isset($this->pages[$path]))
  1468.             {
  1469. //                if ($element->type == 'function' || $element->type == 'method')
  1470.                 {
  1471.                     $uses $element->docblock->getKeyword('uses');
  1472.                     if ($uses)
  1473.                     {
  1474.                         if (!is_array($uses)) $uses array($uses);
  1475.                         foreach($uses as $use)
  1476.                         {
  1477.                             if (!is_object($use)) continue;
  1478.                             $el $use->getSeeElement();
  1479.                             $description $use->getDescription();
  1480.                             $this->uses[$el][array($element$description);
  1481.                         }
  1482.                     }
  1483.                 }
  1484.             }
  1485.         }
  1486.     }
  1487.     
  1488.     /**
  1489.      * Add a {@link parserUsedByTag} link to every element referred to by @uses
  1490.      * @param Converter temporary converter used to retrieve abstract links
  1491.      * @uses phpDocumentor_IntermediateParser::addUses() indirectly, as
  1492.      *        addUses() sets up $uses, which is iterated over here
  1493.      * @uses $pages sets up all @usedby tags from here
  1494.      * @access private
  1495.      */
  1496.     function _setupUsesList(&$converter)
  1497.     {
  1498.         ob_start();
  1499.         $converter->_createPkgElements($this->pages);
  1500.         ob_end_clean();
  1501.         ksort($this->uses);
  1502.         foreach($this->uses as $link => $elements)
  1503.         {
  1504.             foreach($elements as $element)
  1505.             {
  1506.                 if ($element[0]->type == 'method' || $element[0]->type == 'var' ||
  1507.                     $element[0]->type == 'const')
  1508.                 {
  1509.                     $converter->class $element[0]->getClass();
  1510.                 }
  1511.                 if ($element[0]->type == 'class')
  1512.                 {
  1513.                     $converter->class $element[0]->getName();
  1514.                 }
  1515.                 $reallink $converter->getLink($link,$element[0]->docblock->package);
  1516.                 if (is_object($reallink))
  1517.                 {
  1518.                     // add a used by tag to the docblock of the destination
  1519.                     switch(phpDocumentor_get_class($reallink))
  1520.                     {
  1521.                         case 'pagelink' :
  1522.                             $this->pages[$reallink->path]->docblock->addUsedBy(
  1523.                                 $element[0]->getLink($converterfalsetrue),
  1524.                                 $element[1]);
  1525.                         break;
  1526.                         case 'functionlink' :
  1527.                         case 'definelink' :
  1528.                         case 'globallink' :
  1529.                         if (isset($this->pages[$reallink->path]))
  1530.                         {
  1531.                             for ($i=0;
  1532.                                  $i<count($this->pages[$reallink->path]->elements);
  1533.                                  $i++{
  1534.                                 if ($this->pages[$reallink->path]->elements[$i]->type ==
  1535.                                       str_replace('link''',
  1536.                                       phpDocumentor_get_class($reallink)) &&
  1537.                                       $this->pages[$reallink->path]->
  1538.                                       elements[$i]->getName(
  1539.                                       == $reallink->name{
  1540.                                     $this->pages[$reallink->path]->elements[$i]->
  1541.                                     docblock->addUsedBy(
  1542.                                         $element[0]->getLink($converter,false,true),
  1543.                                         $element[1]);
  1544. //                                   debug('added @usedby to '.str_replace('link','',phpDocumentor_get_class($reallink)).' '.$reallink->name);
  1545.                                 }
  1546.                             }
  1547.                         }
  1548.                         break;
  1549.                         case 'classlink' :
  1550.                         case 'methodlink' :
  1551.                         case 'varlink' :
  1552.                         case 'constlink' :
  1553.                         if (isset($this->pages[$reallink->path]))
  1554.                         {
  1555.                             for ($i=0;$i<count($this->pages[$reallink->path]->classelements);$i++)
  1556.                             {
  1557.                                 if ($this->pages[$reallink->path]->classelements[$i]->type ==
  1558.                                       str_replace('link','',phpDocumentor_get_class($reallink)) &&
  1559.                                       $this->pages[$reallink->path]->classelements[$i]->getName(== $reallink->name &&
  1560.                                       (!isset($reallink->class|| 
  1561.                                       $this->pages[$reallink->path]->classelements[$i]->getClass(== $reallink->class))
  1562.                                 {
  1563.                                     $this->pages[$reallink->path]->classelements[$i]->docblock->addUsedBy($element[0]->getLink($converter,false,true)$element[1]);
  1564. //                                   debug('added @usedby to '.str_replace('link','',phpDocumentor_get_class($reallink)).' '.$reallink->name);
  1565.                                 }
  1566.                             }
  1567.                         }
  1568.                         break;
  1569.                     }
  1570.                 }
  1571.             }
  1572.         }
  1573.     }
  1574.     
  1575.     /**
  1576.      * Interface to the Converter
  1577.      *
  1578.      * This function simply passes {@link $pages} and {@link package_pages} to
  1579.      * the walk() method, and then calls the Output() method.  Note that
  1580.      * Output() is not required to do anything, and in fact doesn't in
  1581.      * HTMLframesConverter.
  1582.      * @uses Converter::walk() passes {@link $pages} and {@link $package_pages}
  1583.      * @uses Converter::Output()
  1584.      */
  1585.     function Convert($title$converter)
  1586.     {
  1587.         $converter->walk($this->pages$this->package_pages);
  1588.         $converter->Output($title);
  1589.         $converter->cleanup();
  1590.     }
  1591.     
  1592.     /**
  1593.      * Clean up classes
  1594.      *
  1595.      * {@source } 
  1596.      * @access private
  1597.      * @uses Classes::Inherit() passes $this
  1598.      */
  1599.     function fixClasses()
  1600.     {
  1601.         $this->classes->Inherit($this);
  1602.     }
  1603.     
  1604.     /**
  1605.      * Clean up Procedural Pages
  1606.      * {@source } 
  1607.      * @access private
  1608.      * @uses ProceduralPages::setupPages() passes $this
  1609.      */
  1610.     function fixProcPages()
  1611.     {
  1612.         $this->proceduralpages->setupPages($this);
  1613.     }
  1614.     
  1615.     /**
  1616.      * If the parent class of $class is in a different package, adds it to the
  1617.      * {@link $package_parents} array
  1618.      * @param parserClass &$class 
  1619.      */
  1620.     function addPackageParent(&$class)
  1621.     {
  1622.         if (!is_array($class->parent)) return;
  1623.         $par $this->classes->getClass($class->parent[1]$class->parent[0]);
  1624.         if ($class->docblock->package == $par->docblock->packagereturn;
  1625.         $this->package_parents[$class->docblock->package$par->docblock->package;
  1626.         if (!isset($this->package_parents[$par->docblock->package]|| !$this->package_parents[$par->docblock->package]$this->package_parents[$par->docblock->packagefalse;
  1627.     }
  1628.     
  1629.     /**
  1630.      * Add a converter name to use to the list of converters
  1631.      *
  1632.      * Sets up the {@link $converters} array.
  1633.      * {@internal 
  1634.      * First, the Converter's file is included, and then, if successful,
  1635.      * the converter classname is tested for existance.  If all is good,
  1636.      * then the templates are added to the list of converters/templates to use}}}
  1637.      * @param string $output output format (HTML, PDF, XML).  Must be all caps
  1638.      * @param string $name Converter name (frames, for example, is the name of
  1639.      *                      HTMLframesConverter)
  1640.      * @param string $template template to use, should be a relative path to the
  1641.      *                          templates dir (like DOM/default)
  1642.      */
  1643.     function addConverter($output,$name,$template)
  1644.     {
  1645.         if ($this->templateBase{
  1646.             $templateBase str_replace('\\','/'$this->templateBase'/Converters';
  1647.         else {
  1648.             if ('@[email protected]!= '@'.'[email protected]'{
  1649.                 $templateBase 'PhpDocumentor/phpDocumentor/Converters';
  1650.             else {
  1651.                 $templateBase str_replace('\\','/',$GLOBALS['_phpDocumentor_install_dir']'/phpDocumentor/Converters';
  1652.             }
  1653.         }
  1654.         if (strpos($name,PATH_DELIMITER))
  1655.         {
  1656.             // include the parent template
  1657.             $parent explode(PATH_DELIMITER,$name);
  1658.             $parent $parent[0];
  1659.             if (!class_exists($output $parent 'Converter')) {
  1660.                 $filename $templateBase '/' $output '/' $parent '/' $output
  1661.                     . $parent 'Converter.inc';
  1662.                 if (Io::isIncludeable($filename))
  1663.                 {
  1664.                     include_once($filename);
  1665.                 }
  1666.             }
  1667.             if (!class_exists($output $parent 'Converter'))
  1668.             {
  1669.                 addError(PDERROR_CONVERTER_NOT_FOUND,"parent Converter ".$output $parent "Converter of child Converter ".$output str_replace(PATH_DELIMITER,'',$name"Converter");
  1670.             }
  1671.         }
  1672.         $filename $templateBase .
  1673.              PATH_DELIMITER $output PATH_DELIMITER $name PATH_DELIMITER $output .
  1674.              str_replace(PATH_DELIMITER''$name"Converter" ".inc";
  1675.         if (Io::isIncludeable($filename))
  1676.         {
  1677.             include_once($filename);
  1678.         }
  1679.         if (class_exists($output str_replace(PATH_DELIMITER,'',$name'Converter'))
  1680.         {
  1681.             $this->converters[$output][$output str_replace(PATH_DELIMITER,'',$name"Converter"][$template;
  1682.         else
  1683.         {
  1684.             addError(PDERROR_CONVERTER_NOT_FOUND,$output str_replace(PATH_DELIMITER,'',$name"Converter");
  1685.         }
  1686.     }
  1687.  
  1688.     /**
  1689.      * does a natural case sort on two {@link parserElement} descendants
  1690.      *
  1691.      * @param    mixed    $a 
  1692.      * @param    mixed    $b 
  1693.      * @return    int 
  1694.      * @see        generateElementIndex()
  1695.      */
  1696.     function elementCmp ($a$b)
  1697.     {
  1698.         return strnatcasecmp($a->getName()$b->getName());
  1699.     }
  1700.     
  1701.     /**
  1702.      * does a natural case sort on two class elements (either
  1703.      * {@link parserClass, parserMethod} or {@link parserVar}
  1704.      *
  1705.      * @param    mixed    $a 
  1706.      * @param    mixed    $b 
  1707.      * @return    int 
  1708.      * @see        generateElementIndex()
  1709.      */
  1710.     function ClasselementCmp ($a$b)
  1711.     {
  1712.         if (phpDocumentor_get_class($a== 'parserclass'$atest $a->nameelse $atest $a->class;
  1713.         if (phpDocumentor_get_class($b== 'parserclass'$btest $b->nameelse $btest $b->class;
  1714.         
  1715.         if(($c strnatcasecmp($atest$btest)) != 0return $c;
  1716.         if (phpDocumentor_get_class($a!= 'parserclass'$atest .= $a->name;
  1717.         if (phpDocumentor_get_class($b!= 'parserclass'$btest .= $b->name;
  1718.         if (phpDocumentor_get_class($a== 'parsermethod' && phpDocumentor_get_class($b== 'parsermethod')
  1719.         {
  1720.             if ($a->isConstructorreturn -1;
  1721.             if ($b->isConstructorreturn 1;
  1722.             if ($a->isDestructorreturn -1;
  1723.             if ($b->isDestructorreturn 1;
  1724.         }
  1725.         return strnatcasecmp($atest,$btest);
  1726.     }
  1727.     
  1728.     /**
  1729.      * call this method once parsing has completed.
  1730.      *
  1731.      * This method calls the private methods fixClasses and fixProcPages, both
  1732.      * of which adjust inheritance and package information based on complicated
  1733.      * post-parsing rules described in {@link ProceduralPages::setupPages()}
  1734.      * and {@link Classes::Inherit()}.  Then, it sorts elements of the $pages
  1735.      * array and calls Convert for each Converter in the $converters array
  1736.      * @see $converters
  1737.      * @see $pages
  1738.      * @see Convert()
  1739.      */
  1740.     function Output ($title "Generated Documentation")
  1741.     {
  1742.         $GLOBALS['phpDocumentor_errors']->curfile false;
  1743.         $this->fixClasses();
  1744.         $this->fixProcPages();
  1745. //        var_dump($this->uses);
  1746. //        exit;
  1747.         phpDocumentor_out("\nSorting page elements...");
  1748.         flush();
  1749.         uasort($this->pages,'pagesort');
  1750.         foreach($this->pages as $i => $page)
  1751.         {
  1752.             usort($this->pages[$i]->elements,array($this,'elementCmp'));
  1753.             usort($this->pages[$i]->classelements,array($this,'ClasselementCmp'));
  1754.         }
  1755.         phpDocumentor_out("done\n");
  1756.         flush();
  1757.         $complicatedout false;
  1758.         if (is_array($this->converters))
  1759.         {
  1760.             if (count($this->converters1)
  1761.             {
  1762.                 $complicatedout true;
  1763.             }
  1764.             phpDocumentor_out("Formatting @uses list...");
  1765.             flush();
  1766.             $a new __dummyConverter($this->all_packages$this->package_parents$this->classes$this->proceduralpages$this->packageoutput$this->parsePrivate$this->quietMode$this->targetDir ''$this->title);
  1767.             $this->_setupUsesList($a);
  1768.             unset($a);
  1769.             phpDocumentor_out("done\n\n");
  1770.             flush();
  1771.             foreach($this->converters as $converter => $blah)
  1772.             {
  1773.                 if (is_array($blah))
  1774.                 {
  1775.                     if (count($blah1)
  1776.                     {
  1777.                         $complicatedout true;
  1778.                     }
  1779.                     foreach($blah as $converter => $templates)
  1780.                     {
  1781.                         foreach($templates as $template)
  1782.                         {
  1783.                             $extraout '';
  1784.                             if ($complicatedout)
  1785.                             {
  1786.                                 $extraout SMART_PATH_DELIMITER $converter;
  1787.                             }
  1788.                             if (count($templates1)
  1789.                             {
  1790.                                 $extraout .= SMART_PATH_DELIMITER str_replace(PATH_DELIMITERSMART_PATH_DELIMITERsubstr($template,0,strlen($template1));
  1791.                             }
  1792.                             $a new $converter($this->all_packages$this->package_parents$this->classes$this->proceduralpages$this->packageoutput$this->parsePrivate$this->quietMode$this->targetDir . $extraout$template$this->title);
  1793.                             if (isset($this->templateBase))
  1794.                             {
  1795.                                 $a->setTemplateBase($this->templateBase$template);
  1796.                             }
  1797.                             $a->ric $this->ric;
  1798.                             $a->packagecategories $this->packagecategories;
  1799.                             if (isset($this->tutorials)) $a->setTutorials($this->tutorials);
  1800.                             $this->Convert($title$a);
  1801.                             unset($a);
  1802.                         }
  1803.                     }
  1804.                 }
  1805.             }
  1806.         else
  1807.         {
  1808.             addErrorDie(PDERROR_NO_CONVERTERS);
  1809.         }
  1810.     }
  1811.  
  1812.     /**
  1813.      * Sets the output directory
  1814.      *
  1815.      * @param string $dir the output directory
  1816.      */
  1817.     function setTargetDir($dir)
  1818.     {
  1819.         $this->targetDir = $dir;
  1820.     }
  1821.  
  1822.     /**
  1823.      * Sets the template base directory
  1824.      *
  1825.      * @param string $dir the template base directory
  1826.      * @tutorial phpDocumentor.howto.pkg#using.command-line.templatebase
  1827.      */
  1828.     function setTemplateBase($dir)
  1829.     {
  1830.         $this->templateBase = $dir;
  1831.     }
  1832.  
  1833.     /**
  1834.      * set parsing information output mode (quiet or verbose)
  1835.      *
  1836.      * If set to false, no parsing information (parsing /php/file/thisfile.php,
  1837.      * Converting etc.) will be displayed.
  1838.      * Useful for cron jobs
  1839.      * @param    bool $quietMode 
  1840.      */
  1841.     function setQuietMode($quietMode)
  1842.     {
  1843.         $this->quietMode = $quietMode;
  1844.     }
  1845.     
  1846.     /**
  1847.      * set display of elements marked with @access private
  1848.      *
  1849.      * If set to true, elements will be displayed
  1850.      * @param    bool $parse 
  1851.      */
  1852.     function setParsePrivate($parse)
  1853.     {
  1854.         $this->parsePrivate = $parse;
  1855.     }
  1856. }
  1857.  
  1858. /** @access private */
  1859. function pagesort($a$b)
  1860. {
  1861.     return strnatcasecmp($a->parent->file,$b->parent->file);
  1862. }
  1863. ?>

Documentation generated on Tue, 24 Oct 2006 09:23:50 -0500 by phpDocumentor 1.3.1