home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Web Server / PHP.EXE / pear / PHPDoc / core / Phpdoc.php next >
Encoding:
PHP Script  |  2001-02-18  |  7.3 KB  |  240 lines
  1. <?php
  2. /**
  3. * Coordinates several Phpdoc Object to parse and render source files.
  4. * 
  5. * @access   public
  6. * @version  $Id: Phpdoc.php,v 1.5 2001/02/18 15:29:29 uw Exp $
  7. */
  8. class Phpdoc extends PhpdocSetupHandler {
  9.  
  10.     /**
  11.     * Result from the indexer
  12.     *
  13.     * @var  array
  14.     * @see  render()
  15.     */
  16.     var $indexer_result = array();
  17.  
  18.     /**
  19.     * Print status messages
  20.     */
  21.     var $flag_output = true;
  22.  
  23.     /**
  24.     * Calls the command line handler if necessary.
  25.     *
  26.     * WARNING: Does not work
  27.     *
  28.     * @global array $argc, string $PHP_SELF
  29.     */
  30.     function Phpdoc() {
  31.         global $argc, $PHP_SELF;
  32.  
  33.         $this->target = $PHP_SELF . "apidoc/";
  34.  
  35.         if ($argc > 1) 
  36.             $this->handleArgv();
  37.  
  38.     } // end constructor
  39.  
  40.     /**
  41.     * Starts the parser. 
  42.     *
  43.     * @return   bool        $ok
  44.     * @throws   PhpdocError
  45.     * @access   public
  46.     */
  47.     function parse() {
  48.  
  49.         $this->warn = new PhpdocWarning;
  50.  
  51.         $errors = $this->checkStatus();
  52.         if (0 != count($errors)) {
  53.  
  54.             reset($errors);
  55.             while (list($k, $error)=each($errors))
  56.                 $this->err[] = new PhpdocError($error["msg"]."Errno = ".$error["errno"], 9, __FILE__, __LINE__);
  57.  
  58.             return false;
  59.         }
  60.  
  61.         $this->outl("Parser starts...");
  62.  
  63.         // create some objects
  64.         $fileHandler    = new PhpdocFileHandler;
  65.         $parser         = new PhpdocParser(true);
  66.         $classAnalyser  = new PhpdocClassAnalyser;
  67.         $moduleAnalyser = new PhpdocModuleAnalyser;
  68.  
  69.         $indexer    = new PhpdocIndexer;                
  70.  
  71.         $classExporter  = new PhpdocXMLClassExporter();
  72.         $classExporter->setPath($this->target);
  73.  
  74.         $moduleExporter = new PhpdocXMLModuleExporter();
  75.         $moduleExporter->setPath($this->target);
  76.  
  77.         $indexExporter = new PhpdocXMLIndexExporter();
  78.         $indexExporter->setPath($this->target);
  79.  
  80.         $warningExporter = new PhpdocXMLWarningExporter();
  81.         $warningExporter->setPath($this->target);
  82.  
  83.         // This will change one fine day! 
  84.         $parser->warn         = $this->warn;
  85.         $classAnalyser->warn  = $this->warn;
  86.         $moduleAnalyser->warn = $this->warn;
  87.         $classExporter->warn  = $this->warn;
  88.         $moduleExporter->warn = $this->warn;
  89.         $indexer->warn        = $this->warn; 
  90.  
  91.         $sourcefiles = $fileHandler->getFilesInDirectory($this->sourceDirectory, $this->sourceFileSuffix);
  92.         $parser->setPhpSourcecodeFiles($fileHandler->get($sourcefiles));
  93.  
  94.         $this->outl("... preparse to find modulegroups and classtrees.");
  95.         $parser->preparse();
  96.  
  97.         $this->outl("... parsing classes.");
  98.         while ($classtree = $parser->getClassTree()) {
  99.  
  100.             $classAnalyser->setClasses( $classtree, $parser->current_baseclass );
  101.             $classAnalyser->analyse();
  102.  
  103.             while ($class = $classAnalyser->getClass()) {
  104.                 $indexer->addClass($class);
  105.                 $classExporter->export($class);
  106.             }
  107.  
  108.             if (floor(phpversion()) > 3) {
  109.  
  110.                 $indexExporter->exportClasstree($indexer->getClasstree(), $parser->current_baseclass);
  111.  
  112.             } else {
  113.  
  114.                 $classtree = $indexer->getClasstree();
  115.                 $base = $parser->current_baseclass;
  116.                 $indexExporter->exportClasstree($classtree, $base);
  117.  
  118.             }
  119.  
  120.         }
  121.  
  122.         $this->outl("... parsing modules.");
  123.         while ($modulegroup = $parser->getModulegroup()) {    
  124.  
  125.             $moduleAnalyser->setModulegroup( $modulegroup );
  126.             $moduleAnalyser->analyse();
  127.  
  128.             while ($module = $moduleAnalyser->getModule()) {
  129.                 $indexer->addModule($module);
  130.                 $moduleExporter->export($module);
  131.             }
  132.  
  133.             if (floor(phpversion()) > 3) {
  134.  
  135.                 $indexExporter->exportModulegroup($indexer->getModulegroup());
  136.  
  137.             } else {
  138.  
  139.                 $modulegroup = $indexer->getModulegroup();
  140.                 $indexExporter->exportModulegroup($modulegroup);
  141.  
  142.             }
  143.  
  144.         }
  145.  
  146.         $this->outl("... writing packagelist.");
  147.         if (floor(phpversion()) > 3) {
  148.  
  149.             $indexExporter->exportPackagelist($indexer->getPackages());
  150.             $indexExporter->exportElementlist($indexer->getElementlist());
  151.  
  152.         } else {
  153.  
  154.             $packages = $indexer->getPackages();
  155.             $indexExporter->exportPackagelist($packages);
  156.             $elements = $indexer->getElementlist();
  157.             $indexExporter->exportElementlist($elements);
  158.  
  159.         }
  160.  
  161.         $warningExporter->export($parser->warn->getWarnings(), "parser");
  162.         $warningExporter->export($moduleAnalyser->warn->getWarnings(), "moduleanalyser");
  163.         $warningExporter->export($classAnalyser->warn->getWarnings(), "classanalyser");
  164.  
  165.         $this->outl("Parser finished.");
  166.         return true;
  167.     } // end func parse
  168.  
  169.     /**
  170.     * Renders the PHPDoc XML files as HTML files 
  171.     *
  172.     * @param    string  Targetformat, currently only "html" is available.
  173.     * @param    string  Target directory for the html files
  174.     * @param    string  Directory with the html templates
  175.     * @return   bool    $ok
  176.     * @throws   PhpdocError
  177.     * @access   public
  178.     */
  179.     function render($type = "html", $target = "", $template = "") {
  180.  
  181.         $this->outl("Starting to render...");
  182.         $target = ("" == $target) ? $this->target : $this->getCheckedDirname($target);
  183.         $template = ("" == $template) ? $this->templateRoot : $this->getCheckedDirname($template);                
  184.  
  185.         switch (strtolower($type)) {
  186.  
  187.             case "html":
  188.             default:
  189.                 $renderer = new PhpdocHTMLRendererManager($target, $template, $this->application, $this->targetFileSuffix);
  190.                 break;
  191.         }
  192.  
  193.         $fileHandler         = new PhpdocFileHandler;
  194.         $files = $fileHandler->getFilesInDirectory($target, "xml");
  195.         $len = strlen($target);
  196.  
  197.         $tpl = new IntegratedTemplate($this->templateRoot);
  198.         $tpl->loadTemplateFile("xmlfiles.html");
  199.         $tpl->setCurrentBlock("file_loop");
  200.  
  201.         // Do not change the file prefixes!
  202.         reset($files);
  203.         while (list($k, $file) = each($files)) {
  204.  
  205.             $tpl->setVariable("FILE", substr($file, $len));
  206.             $tpl->parseCurrentBlock();
  207.  
  208.             if ("class_" == substr($file, $len, 6)) {
  209.  
  210.                 $renderer->render(substr($file, $len), "class");
  211.  
  212.             } else if ("module_" == substr($file, $len, 7)) {
  213.  
  214.                 $renderer->render(substr($file, $len), "module");
  215.  
  216.             } else if ("classtree_" == substr($file, $len, 10)) {
  217.  
  218.                 $renderer->render(substr($file, $len), "classtree");
  219.  
  220.             }    else if ("modulegroup_" ==  substr($file, $len, 12)) {
  221.  
  222.                 $renderer->render(substr($file, $len), "modulegroup");
  223.  
  224.             } else if ("warnings_" == substr($file, $len, 9)) {
  225.  
  226.                 $renderer->render(substr($file, $len), "warning");
  227.  
  228.             }
  229.  
  230.         }
  231.  
  232.         $renderer->finish();    
  233.         $fileHandler->createFile($target."phpdoc_xmlfiles".$this->targetFileSuffix, $tpl->get());
  234.  
  235.         $this->outl($this->finishInstructions);
  236.         return true;
  237.     } // end func render
  238.  
  239. } // end class Phpdoc
  240. ?>