WEB-INF/lib/pear/PEAR/PackageFile/v1.php

   1 <?php
   2 /**
   3  * PEAR_PackageFile_v1, package.xml version 1.0
   4  *
   5  * PHP versions 4 and 5
   6  *
   7  * @category   pear
   8  * @package    PEAR
   9  * @author     Greg Beaver <cellog@php.net>
  10  * @copyright  1997-2009 The Authors
  11  * @license    http://opensource.org/licenses/bsd-license.php New BSD License
  12  * @version    CVS: $Id: v1.php 313023 2011-07-06 19:17:11Z dufuz $
  13  * @link       http://pear.php.net/package/PEAR
  14  * @since      File available since Release 1.4.0a1
  15  */
  16 /**
  17  * For error handling
  18  */
  19 require_once 'PEAR/ErrorStack.php';
  20
  21 /**
  22  * Error code if parsing is attempted with no xml extension
  23  */
  24 define('PEAR_PACKAGEFILE_ERROR_NO_XML_EXT', 3);
  25
  26 /**
  27  * Error code if creating the xml parser resource fails
  28  */
  29 define('PEAR_PACKAGEFILE_ERROR_CANT_MAKE_PARSER', 4);
  30
  31 /**
  32  * Error code used for all sax xml parsing errors
  33  */
  34 define('PEAR_PACKAGEFILE_ERROR_PARSER_ERROR', 5);
  35
  36 /**
  37  * Error code used when there is no name
  38  */
  39 define('PEAR_PACKAGEFILE_ERROR_NO_NAME', 6);
  40
  41 /**
  42  * Error code when a package name is not valid
  43  */
  44 define('PEAR_PACKAGEFILE_ERROR_INVALID_NAME', 7);
  45
  46 /**
  47  * Error code used when no summary is parsed
  48  */
  49 define('PEAR_PACKAGEFILE_ERROR_NO_SUMMARY', 8);
  50
  51 /**
  52  * Error code for summaries that are more than 1 line
  53  */
  54 define('PEAR_PACKAGEFILE_ERROR_MULTILINE_SUMMARY', 9);
  55
  56 /**
  57  * Error code used when no description is present
  58  */
  59 define('PEAR_PACKAGEFILE_ERROR_NO_DESCRIPTION', 10);
  60
  61 /**
  62  * Error code used when no license is present
  63  */
  64 define('PEAR_PACKAGEFILE_ERROR_NO_LICENSE', 11);
  65
  66 /**
  67  * Error code used when a <version> version number is not present
  68  */
  69 define('PEAR_PACKAGEFILE_ERROR_NO_VERSION', 12);
  70
  71 /**
  72  * Error code used when a <version> version number is invalid
  73  */
  74 define('PEAR_PACKAGEFILE_ERROR_INVALID_VERSION', 13);
  75
  76 /**
  77  * Error code when release state is missing
  78  */
  79 define('PEAR_PACKAGEFILE_ERROR_NO_STATE', 14);
  80
  81 /**
  82  * Error code when release state is invalid
  83  */
  84 define('PEAR_PACKAGEFILE_ERROR_INVALID_STATE', 15);
  85
  86 /**
  87  * Error code when release state is missing
  88  */
  89 define('PEAR_PACKAGEFILE_ERROR_NO_DATE', 16);
  90
  91 /**
  92  * Error code when release state is invalid
  93  */
  94 define('PEAR_PACKAGEFILE_ERROR_INVALID_DATE', 17);
  95
  96 /**
  97  * Error code when no release notes are found
  98  */
  99 define('PEAR_PACKAGEFILE_ERROR_NO_NOTES', 18);
 100
 101 /**
 102  * Error code when no maintainers are found
 103  */
 104 define('PEAR_PACKAGEFILE_ERROR_NO_MAINTAINERS', 19);
 105
 106 /**
 107  * Error code when a maintainer has no handle
 108  */
 109 define('PEAR_PACKAGEFILE_ERROR_NO_MAINTHANDLE', 20);
 110
 111 /**
 112  * Error code when a maintainer has no handle
 113  */
 114 define('PEAR_PACKAGEFILE_ERROR_NO_MAINTROLE', 21);
 115
 116 /**
 117  * Error code when a maintainer has no name
 118  */
 119 define('PEAR_PACKAGEFILE_ERROR_NO_MAINTNAME', 22);
 120
 121 /**
 122  * Error code when a maintainer has no email
 123  */
 124 define('PEAR_PACKAGEFILE_ERROR_NO_MAINTEMAIL', 23);
 125
 126 /**
 127  * Error code when a maintainer has no handle
 128  */
 129 define('PEAR_PACKAGEFILE_ERROR_INVALID_MAINTROLE', 24);
 130
 131 /**
 132  * Error code when a dependency is not a PHP dependency, but has no name
 133  */
 134 define('PEAR_PACKAGEFILE_ERROR_NO_DEPNAME', 25);
 135
 136 /**
 137  * Error code when a dependency has no type (pkg, php, etc.)
 138  */
 139 define('PEAR_PACKAGEFILE_ERROR_NO_DEPTYPE', 26);
 140
 141 /**
 142  * Error code when a dependency has no relation (lt, ge, has, etc.)
 143  */
 144 define('PEAR_PACKAGEFILE_ERROR_NO_DEPREL', 27);
 145
 146 /**
 147  * Error code when a dependency is not a 'has' relation, but has no version
 148  */
 149 define('PEAR_PACKAGEFILE_ERROR_NO_DEPVERSION', 28);
 150
 151 /**
 152  * Error code when a dependency has an invalid relation
 153  */
 154 define('PEAR_PACKAGEFILE_ERROR_INVALID_DEPREL', 29);
 155
 156 /**
 157  * Error code when a dependency has an invalid type
 158  */
 159 define('PEAR_PACKAGEFILE_ERROR_INVALID_DEPTYPE', 30);
 160
 161 /**
 162  * Error code when a dependency has an invalid optional option
 163  */
 164 define('PEAR_PACKAGEFILE_ERROR_INVALID_DEPOPTIONAL', 31);
 165
 166 /**
 167  * Error code when a dependency is a pkg dependency, and has an invalid package name
 168  */
 169 define('PEAR_PACKAGEFILE_ERROR_INVALID_DEPNAME', 32);
 170
 171 /**
 172  * Error code when a dependency has a channel="foo" attribute, and foo is not a registered channel
 173  */
 174 define('PEAR_PACKAGEFILE_ERROR_UNKNOWN_DEPCHANNEL', 33);
 175
 176 /**
 177  * Error code when rel="has" and version attribute is present.
 178  */
 179 define('PEAR_PACKAGEFILE_ERROR_DEPVERSION_IGNORED', 34);
 180
 181 /**
 182  * Error code when type="php" and dependency name is present
 183  */
 184 define('PEAR_PACKAGEFILE_ERROR_DEPNAME_IGNORED', 35);
 185
 186 /**
 187  * Error code when a configure option has no name
 188  */
 189 define('PEAR_PACKAGEFILE_ERROR_NO_CONFNAME', 36);
 190
 191 /**
 192  * Error code when a configure option has no name
 193  */
 194 define('PEAR_PACKAGEFILE_ERROR_NO_CONFPROMPT', 37);
 195
 196 /**
 197  * Error code when a file in the filelist has an invalid role
 198  */
 199 define('PEAR_PACKAGEFILE_ERROR_INVALID_FILEROLE', 38);
 200
 201 /**
 202  * Error code when a file in the filelist has no role
 203  */
 204 define('PEAR_PACKAGEFILE_ERROR_NO_FILEROLE', 39);
 205
 206 /**
 207  * Error code when analyzing a php source file that has parse errors
 208  */
 209 define('PEAR_PACKAGEFILE_ERROR_INVALID_PHPFILE', 40);
 210
 211 /**
 212  * Error code when analyzing a php source file reveals a source element
 213  * without a package name prefix
 214  */
 215 define('PEAR_PACKAGEFILE_ERROR_NO_PNAME_PREFIX', 41);
 216
 217 /**
 218  * Error code when an unknown channel is specified
 219  */
 220 define('PEAR_PACKAGEFILE_ERROR_UNKNOWN_CHANNEL', 42);
 221
 222 /**
 223  * Error code when no files are found in the filelist
 224  */
 225 define('PEAR_PACKAGEFILE_ERROR_NO_FILES', 43);
 226
 227 /**
 228  * Error code when a file is not valid php according to _analyzeSourceCode()
 229  */
 230 define('PEAR_PACKAGEFILE_ERROR_INVALID_FILE', 44);
 231
 232 /**
 233  * Error code when the channel validator returns an error or warning
 234  */
 235 define('PEAR_PACKAGEFILE_ERROR_CHANNELVAL', 45);
 236
 237 /**
 238  * Error code when a php5 package is packaged in php4 (analysis doesn't work)
 239  */
 240 define('PEAR_PACKAGEFILE_ERROR_PHP5', 46);
 241
 242 /**
 243  * Error code when a file is listed in package.xml but does not exist
 244  */
 245 define('PEAR_PACKAGEFILE_ERROR_FILE_NOTFOUND', 47);
 246
 247 /**
 248  * Error code when a <dep type="php" rel="not"... is encountered (use rel="ne")
 249  */
 250 define('PEAR_PACKAGEFILE_PHP_NO_NOT', 48);
 251
 252 /**
 253  * Error code when a package.xml contains non-ISO-8859-1 characters
 254  */
 255 define('PEAR_PACKAGEFILE_ERROR_NON_ISO_CHARS', 49);
 256
 257 /**
 258  * Error code when a dependency is not a 'has' relation, but has no version
 259  */
 260 define('PEAR_PACKAGEFILE_ERROR_NO_DEPPHPVERSION', 50);
 261
 262 /**
 263  * Error code when a package has no lead developer
 264  */
 265 define('PEAR_PACKAGEFILE_ERROR_NO_LEAD', 51);
 266
 267 /**
 268  * Error code when a filename begins with "."
 269  */
 270 define('PEAR_PACKAGEFILE_ERROR_INVALID_FILENAME', 52);
 271 /**
 272  * package.xml encapsulator
 273  * @category   pear
 274  * @package    PEAR
 275  * @author     Greg Beaver <cellog@php.net>
 276  * @copyright  1997-2009 The Authors
 277  * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 278  * @version    Release: 1.9.4
 279  * @link       http://pear.php.net/package/PEAR
 280  * @since      Class available since Release 1.4.0a1
 281  */
 282 class PEAR_PackageFile_v1
 283 {
 284     /**
 285      * @access private
 286      * @var PEAR_ErrorStack
 287      * @access private
 288      */
 289     var $_stack;
 290
 291     /**
 292      * A registry object, used to access the package name validation regex for non-standard channels
 293      * @var PEAR_Registry
 294      * @access private
 295      */
 296     var $_registry;
 297
 298     /**
 299      * An object that contains a log method that matches PEAR_Common::log's signature
 300      * @var object
 301      * @access private
 302      */
 303     var $_logger;
 304
 305     /**
 306      * Parsed package information
 307      * @var array
 308      * @access private
 309      */
 310     var $_packageInfo;
 311
 312     /**
 313      * path to package.xml
 314      * @var string
 315      * @access private
 316      */
 317     var $_packageFile;
 318
 319     /**
 320      * path to package .tgz or false if this is a local/extracted package.xml
 321      * @var string
 322      * @access private
 323      */
 324     var $_archiveFile;
 325
 326     /**
 327      * @var int
 328      * @access private
 329      */
 330     var $_isValid = 0;
 331
 332     /**
 333      * Determines whether this packagefile was initialized only with partial package info
 334      *
 335      * If this package file was constructed via parsing REST, it will only contain
 336      *
 337      * - package name
 338      * - channel name
 339      * - dependencies
 340      * @var boolean
 341      * @access private
 342      */
 343     var $_incomplete = true;
 344
 345     /**
 346      * @param bool determines whether to return a PEAR_Error object, or use the PEAR_ErrorStack
 347      * @param string Name of Error Stack class to use.
 348      */
 349     function PEAR_PackageFile_v1()
 350     {
 351         $this->_stack = &new PEAR_ErrorStack('PEAR_PackageFile_v1');
 352         $this->_stack->setErrorMessageTemplate($this->_getErrorMessage());
 353         $this->_isValid = 0;
 354     }
 355
 356     function installBinary($installer)
 357     {
 358         return false;
 359     }
 360
 361     function isExtension($name)
 362     {
 363         return false;
 364     }
 365
 366     function setConfig(&$config)
 367     {
 368         $this->_config = &$config;
 369         $this->_registry = &$config->getRegistry();
 370     }
 371
 372     function setRequestedGroup()
 373     {
 374         // placeholder
 375     }
 376
 377     /**
 378      * For saving in the registry.
 379      *
 380      * Set the last version that was installed
 381      * @param string
 382      */
 383     function setLastInstalledVersion($version)
 384     {
 385         $this->_packageInfo['_lastversion'] = $version;
 386     }
 387
 388     /**
 389      * @return string|false
 390      */
 391     function getLastInstalledVersion()
 392     {
 393         if (isset($this->_packageInfo['_lastversion'])) {
 394             return $this->_packageInfo['_lastversion'];
 395         }
 396         return false;
 397     }
 398
 399     function getInstalledBinary()
 400     {
 401         return false;
 402     }
 403
 404     function listPostinstallScripts()
 405     {
 406         return false;
 407     }
 408
 409     function initPostinstallScripts()
 410     {
 411         return false;
 412     }
 413
 414     function setLogger(&$logger)
 415     {
 416         if ($logger && (!is_object($logger) || !method_exists($logger, 'log'))) {
 417             return PEAR::raiseError('Logger must be compatible with PEAR_Common::log');
 418         }
 419         $this->_logger = &$logger;
 420     }
 421
 422     function setPackagefile($file, $archive = false)
 423     {
 424         $this->_packageFile = $file;
 425         $this->_archiveFile = $archive ? $archive : $file;
 426     }
 427
 428     function getPackageFile()
 429     {
 430         return isset($this->_packageFile) ? $this->_packageFile : false;
 431     }
 432
 433     function getPackageType()
 434     {
 435         return 'php';
 436     }
 437
 438     function getArchiveFile()
 439     {
 440         return $this->_archiveFile;
 441     }
 442
 443     function packageInfo($field)
 444     {
 445         if (!is_string($field) || empty($field) ||
 446             !isset($this->_packageInfo[$field])) {
 447             return false;
 448         }
 449         return $this->_packageInfo[$field];
 450     }
 451
 452     function setDirtree($path)
 453     {
 454         if (!isset($this->_packageInfo['dirtree'])) {
 455             $this->_packageInfo['dirtree'] = array();
 456         }
 457         $this->_packageInfo['dirtree'][$path] = true;
 458     }
 459
 460     function getDirtree()
 461     {
 462         if (isset($this->_packageInfo['dirtree']) && count($this->_packageInfo['dirtree'])) {
 463             return $this->_packageInfo['dirtree'];
 464         }
 465         return false;
 466     }
 467
 468     function resetDirtree()
 469     {
 470         unset($this->_packageInfo['dirtree']);
 471     }
 472
 473     function fromArray($pinfo)
 474     {
 475         $this->_incomplete = false;
 476         $this->_packageInfo = $pinfo;
 477     }
 478
 479     function isIncomplete()
 480     {
 481         return $this->_incomplete;
 482     }
 483
 484     function getChannel()
 485     {
 486         return 'pear.php.net';
 487     }
 488
 489     function getUri()
 490     {
 491         return false;
 492     }
 493
 494     function getTime()
 495     {
 496         return false;
 497     }
 498
 499     function getExtends()
 500     {
 501         if (isset($this->_packageInfo['extends'])) {
 502             return $this->_packageInfo['extends'];
 503         }
 504         return false;
 505     }
 506
 507     /**
 508      * @return array
 509      */
 510     function toArray()
 511     {
 512         if (!$this->validate(PEAR_VALIDATE_NORMAL)) {
 513             return false;
 514         }
 515         return $this->getArray();
 516     }
 517
 518     function getArray()
 519     {
 520         return $this->_packageInfo;
 521     }
 522
 523     function getName()
 524     {
 525         return $this->getPackage();
 526     }
 527
 528     function getPackage()
 529     {
 530         if (isset($this->_packageInfo['package'])) {
 531             return $this->_packageInfo['package'];
 532         }
 533         return false;
 534     }
 535
 536     /**
 537      * WARNING - don't use this unless you know what you are doing
 538      */
 539     function setRawPackage($package)
 540     {
 541         $this->_packageInfo['package'] = $package;
 542     }
 543
 544     function setPackage($package)
 545     {
 546         $this->_packageInfo['package'] = $package;
 547         $this->_isValid = false;
 548     }
 549
 550     function getVersion()
 551     {
 552         if (isset($this->_packageInfo['version'])) {
 553             return $this->_packageInfo['version'];
 554         }
 555         return false;
 556     }
 557
 558     function setVersion($version)
 559     {
 560         $this->_packageInfo['version'] = $version;
 561         $this->_isValid = false;
 562     }
 563
 564     function clearMaintainers()
 565     {
 566         unset($this->_packageInfo['maintainers']);
 567     }
 568
 569     function getMaintainers()
 570     {
 571         if (isset($this->_packageInfo['maintainers'])) {
 572             return $this->_packageInfo['maintainers'];
 573         }
 574         return false;
 575     }
 576
 577     /**
 578      * Adds a new maintainer - no checking of duplicates is performed, use
 579      * updatemaintainer for that purpose.
 580      */
 581     function addMaintainer($role, $handle, $name, $email)
 582     {
 583         $this->_packageInfo['maintainers'][] =
 584             array('handle' => $handle, 'role' => $role, 'email' => $email, 'name' => $name);
 585         $this->_isValid = false;
 586     }
 587
 588     function updateMaintainer($role, $handle, $name, $email)
 589     {
 590         $found = false;
 591         if (!isset($this->_packageInfo['maintainers']) ||
 592               !is_array($this->_packageInfo['maintainers'])) {
 593             return $this->addMaintainer($role, $handle, $name, $email);
 594         }
 595         foreach ($this->_packageInfo['maintainers'] as $i => $maintainer) {
 596             if ($maintainer['handle'] == $handle) {
 597                 $found = $i;
 598                 break;
 599             }
 600         }
 601         if ($found !== false) {
 602             unset($this->_packageInfo['maintainers'][$found]);
 603             $this->_packageInfo['maintainers'] =
 604                 array_values($this->_packageInfo['maintainers']);
 605         }
 606         $this->addMaintainer($role, $handle, $name, $email);
 607     }
 608
 609     function deleteMaintainer($handle)
 610     {
 611         $found = false;
 612         foreach ($this->_packageInfo['maintainers'] as $i => $maintainer) {
 613             if ($maintainer['handle'] == $handle) {
 614                 $found = $i;
 615                 break;
 616             }
 617         }
 618         if ($found !== false) {
 619             unset($this->_packageInfo['maintainers'][$found]);
 620             $this->_packageInfo['maintainers'] =
 621                 array_values($this->_packageInfo['maintainers']);
 622             return true;
 623         }
 624         return false;
 625     }
 626
 627     function getState()
 628     {
 629         if (isset($this->_packageInfo['release_state'])) {
 630             return $this->_packageInfo['release_state'];
 631         }
 632         return false;
 633     }
 634
 635     function setRawState($state)
 636     {
 637         $this->_packageInfo['release_state'] = $state;
 638     }
 639
 640     function setState($state)
 641     {
 642         $this->_packageInfo['release_state'] = $state;
 643         $this->_isValid = false;
 644     }
 645
 646     function getDate()
 647     {
 648         if (isset($this->_packageInfo['release_date'])) {
 649             return $this->_packageInfo['release_date'];
 650         }
 651         return false;
 652     }
 653
 654     function setDate($date)
 655     {
 656         $this->_packageInfo['release_date'] = $date;
 657         $this->_isValid = false;
 658     }
 659
 660     function getLicense()
 661     {
 662         if (isset($this->_packageInfo['release_license'])) {
 663             return $this->_packageInfo['release_license'];
 664         }
 665         return false;
 666     }
 667
 668     function setLicense($date)
 669     {
 670         $this->_packageInfo['release_license'] = $date;
 671         $this->_isValid = false;
 672     }
 673
 674     function getSummary()
 675     {
 676         if (isset($this->_packageInfo['summary'])) {
 677             return $this->_packageInfo['summary'];
 678         }
 679         return false;
 680     }
 681
 682     function setSummary($summary)
 683     {
 684         $this->_packageInfo['summary'] = $summary;
 685         $this->_isValid = false;
 686     }
 687
 688     function getDescription()
 689     {
 690         if (isset($this->_packageInfo['description'])) {
 691             return $this->_packageInfo['description'];
 692         }
 693         return false;
 694     }
 695
 696     function setDescription($desc)
 697     {
 698         $this->_packageInfo['description'] = $desc;
 699         $this->_isValid = false;
 700     }
 701
 702     function getNotes()
 703     {
 704         if (isset($this->_packageInfo['release_notes'])) {
 705             return $this->_packageInfo['release_notes'];
 706         }
 707         return false;
 708     }
 709
 710     function setNotes($notes)
 711     {
 712         $this->_packageInfo['release_notes'] = $notes;
 713         $this->_isValid = false;
 714     }
 715
 716     function getDeps()
 717     {
 718         if (isset($this->_packageInfo['release_deps'])) {
 719             return $this->_packageInfo['release_deps'];
 720         }
 721         return false;
 722     }
 723
 724     /**
 725      * Reset dependencies prior to adding new ones
 726      */
 727     function clearDeps()
 728     {
 729         unset($this->_packageInfo['release_deps']);
 730     }
 731
 732     function addPhpDep($version, $rel)
 733     {
 734         $this->_isValid = false;
 735         $this->_packageInfo['release_deps'][] =
 736             array('type' => 'php',
 737                   'rel' => $rel,
 738                   'version' => $version);
 739     }
 740
 741     function addPackageDep($name, $version, $rel, $optional = 'no')
 742     {
 743         $this->_isValid = false;
 744         $dep =
 745             array('type' => 'pkg',
 746                   'name' => $name,
 747                   'rel' => $rel,
 748                   'optional' => $optional);
 749         if ($rel != 'has' && $rel != 'not') {
 750             $dep['version'] = $version;
 751         }
 752         $this->_packageInfo['release_deps'][] = $dep;
 753     }
 754
 755     function addExtensionDep($name, $version, $rel, $optional = 'no')
 756     {
 757         $this->_isValid = false;
 758         $this->_packageInfo['release_deps'][] =
 759             array('type' => 'ext',
 760                   'name' => $name,
 761                   'rel' => $rel,
 762                   'version' => $version,
 763                   'optional' => $optional);
 764     }
 765
 766     /**
 767      * WARNING - do not use this function directly unless you know what you're doing
 768      */
 769     function setDeps($deps)
 770     {
 771         $this->_packageInfo['release_deps'] = $deps;
 772     }
 773
 774     function hasDeps()
 775     {
 776         return isset($this->_packageInfo['release_deps']) &&
 777             count($this->_packageInfo['release_deps']);
 778     }
 779
 780     function getDependencyGroup($group)
 781     {
 782         return false;
 783     }
 784
 785     function isCompatible($pf)
 786     {
 787         return false;
 788     }
 789
 790     function isSubpackageOf($p)
 791     {
 792         return $p->isSubpackage($this);
 793     }
 794
 795     function isSubpackage($p)
 796     {
 797         return false;
 798     }
 799
 800     function dependsOn($package, $channel)
 801     {
 802         if (strtolower($channel) != 'pear.php.net') {
 803             return false;
 804         }
 805         if (!($deps = $this->getDeps())) {
 806             return false;
 807         }
 808         foreach ($deps as $dep) {
 809             if ($dep['type'] != 'pkg') {
 810                 continue;
 811             }
 812             if (strtolower($dep['name']) == strtolower($package)) {
 813                 return true;
 814             }
 815         }
 816         return false;
 817     }
 818
 819     function getConfigureOptions()
 820     {
 821         if (isset($this->_packageInfo['configure_options'])) {
 822             return $this->_packageInfo['configure_options'];
 823         }
 824         return false;
 825     }
 826
 827     function hasConfigureOptions()
 828     {
 829         return isset($this->_packageInfo['configure_options']) &&
 830             count($this->_packageInfo['configure_options']);
 831     }
 832
 833     function addConfigureOption($name, $prompt, $default = false)
 834     {
 835         $o = array('name' => $name, 'prompt' => $prompt);
 836         if ($default !== false) {
 837             $o['default'] = $default;
 838         }
 839         if (!isset($this->_packageInfo['configure_options'])) {
 840             $this->_packageInfo['configure_options'] = array();
 841         }
 842         $this->_packageInfo['configure_options'][] = $o;
 843     }
 844
 845     function clearConfigureOptions()
 846     {
 847         unset($this->_packageInfo['configure_options']);
 848     }
 849
 850     function getProvides()
 851     {
 852         if (isset($this->_packageInfo['provides'])) {
 853             return $this->_packageInfo['provides'];
 854         }
 855         return false;
 856     }
 857
 858     function getProvidesExtension()
 859     {
 860         return false;
 861     }
 862
 863     function addFile($dir, $file, $attrs)
 864     {
 865         $dir = preg_replace(array('!\\\\+!', '!/+!'), array('/', '/'), $dir);
 866         if ($dir == '/' || $dir == '') {
 867             $dir = '';
 868         } else {
 869             $dir .= '/';
 870         }
 871         $file = $dir . $file;
 872         $file = preg_replace('![\\/]+!', '/', $file);
 873         $this->_packageInfo['filelist'][$file] = $attrs;
 874     }
 875
 876     function getInstallationFilelist()
 877     {
 878         return $this->getFilelist();
 879     }
 880
 881     function getFilelist()
 882     {
 883         if (isset($this->_packageInfo['filelist'])) {
 884             return $this->_packageInfo['filelist'];
 885         }
 886         return false;
 887     }
 888
 889     function setFileAttribute($file, $attr, $value)
 890     {
 891         $this->_packageInfo['filelist'][$file][$attr] = $value;
 892     }
 893
 894     function resetFilelist()
 895     {
 896         $this->_packageInfo['filelist'] = array();
 897     }
 898
 899     function setInstalledAs($file, $path)
 900     {
 901         if ($path) {
 902             return $this->_packageInfo['filelist'][$file]['installed_as'] = $path;
 903         }
 904         unset($this->_packageInfo['filelist'][$file]['installed_as']);
 905     }
 906
 907     function installedFile($file, $atts)
 908     {
 909         if (isset($this->_packageInfo['filelist'][$file])) {
 910             $this->_packageInfo['filelist'][$file] =
 911                 array_merge($this->_packageInfo['filelist'][$file], $atts);
 912         } else {
 913             $this->_packageInfo['filelist'][$file] = $atts;
 914         }
 915     }
 916
 917     function getChangelog()
 918     {
 919         if (isset($this->_packageInfo['changelog'])) {
 920             return $this->_packageInfo['changelog'];
 921         }
 922         return false;
 923     }
 924
 925     function getPackagexmlVersion()
 926     {
 927         return '1.0';
 928     }
 929
 930     /**
 931      * Wrapper to {@link PEAR_ErrorStack::getErrors()}
 932      * @param boolean determines whether to purge the error stack after retrieving
 933      * @return array
 934      */
 935     function getValidationWarnings($purge = true)
 936     {
 937         return $this->_stack->getErrors($purge);
 938     }
 939
 940     // }}}
 941     /**
 942      * Validation error.  Also marks the object contents as invalid
 943      * @param error code
 944      * @param array error information
 945      * @access private
 946      */
 947     function _validateError($code, $params = array())
 948     {
 949         $this->_stack->push($code, 'error', $params, false, false, debug_backtrace());
 950         $this->_isValid = false;
 951     }
 952
 953     /**
 954      * Validation warning.  Does not mark the object contents invalid.
 955      * @param error code
 956      * @param array error information
 957      * @access private
 958      */
 959     function _validateWarning($code, $params = array())
 960     {
 961         $this->_stack->push($code, 'warning', $params, false, false, debug_backtrace());
 962     }
 963
 964     /**
 965      * @param integer error code
 966      * @access protected
 967      */
 968     function _getErrorMessage()
 969     {
 970         return array(
 971                 PEAR_PACKAGEFILE_ERROR_NO_NAME =>
 972                     'Missing Package Name',
 973                 PEAR_PACKAGEFILE_ERROR_NO_SUMMARY =>
 974                     'No summary found',
 975                 PEAR_PACKAGEFILE_ERROR_MULTILINE_SUMMARY =>
 976                     'Summary should be on one line',
 977                 PEAR_PACKAGEFILE_ERROR_NO_DESCRIPTION =>
 978                     'Missing description',
 979                 PEAR_PACKAGEFILE_ERROR_NO_LICENSE =>
 980                     'Missing license',
 981                 PEAR_PACKAGEFILE_ERROR_NO_VERSION =>
 982                     'No release version found',
 983                 PEAR_PACKAGEFILE_ERROR_NO_STATE =>
 984                     'No release state found',
 985                 PEAR_PACKAGEFILE_ERROR_NO_DATE =>
 986                     'No release date found',
 987                 PEAR_PACKAGEFILE_ERROR_NO_NOTES =>
 988                     'No release notes found',
 989                 PEAR_PACKAGEFILE_ERROR_NO_LEAD =>
 990                     'Package must have at least one lead maintainer',
 991                 PEAR_PACKAGEFILE_ERROR_NO_MAINTAINERS =>
 992                     'No maintainers found, at least one must be defined',
 993                 PEAR_PACKAGEFILE_ERROR_NO_MAINTHANDLE =>
 994                     'Maintainer %index% has no handle (user ID at channel server)',
 995                 PEAR_PACKAGEFILE_ERROR_NO_MAINTROLE =>
 996                     'Maintainer %index% has no role',
 997                 PEAR_PACKAGEFILE_ERROR_NO_MAINTNAME =>
 998                     'Maintainer %index% has no name',
 999                 PEAR_PACKAGEFILE_ERROR_NO_MAINTEMAIL =>
1000                     'Maintainer %index% has no email',
1001                 PEAR_PACKAGEFILE_ERROR_NO_DEPNAME =>
1002                     'Dependency %index% is not a php dependency, and has no name',
1003                 PEAR_PACKAGEFILE_ERROR_NO_DEPREL =>
1004                     'Dependency %index% has no relation (rel)',
1005                 PEAR_PACKAGEFILE_ERROR_NO_DEPTYPE =>
1006                     'Dependency %index% has no type',
1007                 PEAR_PACKAGEFILE_ERROR_DEPNAME_IGNORED =>
1008                     'PHP Dependency %index% has a name attribute of "%name%" which will be' .
1009                         ' ignored!',
1010                 PEAR_PACKAGEFILE_ERROR_NO_DEPVERSION =>
1011                     'Dependency %index% is not a rel="has" or rel="not" dependency, ' .
1012                         'and has no version',
1013                 PEAR_PACKAGEFILE_ERROR_NO_DEPPHPVERSION =>
1014                     'Dependency %index% is a type="php" dependency, ' .
1015                         'and has no version',
1016                 PEAR_PACKAGEFILE_ERROR_DEPVERSION_IGNORED =>
1017                     'Dependency %index% is a rel="%rel%" dependency, versioning is ignored',
1018                 PEAR_PACKAGEFILE_ERROR_INVALID_DEPOPTIONAL =>
1019                     'Dependency %index% has invalid optional value "%opt%", should be yes or no',
1020                 PEAR_PACKAGEFILE_PHP_NO_NOT =>
1021                     'Dependency %index%: php dependencies cannot use "not" rel, use "ne"' .
1022                         ' to exclude specific versions',
1023                 PEAR_PACKAGEFILE_ERROR_NO_CONFNAME =>
1024                     'Configure Option %index% has no name',
1025                 PEAR_PACKAGEFILE_ERROR_NO_CONFPROMPT =>
1026                     'Configure Option %index% has no prompt',
1027                 PEAR_PACKAGEFILE_ERROR_NO_FILES =>
1028                     'No files in <filelist> section of package.xml',
1029                 PEAR_PACKAGEFILE_ERROR_NO_FILEROLE =>
1030                     'File "%file%" has no role, expecting one of "%roles%"',
1031                 PEAR_PACKAGEFILE_ERROR_INVALID_FILEROLE =>
1032                     'File "%file%" has invalid role "%role%", expecting one of "%roles%"',
1033                 PEAR_PACKAGEFILE_ERROR_INVALID_FILENAME =>
1034                     'File "%file%" cannot start with ".", cannot package or install',
1035                 PEAR_PACKAGEFILE_ERROR_INVALID_PHPFILE =>
1036                     'Parser error: invalid PHP found in file "%file%"',
1037                 PEAR_PACKAGEFILE_ERROR_NO_PNAME_PREFIX =>
1038                     'in %file%: %type% "%name%" not prefixed with package name "%package%"',
1039                 PEAR_PACKAGEFILE_ERROR_INVALID_FILE =>
1040                     'Parser error: invalid PHP file "%file%"',
1041                 PEAR_PACKAGEFILE_ERROR_CHANNELVAL =>
1042                     'Channel validator error: field "%field%" - %reason%',
1043                 PEAR_PACKAGEFILE_ERROR_PHP5 =>
1044                     'Error, PHP5 token encountered in %file%, analysis should be in PHP5',
1045                 PEAR_PACKAGEFILE_ERROR_FILE_NOTFOUND =>
1046                     'File "%file%" in package.xml does not exist',
1047                 PEAR_PACKAGEFILE_ERROR_NON_ISO_CHARS =>
1048                     'Package.xml contains non-ISO-8859-1 characters, and may not validate',
1049             );
1050     }
1051
1052     /**
1053      * Validate XML package definition file.
1054      *
1055      * @access public
1056      * @return boolean
1057      */
1058     function validate($state = PEAR_VALIDATE_NORMAL, $nofilechecking = false)
1059     {
1060         if (($this->_isValid & $state) == $state) {
1061             return true;
1062         }
1063         $this->_isValid = true;
1064         $info = $this->_packageInfo;
1065         if (empty($info['package'])) {
1066             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_NAME);
1067             $this->_packageName = $pn = 'unknown';
1068         } else {
1069             $this->_packageName = $pn = $info['package'];
1070         }
1071
1072         if (empty($info['summary'])) {
1073             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_SUMMARY);
1074         } elseif (strpos(trim($info['summary']), "\n") !== false) {
1075             $this->_validateWarning(PEAR_PACKAGEFILE_ERROR_MULTILINE_SUMMARY,
1076                 array('summary' => $info['summary']));
1077         }
1078         if (empty($info['description'])) {
1079             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_DESCRIPTION);
1080         }
1081         if (empty($info['release_license'])) {
1082             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_LICENSE);
1083         }
1084         if (empty($info['version'])) {
1085             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_VERSION);
1086         }
1087         if (empty($info['release_state'])) {
1088             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_STATE);
1089         }
1090         if (empty($info['release_date'])) {
1091             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_DATE);
1092         }
1093         if (empty($info['release_notes'])) {
1094             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_NOTES);
1095         }
1096         if (empty($info['maintainers'])) {
1097             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_MAINTAINERS);
1098         } else {
1099             $haslead = false;
1100             $i = 1;
1101             foreach ($info['maintainers'] as $m) {
1102                 if (empty($m['handle'])) {
1103                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_MAINTHANDLE,
1104                         array('index' => $i));
1105                 }
1106                 if (empty($m['role'])) {
1107                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_MAINTROLE,
1108                         array('index' => $i, 'roles' => PEAR_Common::getUserRoles()));
1109                 } elseif ($m['role'] == 'lead') {
1110                     $haslead = true;
1111                 }
1112                 if (empty($m['name'])) {
1113                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_MAINTNAME,
1114                         array('index' => $i));
1115                 }
1116                 if (empty($m['email'])) {
1117                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_MAINTEMAIL,
1118                         array('index' => $i));
1119                 }
1120                 $i++;
1121             }
1122             if (!$haslead) {
1123                 $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_LEAD);
1124             }
1125         }
1126         if (!empty($info['release_deps'])) {
1127             $i = 1;
1128             foreach ($info['release_deps'] as $d) {
1129                 if (!isset($d['type']) || empty($d['type'])) {
1130                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_DEPTYPE,
1131                         array('index' => $i, 'types' => PEAR_Common::getDependencyTypes()));
1132                     continue;
1133                 }
1134                 if (!isset($d['rel']) || empty($d['rel'])) {
1135                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_DEPREL,
1136                         array('index' => $i, 'rels' => PEAR_Common::getDependencyRelations()));
1137                     continue;
1138                 }
1139                 if (!empty($d['optional'])) {
1140                     if (!in_array($d['optional'], array('yes', 'no'))) {
1141                         $this->_validateError(PEAR_PACKAGEFILE_ERROR_INVALID_DEPOPTIONAL,
1142                             array('index' => $i, 'opt' => $d['optional']));
1143                     }
1144                 }
1145                 if ($d['rel'] != 'has' && $d['rel'] != 'not' && empty($d['version'])) {
1146                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_DEPVERSION,
1147                         array('index' => $i));
1148                 } elseif (($d['rel'] == 'has' || $d['rel'] == 'not') && !empty($d['version'])) {
1149                     $this->_validateWarning(PEAR_PACKAGEFILE_ERROR_DEPVERSION_IGNORED,
1150                         array('index' => $i, 'rel' => $d['rel']));
1151                 }
1152                 if ($d['type'] == 'php' && !empty($d['name'])) {
1153                     $this->_validateWarning(PEAR_PACKAGEFILE_ERROR_DEPNAME_IGNORED,
1154                         array('index' => $i, 'name' => $d['name']));
1155                 } elseif ($d['type'] != 'php' && empty($d['name'])) {
1156                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_DEPNAME,
1157                         array('index' => $i));
1158                 }
1159                 if ($d['type'] == 'php' && empty($d['version'])) {
1160                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_DEPPHPVERSION,
1161                         array('index' => $i));
1162                 }
1163                 if (($d['rel'] == 'not') && ($d['type'] == 'php')) {
1164                     $this->_validateError(PEAR_PACKAGEFILE_PHP_NO_NOT,
1165                         array('index' => $i));
1166                 }
1167                 $i++;
1168             }
1169         }
1170         if (!empty($info['configure_options'])) {
1171             $i = 1;
1172             foreach ($info['configure_options'] as $c) {
1173                 if (empty($c['name'])) {
1174                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_CONFNAME,
1175                         array('index' => $i));
1176                 }
1177                 if (empty($c['prompt'])) {
1178                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_CONFPROMPT,
1179                         array('index' => $i));
1180                 }
1181                 $i++;
1182             }
1183         }
1184         if (empty($info['filelist'])) {
1185             $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_FILES);
1186             $errors[] = 'no files';
1187         } else {
1188             foreach ($info['filelist'] as $file => $fa) {
1189                 if (empty($fa['role'])) {
1190                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_NO_FILEROLE,
1191                         array('file' => $file, 'roles' => PEAR_Common::getFileRoles()));
1192                     continue;
1193                 } elseif (!in_array($fa['role'], PEAR_Common::getFileRoles())) {
1194                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_INVALID_FILEROLE,
1195                         array('file' => $file, 'role' => $fa['role'], 'roles' => PEAR_Common::getFileRoles()));
1196                 }
1197                 if (preg_match('~/\.\.?(/|\\z)|^\.\.?/~', str_replace('\\', '/', $file))) {
1198                     // file contains .. parent directory or . cur directory references
1199                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_INVALID_FILENAME,
1200                         array('file' => $file));
1201                 }
1202                 if (isset($fa['install-as']) &&
1203                       preg_match('~/\.\.?(/|\\z)|^\.\.?/~',
1204                                  str_replace('\\', '/', $fa['install-as']))) {
1205                     // install-as contains .. parent directory or . cur directory references
1206                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_INVALID_FILENAME,
1207                         array('file' => $file . ' [installed as ' . $fa['install-as'] . ']'));
1208                 }
1209                 if (isset($fa['baseinstalldir']) &&
1210                       preg_match('~/\.\.?(/|\\z)|^\.\.?/~',
1211                                  str_replace('\\', '/', $fa['baseinstalldir']))) {
1212                     // install-as contains .. parent directory or . cur directory references
1213                     $this->_validateError(PEAR_PACKAGEFILE_ERROR_INVALID_FILENAME,
1214                         array('file' => $file . ' [baseinstalldir ' . $fa['baseinstalldir'] . ']'));
1215                 }
1216             }
1217         }
1218         if (isset($this->_registry) && $this->_isValid) {
1219             $chan = $this->_registry->getChannel('pear.php.net');
1220             if (PEAR::isError($chan)) {
1221                 $this->_validateError(PEAR_PACKAGEFILE_ERROR_CHANNELVAL, $chan->getMessage());
1222                 return $this->_isValid = 0;
1223             }
1224             $validator = $chan->getValidationObject();
1225             $validator->setPackageFile($this);
1226             $validator->validate($state);
1227             $failures = $validator->getFailures();
1228             foreach ($failures['errors'] as $error) {
1229                 $this->_validateError(PEAR_PACKAGEFILE_ERROR_CHANNELVAL, $error);
1230             }
1231             foreach ($failures['warnings'] as $warning) {
1232                 $this->_validateWarning(PEAR_PACKAGEFILE_ERROR_CHANNELVAL, $warning);
1233             }
1234         }
1235         if ($this->_isValid && $state == PEAR_VALIDATE_PACKAGING && !$nofilechecking) {
1236             if ($this->_analyzePhpFiles()) {
1237                 $this->_isValid = true;
1238             }
1239         }
1240         if ($this->_isValid) {
1241             return $this->_isValid = $state;
1242         }
1243         return $this->_isValid = 0;
1244     }
1245
1246     function _analyzePhpFiles()
1247     {
1248         if (!$this->_isValid) {
1249             return false;
1250         }
1251         if (!isset($this->_packageFile)) {
1252             return false;
1253         }
1254         $dir_prefix = dirname($this->_packageFile);
1255         $common = new PEAR_Common;
1256         $log = isset($this->_logger) ? array(&$this->_logger, 'log') :
1257             array($common, 'log');
1258         $info = $this->getFilelist();
1259         foreach ($info as $file => $fa) {
1260             if (!file_exists($dir_prefix . DIRECTORY_SEPARATOR . $file)) {
1261                 $this->_validateError(PEAR_PACKAGEFILE_ERROR_FILE_NOTFOUND,
1262                     array('file' => realpath($dir_prefix) . DIRECTORY_SEPARATOR . $file));
1263                 continue;
1264             }
1265             if ($fa['role'] == 'php' && $dir_prefix) {
1266                 call_user_func_array($log, array(1, "Analyzing $file"));
1267                 $srcinfo = $this->_analyzeSourceCode($dir_prefix . DIRECTORY_SEPARATOR . $file);
1268                 if ($srcinfo) {
1269                     $this->_buildProvidesArray($srcinfo);
1270                 }
1271             }
1272         }
1273         $this->_packageName = $pn = $this->getPackage();
1274         $pnl = strlen($pn);
1275         if (isset($this->_packageInfo['provides'])) {
1276             foreach ((array) $this->_packageInfo['provides'] as $key => $what) {
1277                 if (isset($what['explicit'])) {
1278                     // skip conformance checks if the provides entry is
1279                     // specified in the package.xml file
1280                     continue;
1281                 }
1282                 extract($what);
1283                 if ($type == 'class') {
1284                     if (!strncasecmp($name, $pn, $pnl)) {
1285                         continue;
1286                     }
1287                     $this->_validateWarning(PEAR_PACKAGEFILE_ERROR_NO_PNAME_PREFIX,
1288                         array('file' => $file, 'type' => $type, 'name' => $name, 'package' => $pn));
1289                 } elseif ($type == 'function') {
1290                     if (strstr($name, '::') || !strncasecmp($name, $pn, $pnl)) {
1291                         continue;
1292                     }
1293                     $this->_validateWarning(PEAR_PACKAGEFILE_ERROR_NO_PNAME_PREFIX,
1294                         array('file' => $file, 'type' => $type, 'name' => $name, 'package' => $pn));
1295                 }
1296             }
1297         }
1298         return $this->_isValid;
1299     }
1300
1301     /**
1302      * Get the default xml generator object
1303      *
1304      * @return PEAR_PackageFile_Generator_v1
1305      */
1306     function &getDefaultGenerator()
1307     {
1308         if (!class_exists('PEAR_PackageFile_Generator_v1')) {
1309             require_once 'PEAR/PackageFile/Generator/v1.php';
1310         }
1311         $a = &new PEAR_PackageFile_Generator_v1($this);
1312         return $a;
1313     }
1314
1315     /**
1316      * Get the contents of a file listed within the package.xml
1317      * @param string
1318      * @return string
1319      */
1320     function getFileContents($file)
1321     {
1322         if ($this->_archiveFile == $this->_packageFile) { // unpacked
1323             $dir = dirname($this->_packageFile);
1324             $file = $dir . DIRECTORY_SEPARATOR . $file;
1325             $file = str_replace(array('/', '\\'),
1326                 array(DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR), $file);
1327             if (file_exists($file) && is_readable($file)) {
1328                 return implode('', file($file));
1329             }
1330         } else { // tgz
1331             if (!class_exists('Archive_Tar')) {
1332                 require_once 'Archive/Tar.php';
1333             }
1334             $tar = &new Archive_Tar($this->_archiveFile);
1335             $tar->pushErrorHandling(PEAR_ERROR_RETURN);
1336             if ($file != 'package.xml' && $file != 'package2.xml') {
1337                 $file = $this->getPackage() . '-' . $this->getVersion() . '/' . $file;
1338             }
1339             $file = $tar->extractInString($file);
1340             $tar->popErrorHandling();
1341             if (PEAR::isError($file)) {
1342                 return PEAR::raiseError("Cannot locate file '$file' in archive");
1343             }
1344             return $file;
1345         }
1346     }
1347
1348     // {{{ analyzeSourceCode()
1349     /**
1350      * Analyze the source code of the given PHP file
1351      *
1352      * @param  string Filename of the PHP file
1353      * @return mixed
1354      * @access private
1355      */
1356     function _analyzeSourceCode($file)
1357     {
1358         if (!function_exists("token_get_all")) {
1359             return false;
1360         }
1361         if (!defined('T_DOC_COMMENT')) {
1362             define('T_DOC_COMMENT', T_COMMENT);
1363         }
1364         if (!defined('T_INTERFACE')) {
1365             define('T_INTERFACE', -1);
1366         }
1367         if (!defined('T_IMPLEMENTS')) {
1368             define('T_IMPLEMENTS', -1);
1369         }
1370         if (!$fp = @fopen($file, "r")) {
1371             return false;
1372         }
1373         fclose($fp);
1374         $contents = file_get_contents($file);
1375         $tokens = token_get_all($contents);
1376 /*
1377         for ($i = 0; $i < sizeof($tokens); $i++) {
1378             @list($token, $data) = $tokens[$i];
1379             if (is_string($token)) {
1380                 var_dump($token);
1381             } else {
1382                 print token_name($token) . ' ';
1383                 var_dump(rtrim($data));
1384             }
1385         }
1386 */
1387         $look_for = 0;
1388         $paren_level = 0;
1389         $bracket_level = 0;
1390         $brace_level = 0;
1391         $lastphpdoc = '';
1392         $current_class = '';
1393         $current_interface = '';
1394         $current_class_level = -1;
1395         $current_function = '';
1396         $current_function_level = -1;
1397         $declared_classes = array();
1398         $declared_interfaces = array();
1399         $declared_functions = array();
1400         $declared_methods = array();
1401         $used_classes = array();
1402         $used_functions = array();
1403         $extends = array();
1404         $implements = array();
1405         $nodeps = array();
1406         $inquote = false;
1407         $interface = false;
1408         for ($i = 0; $i < sizeof($tokens); $i++) {
1409             if (is_array($tokens[$i])) {
1410                 list($token, $data) = $tokens[$i];
1411             } else {
1412                 $token = $tokens[$i];
1413                 $data = '';
1414             }
1415             if ($inquote) {
1416                 if ($token != '"' && $token != T_END_HEREDOC) {
1417                     continue;
1418                 } else {
1419                     $inquote = false;
1420                     continue;
1421                 }
1422             }
1423             switch ($token) {
1424                 case T_WHITESPACE :
1425                     continue;
1426                 case ';':
1427                     if ($interface) {
1428                         $current_function = '';
1429                         $current_function_level = -1;
1430                     }
1431                     break;
1432                 case '"':
1433                 case T_START_HEREDOC:
1434                     $inquote = true;
1435                     break;
1436                 case T_CURLY_OPEN:
1437                 case T_DOLLAR_OPEN_CURLY_BRACES:
1438                 case '{': $brace_level++; continue 2;
1439                 case '}':
1440                     $brace_level--;
1441                     if ($current_class_level == $brace_level) {
1442                         $current_class = '';
1443                         $current_class_level = -1;
1444                     }
1445                     if ($current_function_level == $brace_level) {
1446                         $current_function = '';
1447                         $current_function_level = -1;
1448                     }
1449                     continue 2;
1450                 case '[': $bracket_level++; continue 2;
1451                 case ']': $bracket_level--; continue 2;
1452                 case '(': $paren_level++;   continue 2;
1453                 case ')': $paren_level--;   continue 2;
1454                 case T_INTERFACE:
1455                     $interface = true;
1456                 case T_CLASS:
1457                     if (($current_class_level != -1) || ($current_function_level != -1)) {
1458                         $this->_validateError(PEAR_PACKAGEFILE_ERROR_INVALID_PHPFILE,
1459                             array('file' => $file));
1460                         return false;
1461                     }
1462                 case T_FUNCTION:
1463                 case T_NEW:
1464                 case T_EXTENDS:
1465                 case T_IMPLEMENTS:
1466                     $look_for = $token;
1467                     continue 2;
1468                 case T_STRING:
1469                     if (version_compare(zend_version(), '2.0', '<')) {
1470                         if (in_array(strtolower($data),
1471                             array('public', 'private', 'protected', 'abstract',
1472                                   'interface', 'implements', 'throw')
1473                                  )) {
1474                             $this->_validateWarning(PEAR_PACKAGEFILE_ERROR_PHP5,
1475                                 array($file));
1476                         }
1477                     }
1478                     if ($look_for == T_CLASS) {
1479                         $current_class = $data;
1480                         $current_class_level = $brace_level;
1481                         $declared_classes[] = $current_class;
1482                     } elseif ($look_for == T_INTERFACE) {
1483                         $current_interface = $data;
1484                         $current_class_level = $brace_level;
1485                         $declared_interfaces[] = $current_interface;
1486                     } elseif ($look_for == T_IMPLEMENTS) {
1487                         $implements[$current_class] = $data;
1488                     } elseif ($look_for == T_EXTENDS) {
1489                         $extends[$current_class] = $data;
1490                     } elseif ($look_for == T_FUNCTION) {
1491                         if ($current_class) {
1492                             $current_function = "$current_class::$data";
1493                             $declared_methods[$current_class][] = $data;
1494                         } elseif ($current_interface) {
1495                             $current_function = "$current_interface::$data";
1496                             $declared_methods[$current_interface][] = $data;
1497                         } else {
1498                             $current_function = $data;
1499                             $declared_functions[] = $current_function;
1500                         }
1501                         $current_function_level = $brace_level;
1502                         $m = array();
1503                     } elseif ($look_for == T_NEW) {
1504                         $used_classes[$data] = true;
1505                     }
1506                     $look_for = 0;
1507                     continue 2;
1508                 case T_VARIABLE:
1509                     $look_for = 0;
1510                     continue 2;
1511                 case T_DOC_COMMENT:
1512                 case T_COMMENT:
1513                     if (preg_match('!^/\*\*\s!', $data)) {
1514                         $lastphpdoc = $data;
1515                         if (preg_match_all('/@nodep\s+(\S+)/', $lastphpdoc, $m)) {
1516                             $nodeps = array_merge($nodeps, $m[1]);
1517                         }
1518                     }
1519                     continue 2;
1520                 case T_DOUBLE_COLON:
1521                     if (!($tokens[$i - 1][0] == T_WHITESPACE || $tokens[$i - 1][0] == T_STRING)) {
1522                         $this->_validateError(PEAR_PACKAGEFILE_ERROR_INVALID_PHPFILE,
1523                             array('file' => $file));
1524                         return false;
1525                     }
1526                     $class = $tokens[$i - 1][1];
1527                     if (strtolower($class) != 'parent') {
1528                         $used_classes[$class] = true;
1529                     }
1530                     continue 2;
1531             }
1532         }
1533         return array(
1534             "source_file" => $file,
1535             "declared_classes" => $declared_classes,
1536             "declared_interfaces" => $declared_interfaces,
1537             "declared_methods" => $declared_methods,
1538             "declared_functions" => $declared_functions,
1539             "used_classes" => array_diff(array_keys($used_classes), $nodeps),
1540             "inheritance" => $extends,
1541             "implements" => $implements,
1542             );
1543     }
1544
1545     /**
1546      * Build a "provides" array from data returned by
1547      * analyzeSourceCode().  The format of the built array is like
1548      * this:
1549      *
1550      *  array(
1551      *    'class;MyClass' => 'array('type' => 'class', 'name' => 'MyClass'),
1552      *    ...
1553      *  )
1554      *
1555      *
1556      * @param array $srcinfo array with information about a source file
1557      * as returned by the analyzeSourceCode() method.
1558      *
1559      * @return void
1560      *
1561      * @access private
1562      *
1563      */
1564     function _buildProvidesArray($srcinfo)
1565     {
1566         if (!$this->_isValid) {
1567             return false;
1568         }
1569         $file = basename($srcinfo['source_file']);
1570         $pn = $this->getPackage();
1571         $pnl = strlen($pn);
1572         foreach ($srcinfo['declared_classes'] as $class) {
1573             $key = "class;$class";
1574             if (isset($this->_packageInfo['provides'][$key])) {
1575                 continue;
1576             }
1577             $this->_packageInfo['provides'][$key] =
1578                 array('file'=> $file, 'type' => 'class', 'name' => $class);
1579             if (isset($srcinfo['inheritance'][$class])) {
1580                 $this->_packageInfo['provides'][$key]['extends'] =
1581                     $srcinfo['inheritance'][$class];
1582             }
1583         }
1584         foreach ($srcinfo['declared_methods'] as $class => $methods) {
1585             foreach ($methods as $method) {
1586                 $function = "$class::$method";
1587                 $key = "function;$function";
1588                 if ($method{0} == '_' || !strcasecmp($method, $class) ||
1589                     isset($this->_packageInfo['provides'][$key])) {
1590                     continue;
1591                 }
1592                 $this->_packageInfo['provides'][$key] =
1593                     array('file'=> $file, 'type' => 'function', 'name' => $function);
1594             }
1595         }
1596
1597         foreach ($srcinfo['declared_functions'] as $function) {
1598             $key = "function;$function";
1599             if ($function{0} == '_' || isset($this->_packageInfo['provides'][$key])) {
1600                 continue;
1601             }
1602             if (!strstr($function, '::') && strncasecmp($function, $pn, $pnl)) {
1603                 $warnings[] = "in1 " . $file . ": function \"$function\" not prefixed with package name \"$pn\"";
1604             }
1605             $this->_packageInfo['provides'][$key] =
1606                 array('file'=> $file, 'type' => 'function', 'name' => $function);
1607         }
1608     }
1609
1610     // }}}
1611 }
1612 ?>