interface/modules/zend_modules/library/Zend/Code/Scanner/MethodScanner.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Code\Scanner;
  11
  12 use Zend\Code\Annotation\AnnotationManager;
  13 use Zend\Code\Exception;
  14 use Zend\Code\NameInformation;
  15
  16 class MethodScanner implements ScannerInterface
  17 {
  18     /**
  19      * @var bool
  20      */
  21     protected $isScanned    = false;
  22
  23     /**
  24      * @var string
  25      */
  26     protected $docComment   = null;
  27
  28     /**
  29      * @var ClassScanner
  30      */
  31     protected $scannerClass = null;
  32
  33     /**
  34      * @var string
  35      */
  36     protected $class        = null;
  37
  38     /**
  39      * @var string
  40      */
  41     protected $name         = null;
  42
  43     /**
  44      * @var int
  45      */
  46     protected $lineStart    = null;
  47
  48     /**
  49      * @var int
  50      */
  51     protected $lineEnd      = null;
  52
  53     /**
  54      * @var bool
  55      */
  56     protected $isFinal = false;
  57
  58     /**
  59      * @var bool
  60      */
  61     protected $isAbstract = false;
  62
  63     /**
  64      * @var bool
  65      */
  66     protected $isPublic = true;
  67
  68     /**
  69      * @var bool
  70      */
  71     protected $isProtected = false;
  72
  73     /**
  74      * @var bool
  75      */
  76     protected $isPrivate = false;
  77
  78     /**
  79      * @var bool
  80      */
  81     protected $isStatic = false;
  82
  83     /**
  84      * @var string
  85      */
  86     protected $body = '';
  87
  88     /**
  89      * @var array
  90      */
  91     protected $tokens = array();
  92
  93     /**
  94      * @var NameInformation
  95      */
  96     protected $nameInformation = null;
  97
  98     /**
  99      * @var array
 100      */
 101     protected $infos = array();
 102
 103     /**
 104      * @param  array $methodTokens
 105      * @param NameInformation $nameInformation
 106      */
 107     public function __construct(array $methodTokens, NameInformation $nameInformation = null)
 108     {
 109         $this->tokens          = $methodTokens;
 110         $this->nameInformation = $nameInformation;
 111     }
 112
 113     /**
 114      * @param  string $class
 115      * @return MethodScanner
 116      */
 117     public function setClass($class)
 118     {
 119         $this->class = (string) $class;
 120         return $this;
 121     }
 122
 123     /**
 124      * @param  ClassScanner  $scannerClass
 125      * @return MethodScanner
 126      */
 127     public function setScannerClass(ClassScanner $scannerClass)
 128     {
 129         $this->scannerClass = $scannerClass;
 130         return $this;
 131     }
 132
 133     /**
 134      * @return MethodScanner
 135      */
 136     public function getClassScanner()
 137     {
 138         return $this->scannerClass;
 139     }
 140
 141     /**
 142      * @return string
 143      */
 144     public function getName()
 145     {
 146         $this->scan();
 147
 148         return $this->name;
 149     }
 150
 151     /**
 152      * @return int
 153      */
 154     public function getLineStart()
 155     {
 156         $this->scan();
 157
 158         return $this->lineStart;
 159     }
 160
 161     /**
 162      * @return int
 163      */
 164     public function getLineEnd()
 165     {
 166         $this->scan();
 167
 168         return $this->lineEnd;
 169     }
 170
 171     /**
 172      * @return string
 173      */
 174     public function getDocComment()
 175     {
 176         $this->scan();
 177
 178         return $this->docComment;
 179     }
 180
 181     /**
 182      * @param  AnnotationManager $annotationManager
 183      * @return AnnotationScanner
 184      */
 185     public function getAnnotations(AnnotationManager $annotationManager)
 186     {
 187         if (($docComment = $this->getDocComment()) == '') {
 188             return false;
 189         }
 190
 191         return new AnnotationScanner($annotationManager, $docComment, $this->nameInformation);
 192     }
 193
 194     /**
 195      * @return bool
 196      */
 197     public function isFinal()
 198     {
 199         $this->scan();
 200
 201         return $this->isFinal;
 202     }
 203
 204     /**
 205      * @return bool
 206      */
 207     public function isAbstract()
 208     {
 209         $this->scan();
 210
 211         return $this->isAbstract;
 212     }
 213
 214     /**
 215      * @return bool
 216      */
 217     public function isPublic()
 218     {
 219         $this->scan();
 220
 221         return $this->isPublic;
 222     }
 223
 224     /**
 225      * @return bool
 226      */
 227     public function isProtected()
 228     {
 229         $this->scan();
 230
 231         return $this->isProtected;
 232     }
 233
 234     /**
 235      * @return bool
 236      */
 237     public function isPrivate()
 238     {
 239         $this->scan();
 240
 241         return $this->isPrivate;
 242     }
 243
 244     /**
 245      * @return bool
 246      */
 247     public function isStatic()
 248     {
 249         $this->scan();
 250
 251         return $this->isStatic;
 252     }
 253
 254     /**
 255      * @return int
 256      */
 257     public function getNumberOfParameters()
 258     {
 259         return count($this->getParameters());
 260     }
 261
 262     /**
 263      * @param  bool $returnScanner
 264      * @return array
 265      */
 266     public function getParameters($returnScanner = false)
 267     {
 268         $this->scan();
 269
 270         $return = array();
 271
 272         foreach ($this->infos as $info) {
 273             if ($info['type'] != 'parameter') {
 274                 continue;
 275             }
 276
 277             if (!$returnScanner) {
 278                 $return[] = $info['name'];
 279             } else {
 280                 $return[] = $this->getParameter($info['name']);
 281             }
 282         }
 283
 284         return $return;
 285     }
 286
 287     /**
 288      * @param  int|string $parameterNameOrInfoIndex
 289      * @return ParameterScanner
 290      * @throws Exception\InvalidArgumentException
 291      */
 292     public function getParameter($parameterNameOrInfoIndex)
 293     {
 294         $this->scan();
 295
 296         if (is_int($parameterNameOrInfoIndex)) {
 297             $info = $this->infos[$parameterNameOrInfoIndex];
 298             if ($info['type'] != 'parameter') {
 299                 throw new Exception\InvalidArgumentException('Index of info offset is not about a parameter');
 300             }
 301         } elseif (is_string($parameterNameOrInfoIndex)) {
 302             foreach ($this->infos as $info) {
 303                 if ($info['type'] === 'parameter' && $info['name'] === $parameterNameOrInfoIndex) {
 304                     break;
 305                 }
 306                 unset($info);
 307             }
 308             if (!isset($info)) {
 309                 throw new Exception\InvalidArgumentException('Index of info offset is not about a parameter');
 310             }
 311         }
 312
 313         $p = new ParameterScanner(
 314             array_slice($this->tokens, $info['tokenStart'], $info['tokenEnd'] - $info['tokenStart']),
 315             $this->nameInformation
 316         );
 317         $p->setDeclaringFunction($this->name);
 318         $p->setDeclaringScannerFunction($this);
 319         $p->setDeclaringClass($this->class);
 320         $p->setDeclaringScannerClass($this->scannerClass);
 321         $p->setPosition($info['position']);
 322
 323         return $p;
 324     }
 325
 326     /**
 327      * @return string
 328      */
 329     public function getBody()
 330     {
 331         $this->scan();
 332
 333         return $this->body;
 334     }
 335
 336     public static function export()
 337     {
 338         // @todo
 339     }
 340
 341     public function __toString()
 342     {
 343         $this->scan();
 344
 345         return var_export($this, true);
 346     }
 347
 348     protected function scan()
 349     {
 350         if ($this->isScanned) {
 351             return;
 352         }
 353
 354         if (!$this->tokens) {
 355             throw new Exception\RuntimeException('No tokens were provided');
 356         }
 357
 358         /**
 359          * Variables & Setup
 360          */
 361
 362         $tokens       = &$this->tokens; // localize
 363         $infos        = &$this->infos; // localize
 364         $tokenIndex   = null;
 365         $token        = null;
 366         $tokenType    = null;
 367         $tokenContent = null;
 368         $tokenLine    = null;
 369         $infoIndex    = 0;
 370         $parentCount  = 0;
 371
 372         /*
 373          * MACRO creation
 374          */
 375         $MACRO_TOKEN_ADVANCE = function () use (&$tokens, &$tokenIndex, &$token, &$tokenType, &$tokenContent, &$tokenLine) {
 376             static $lastTokenArray = null;
 377             $tokenIndex = ($tokenIndex === null) ? 0 : $tokenIndex + 1;
 378             if (!isset($tokens[$tokenIndex])) {
 379                 $token        = false;
 380                 $tokenContent = false;
 381                 $tokenType    = false;
 382                 $tokenLine    = false;
 383
 384                 return false;
 385             }
 386             $token = $tokens[$tokenIndex];
 387             if (is_string($token)) {
 388                 $tokenType    = null;
 389                 $tokenContent = $token;
 390                 $tokenLine    = $tokenLine + substr_count($lastTokenArray[1],
 391                                                           "\n"); // adjust token line by last known newline count
 392             } else {
 393                 list($tokenType, $tokenContent, $tokenLine) = $token;
 394             }
 395
 396             return $tokenIndex;
 397         };
 398         $MACRO_INFO_START    = function () use (&$infoIndex, &$infos, &$tokenIndex, &$tokenLine) {
 399             $infos[$infoIndex] = array(
 400                 'type'        => 'parameter',
 401                 'tokenStart'  => $tokenIndex,
 402                 'tokenEnd'    => null,
 403                 'lineStart'   => $tokenLine,
 404                 'lineEnd'     => $tokenLine,
 405                 'name'        => null,
 406                 'position'    => $infoIndex + 1, // position is +1 of infoIndex
 407             );
 408         };
 409         $MACRO_INFO_ADVANCE  = function () use (&$infoIndex, &$infos, &$tokenIndex, &$tokenLine) {
 410             $infos[$infoIndex]['tokenEnd'] = $tokenIndex;
 411             $infos[$infoIndex]['lineEnd']  = $tokenLine;
 412             $infoIndex++;
 413
 414             return $infoIndex;
 415         };
 416
 417         /**
 418          * START FINITE STATE MACHINE FOR SCANNING TOKENS
 419          */
 420
 421         // Initialize token
 422         $MACRO_TOKEN_ADVANCE();
 423
 424         SCANNER_TOP:
 425
 426         $this->lineStart = ($this->lineStart) ? : $tokenLine;
 427
 428         switch ($tokenType) {
 429             case T_DOC_COMMENT:
 430                 $this->lineStart = null;
 431                 if ($this->docComment === null && $this->name === null) {
 432                     $this->docComment = $tokenContent;
 433                 }
 434                 goto SCANNER_CONTINUE_SIGNATURE;
 435
 436             case T_FINAL:
 437                 $this->isFinal = true;
 438                 goto SCANNER_CONTINUE_SIGNATURE;
 439
 440             case T_ABSTRACT:
 441                 $this->isAbstract = true;
 442                 goto SCANNER_CONTINUE_SIGNATURE;
 443
 444             case T_PUBLIC:
 445                 // use defaults
 446                 goto SCANNER_CONTINUE_SIGNATURE;
 447
 448             case T_PROTECTED:
 449                 $this->isProtected = true;
 450                 $this->isPublic    = false;
 451                 goto SCANNER_CONTINUE_SIGNATURE;
 452
 453             case T_PRIVATE:
 454                 $this->isPrivate = true;
 455                 $this->isPublic  = false;
 456                 goto SCANNER_CONTINUE_SIGNATURE;
 457
 458             case T_STATIC:
 459                 $this->isStatic = true;
 460                 goto SCANNER_CONTINUE_SIGNATURE;
 461
 462             case T_VARIABLE:
 463             case T_STRING:
 464
 465                 if ($tokenType === T_STRING && $parentCount === 0) {
 466                     $this->name = $tokenContent;
 467                 }
 468
 469                 if ($parentCount === 1) {
 470                     if (!isset($infos[$infoIndex])) {
 471                         $MACRO_INFO_START();
 472                     }
 473                     if ($tokenType === T_VARIABLE) {
 474                         $infos[$infoIndex]['name'] = ltrim($tokenContent, '$');
 475                     }
 476                 }
 477
 478                 goto SCANNER_CONTINUE_SIGNATURE;
 479
 480             case null:
 481
 482                 switch ($tokenContent) {
 483                     case '&':
 484                         if (!isset($infos[$infoIndex])) {
 485                             $MACRO_INFO_START();
 486                         }
 487                         goto SCANNER_CONTINUE_SIGNATURE;
 488                     case '(':
 489                         $parentCount++;
 490                         goto SCANNER_CONTINUE_SIGNATURE;
 491                     case ')':
 492                         $parentCount--;
 493                         if ($parentCount === 0) {
 494                             if ($infos) {
 495                                 $MACRO_INFO_ADVANCE();
 496                             }
 497                             $context = 'body';
 498                         }
 499                         goto SCANNER_CONTINUE_BODY;
 500                     case ',':
 501                         if ($parentCount === 1) {
 502                             $MACRO_INFO_ADVANCE();
 503                         }
 504                         goto SCANNER_CONTINUE_SIGNATURE;
 505                 }
 506         }
 507
 508         SCANNER_CONTINUE_SIGNATURE:
 509
 510         if ($MACRO_TOKEN_ADVANCE() === false) {
 511             goto SCANNER_END;
 512         }
 513         goto SCANNER_TOP;
 514
 515         SCANNER_CONTINUE_BODY:
 516
 517         $braceCount = 0;
 518         while ($MACRO_TOKEN_ADVANCE() !== false) {
 519             if ($tokenContent == '}') {
 520                 $braceCount--;
 521             }
 522             if ($braceCount > 0) {
 523                 $this->body .= $tokenContent;
 524             }
 525             if ($tokenContent == '{') {
 526                 $braceCount++;
 527             }
 528             $this->lineEnd = $tokenLine;
 529         }
 530
 531         SCANNER_END:
 532
 533         $this->isScanned = true;
 534
 535         return;
 536     }
 537 }