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

Documentation generated on Mon, 05 Dec 2011 21:17:12 -0600 by phpDocumentor 1.4.4