www.aleph1.co.uk Git - yaffs-website/blob - vendor/phpunit/php-token-stream/src/Token.php

   1 <?php
   2 /*
   3  * This file is part of the PHP_TokenStream package.
   4  *
   5  * (c) Sebastian Bergmann <sebastian@phpunit.de>
   6  *
   7  * For the full copyright and license information, please view the LICENSE
   8  * file that was distributed with this source code.
   9  */
  10
  11 /**
  12  * A PHP token.
  13  *
  14  * @author    Sebastian Bergmann <sebastian@phpunit.de>
  15  * @copyright Sebastian Bergmann <sebastian@phpunit.de>
  16  * @license   http://www.opensource.org/licenses/BSD-3-Clause  The BSD 3-Clause License
  17  * @link      http://github.com/sebastianbergmann/php-token-stream/tree
  18  * @since     Class available since Release 1.0.0
  19  */
  20 abstract class PHP_Token
  21 {
  22     /**
  23      * @var string
  24      */
  25     protected $text;
  26
  27     /**
  28      * @var integer
  29      */
  30     protected $line;
  31
  32     /**
  33      * @var PHP_Token_Stream
  34      */
  35     protected $tokenStream;
  36
  37     /**
  38      * @var integer
  39      */
  40     protected $id;
  41
  42     /**
  43      * Constructor.
  44      *
  45      * @param string           $text
  46      * @param integer          $line
  47      * @param PHP_Token_Stream $tokenStream
  48      * @param integer          $id
  49      */
  50     public function __construct($text, $line, PHP_Token_Stream $tokenStream, $id)
  51     {
  52         $this->text        = $text;
  53         $this->line        = $line;
  54         $this->tokenStream = $tokenStream;
  55         $this->id          = $id;
  56     }
  57
  58     /**
  59      * @return string
  60      */
  61     public function __toString()
  62     {
  63         return $this->text;
  64     }
  65
  66     /**
  67      * @return integer
  68      */
  69     public function getLine()
  70     {
  71         return $this->line;
  72     }
  73 }
  74
  75 abstract class PHP_TokenWithScope extends PHP_Token
  76 {
  77     /**
  78      * @var integer
  79      */
  80     protected $endTokenId;
  81
  82     /**
  83      * Get the docblock for this token
  84      *
  85      * This method will fetch the docblock belonging to the current token. The
  86      * docblock must be placed on the line directly above the token to be
  87      * recognized.
  88      *
  89      * @return string|null Returns the docblock as a string if found
  90      */
  91     public function getDocblock()
  92     {
  93         $tokens            = $this->tokenStream->tokens();
  94         $currentLineNumber = $tokens[$this->id]->getLine();
  95         $prevLineNumber    = $currentLineNumber - 1;
  96
  97         for ($i = $this->id - 1; $i; $i--) {
  98             if (!isset($tokens[$i])) {
  99                 return;
 100             }
 101
 102             if ($tokens[$i] instanceof PHP_Token_FUNCTION ||
 103                 $tokens[$i] instanceof PHP_Token_CLASS ||
 104                 $tokens[$i] instanceof PHP_Token_TRAIT) {
 105                 // Some other trait, class or function, no docblock can be
 106                 // used for the current token
 107                 break;
 108             }
 109
 110             $line = $tokens[$i]->getLine();
 111
 112             if ($line == $currentLineNumber ||
 113                 ($line == $prevLineNumber &&
 114                  $tokens[$i] instanceof PHP_Token_WHITESPACE)) {
 115                 continue;
 116             }
 117
 118             if ($line < $currentLineNumber &&
 119                 !$tokens[$i] instanceof PHP_Token_DOC_COMMENT) {
 120                 break;
 121             }
 122
 123             return (string)$tokens[$i];
 124         }
 125     }
 126
 127     /**
 128      * @return integer
 129      */
 130     public function getEndTokenId()
 131     {
 132         $block  = 0;
 133         $i      = $this->id;
 134         $tokens = $this->tokenStream->tokens();
 135
 136         while ($this->endTokenId === null && isset($tokens[$i])) {
 137             if ($tokens[$i] instanceof PHP_Token_OPEN_CURLY ||
 138                 $tokens[$i] instanceof PHP_Token_CURLY_OPEN) {
 139                 $block++;
 140             } elseif ($tokens[$i] instanceof PHP_Token_CLOSE_CURLY) {
 141                 $block--;
 142
 143                 if ($block === 0) {
 144                     $this->endTokenId = $i;
 145                 }
 146             } elseif (($this instanceof PHP_Token_FUNCTION ||
 147                 $this instanceof PHP_Token_NAMESPACE) &&
 148                 $tokens[$i] instanceof PHP_Token_SEMICOLON) {
 149                 if ($block === 0) {
 150                     $this->endTokenId = $i;
 151                 }
 152             }
 153
 154             $i++;
 155         }
 156
 157         if ($this->endTokenId === null) {
 158             $this->endTokenId = $this->id;
 159         }
 160
 161         return $this->endTokenId;
 162     }
 163
 164     /**
 165      * @return integer
 166      */
 167     public function getEndLine()
 168     {
 169         return $this->tokenStream[$this->getEndTokenId()]->getLine();
 170     }
 171 }
 172
 173 abstract class PHP_TokenWithScopeAndVisibility extends PHP_TokenWithScope
 174 {
 175     /**
 176      * @return string
 177      */
 178     public function getVisibility()
 179     {
 180         $tokens = $this->tokenStream->tokens();
 181
 182         for ($i = $this->id - 2; $i > $this->id - 7; $i -= 2) {
 183             if (isset($tokens[$i]) &&
 184                ($tokens[$i] instanceof PHP_Token_PRIVATE ||
 185                 $tokens[$i] instanceof PHP_Token_PROTECTED ||
 186                 $tokens[$i] instanceof PHP_Token_PUBLIC)) {
 187                 return strtolower(
 188                     str_replace('PHP_Token_', '', get_class($tokens[$i]))
 189                 );
 190             }
 191             if (isset($tokens[$i]) &&
 192               !($tokens[$i] instanceof PHP_Token_STATIC ||
 193                 $tokens[$i] instanceof PHP_Token_FINAL ||
 194                 $tokens[$i] instanceof PHP_Token_ABSTRACT)) {
 195                 // no keywords; stop visibility search
 196                 break;
 197             }
 198         }
 199     }
 200
 201     /**
 202      * @return string
 203      */
 204     public function getKeywords()
 205     {
 206         $keywords = array();
 207         $tokens   = $this->tokenStream->tokens();
 208
 209         for ($i = $this->id - 2; $i > $this->id - 7; $i -= 2) {
 210             if (isset($tokens[$i]) &&
 211                ($tokens[$i] instanceof PHP_Token_PRIVATE ||
 212                 $tokens[$i] instanceof PHP_Token_PROTECTED ||
 213                 $tokens[$i] instanceof PHP_Token_PUBLIC)) {
 214                 continue;
 215             }
 216
 217             if (isset($tokens[$i]) &&
 218                ($tokens[$i] instanceof PHP_Token_STATIC ||
 219                 $tokens[$i] instanceof PHP_Token_FINAL ||
 220                 $tokens[$i] instanceof PHP_Token_ABSTRACT)) {
 221                 $keywords[] = strtolower(
 222                     str_replace('PHP_Token_', '', get_class($tokens[$i]))
 223                 );
 224             }
 225         }
 226
 227         return implode(',', $keywords);
 228     }
 229 }
 230
 231 abstract class PHP_Token_Includes extends PHP_Token
 232 {
 233     /**
 234      * @var string
 235      */
 236     protected $name;
 237
 238     /**
 239      * @var string
 240      */
 241     protected $type;
 242
 243     /**
 244      * @return string
 245      */
 246     public function getName()
 247     {
 248         if ($this->name === null) {
 249             $this->process();
 250         }
 251
 252         return $this->name;
 253     }
 254
 255     /**
 256      * @return string
 257      */
 258     public function getType()
 259     {
 260         if ($this->type === null) {
 261             $this->process();
 262         }
 263
 264         return $this->type;
 265     }
 266
 267     private function process()
 268     {
 269         $tokens = $this->tokenStream->tokens();
 270
 271         if ($tokens[$this->id+2] instanceof PHP_Token_CONSTANT_ENCAPSED_STRING) {
 272             $this->name = trim($tokens[$this->id+2], "'\"");
 273             $this->type = strtolower(
 274                 str_replace('PHP_Token_', '', get_class($tokens[$this->id]))
 275             );
 276         }
 277     }
 278 }
 279
 280
 281 class PHP_Token_FUNCTION extends PHP_TokenWithScopeAndVisibility
 282 {
 283     /**
 284      * @var array
 285      */
 286     protected $arguments;
 287
 288     /**
 289      * @var integer
 290      */
 291     protected $ccn;
 292
 293     /**
 294      * @var string
 295      */
 296     protected $name;
 297
 298     /**
 299      * @var string
 300      */
 301     protected $signature;
 302
 303     /**
 304      * @return array
 305      */
 306     public function getArguments()
 307     {
 308         if ($this->arguments !== null) {
 309             return $this->arguments;
 310         }
 311
 312         $this->arguments = array();
 313         $tokens          = $this->tokenStream->tokens();
 314         $typeDeclaration = null;
 315
 316         // Search for first token inside brackets
 317         $i = $this->id + 2;
 318
 319         while (!$tokens[$i-1] instanceof PHP_Token_OPEN_BRACKET) {
 320             $i++;
 321         }
 322
 323         while (!$tokens[$i] instanceof PHP_Token_CLOSE_BRACKET) {
 324             if ($tokens[$i] instanceof PHP_Token_STRING) {
 325                 $typeDeclaration = (string)$tokens[$i];
 326             } elseif ($tokens[$i] instanceof PHP_Token_VARIABLE) {
 327                 $this->arguments[(string)$tokens[$i]] = $typeDeclaration;
 328                 $typeDeclaration                      = null;
 329             }
 330
 331             $i++;
 332         }
 333
 334         return $this->arguments;
 335     }
 336
 337     /**
 338      * @return string
 339      */
 340     public function getName()
 341     {
 342         if ($this->name !== null) {
 343             return $this->name;
 344         }
 345
 346         $tokens = $this->tokenStream->tokens();
 347
 348         for ($i = $this->id + 1; $i < count($tokens); $i++) {
 349             if ($tokens[$i] instanceof PHP_Token_STRING) {
 350                 $this->name = (string)$tokens[$i];
 351                 break;
 352             } elseif ($tokens[$i] instanceof PHP_Token_AMPERSAND &&
 353                      $tokens[$i+1] instanceof PHP_Token_STRING) {
 354                 $this->name = (string)$tokens[$i+1];
 355                 break;
 356             } elseif ($tokens[$i] instanceof PHP_Token_OPEN_BRACKET) {
 357                 $this->name = 'anonymous function';
 358                 break;
 359             }
 360         }
 361
 362         if ($this->name != 'anonymous function') {
 363             for ($i = $this->id; $i; --$i) {
 364                 if ($tokens[$i] instanceof PHP_Token_NAMESPACE) {
 365                     $this->name = $tokens[$i]->getName() . '\\' . $this->name;
 366                     break;
 367                 }
 368
 369                 if ($tokens[$i] instanceof PHP_Token_INTERFACE) {
 370                     break;
 371                 }
 372             }
 373         }
 374
 375         return $this->name;
 376     }
 377
 378     /**
 379      * @return integer
 380      */
 381     public function getCCN()
 382     {
 383         if ($this->ccn !== null) {
 384             return $this->ccn;
 385         }
 386
 387         $this->ccn = 1;
 388         $end       = $this->getEndTokenId();
 389         $tokens    = $this->tokenStream->tokens();
 390
 391         for ($i = $this->id; $i <= $end; $i++) {
 392             switch (get_class($tokens[$i])) {
 393                 case 'PHP_Token_IF':
 394                 case 'PHP_Token_ELSEIF':
 395                 case 'PHP_Token_FOR':
 396                 case 'PHP_Token_FOREACH':
 397                 case 'PHP_Token_WHILE':
 398                 case 'PHP_Token_CASE':
 399                 case 'PHP_Token_CATCH':
 400                 case 'PHP_Token_BOOLEAN_AND':
 401                 case 'PHP_Token_LOGICAL_AND':
 402                 case 'PHP_Token_BOOLEAN_OR':
 403                 case 'PHP_Token_LOGICAL_OR':
 404                 case 'PHP_Token_QUESTION_MARK':
 405                     $this->ccn++;
 406                     break;
 407             }
 408         }
 409
 410         return $this->ccn;
 411     }
 412
 413     /**
 414      * @return string
 415      */
 416     public function getSignature()
 417     {
 418         if ($this->signature !== null) {
 419             return $this->signature;
 420         }
 421
 422         if ($this->getName() == 'anonymous function') {
 423             $this->signature = 'anonymous function';
 424             $i               = $this->id + 1;
 425         } else {
 426             $this->signature = '';
 427             $i               = $this->id + 2;
 428         }
 429
 430         $tokens = $this->tokenStream->tokens();
 431
 432         while (isset($tokens[$i]) &&
 433                !$tokens[$i] instanceof PHP_Token_OPEN_CURLY &&
 434                !$tokens[$i] instanceof PHP_Token_SEMICOLON) {
 435             $this->signature .= $tokens[$i++];
 436         }
 437
 438         $this->signature = trim($this->signature);
 439
 440         return $this->signature;
 441     }
 442 }
 443
 444 class PHP_Token_INTERFACE extends PHP_TokenWithScopeAndVisibility
 445 {
 446     /**
 447      * @var array
 448      */
 449     protected $interfaces;
 450
 451     /**
 452      * @return string
 453      */
 454     public function getName()
 455     {
 456         return (string)$this->tokenStream[$this->id + 2];
 457     }
 458
 459     /**
 460      * @return boolean
 461      */
 462     public function hasParent()
 463     {
 464         return $this->tokenStream[$this->id + 4] instanceof PHP_Token_EXTENDS;
 465     }
 466
 467     /**
 468      * @return array
 469      */
 470     public function getPackage()
 471     {
 472         $className  = $this->getName();
 473         $docComment = $this->getDocblock();
 474
 475         $result = array(
 476             'namespace'   => '',
 477             'fullPackage' => '',
 478             'category'    => '',
 479             'package'     => '',
 480             'subpackage'  => ''
 481         );
 482
 483         for ($i = $this->id; $i; --$i) {
 484             if ($this->tokenStream[$i] instanceof PHP_Token_NAMESPACE) {
 485                 $result['namespace'] = $this->tokenStream[$i]->getName();
 486                 break;
 487             }
 488         }
 489
 490         if (preg_match('/@category[\s]+([\.\w]+)/', $docComment, $matches)) {
 491             $result['category'] = $matches[1];
 492         }
 493
 494         if (preg_match('/@package[\s]+([\.\w]+)/', $docComment, $matches)) {
 495             $result['package']     = $matches[1];
 496             $result['fullPackage'] = $matches[1];
 497         }
 498
 499         if (preg_match('/@subpackage[\s]+([\.\w]+)/', $docComment, $matches)) {
 500             $result['subpackage']   = $matches[1];
 501             $result['fullPackage'] .= '.' . $matches[1];
 502         }
 503
 504         if (empty($result['fullPackage'])) {
 505             $result['fullPackage'] = $this->arrayToName(
 506                 explode('_', str_replace('\\', '_', $className)),
 507                 '.'
 508             );
 509         }
 510
 511         return $result;
 512     }
 513
 514     /**
 515      * @param  array  $parts
 516      * @param  string $join
 517      * @return string
 518      */
 519     protected function arrayToName(array $parts, $join = '\\')
 520     {
 521         $result = '';
 522
 523         if (count($parts) > 1) {
 524             array_pop($parts);
 525
 526             $result = join($join, $parts);
 527         }
 528
 529         return $result;
 530     }
 531
 532     /**
 533      * @return boolean|string
 534      */
 535     public function getParent()
 536     {
 537         if (!$this->hasParent()) {
 538             return false;
 539         }
 540
 541         $i         = $this->id + 6;
 542         $tokens    = $this->tokenStream->tokens();
 543         $className = (string)$tokens[$i];
 544
 545         while (isset($tokens[$i+1]) &&
 546                !$tokens[$i+1] instanceof PHP_Token_WHITESPACE) {
 547             $className .= (string)$tokens[++$i];
 548         }
 549
 550         return $className;
 551     }
 552
 553     /**
 554      * @return boolean
 555      */
 556     public function hasInterfaces()
 557     {
 558         return (isset($this->tokenStream[$this->id + 4]) &&
 559                 $this->tokenStream[$this->id + 4] instanceof PHP_Token_IMPLEMENTS) ||
 560                (isset($this->tokenStream[$this->id + 8]) &&
 561                 $this->tokenStream[$this->id + 8] instanceof PHP_Token_IMPLEMENTS);
 562     }
 563
 564     /**
 565      * @return array|boolean
 566      */
 567     public function getInterfaces()
 568     {
 569         if ($this->interfaces !== null) {
 570             return $this->interfaces;
 571         }
 572
 573         if (!$this->hasInterfaces()) {
 574             return ($this->interfaces = false);
 575         }
 576
 577         if ($this->tokenStream[$this->id + 4] instanceof PHP_Token_IMPLEMENTS) {
 578             $i = $this->id + 3;
 579         } else {
 580             $i = $this->id + 7;
 581         }
 582
 583         $tokens = $this->tokenStream->tokens();
 584
 585         while (!$tokens[$i+1] instanceof PHP_Token_OPEN_CURLY) {
 586             $i++;
 587
 588             if ($tokens[$i] instanceof PHP_Token_STRING) {
 589                 $this->interfaces[] = (string)$tokens[$i];
 590             }
 591         }
 592
 593         return $this->interfaces;
 594     }
 595 }
 596
 597 class PHP_Token_ABSTRACT extends PHP_Token {}
 598 class PHP_Token_AMPERSAND extends PHP_Token {}
 599 class PHP_Token_AND_EQUAL extends PHP_Token {}
 600 class PHP_Token_ARRAY extends PHP_Token {}
 601 class PHP_Token_ARRAY_CAST extends PHP_Token {}
 602 class PHP_Token_AS extends PHP_Token {}
 603 class PHP_Token_AT extends PHP_Token {}
 604 class PHP_Token_BACKTICK extends PHP_Token {}
 605 class PHP_Token_BAD_CHARACTER extends PHP_Token {}
 606 class PHP_Token_BOOLEAN_AND extends PHP_Token {}
 607 class PHP_Token_BOOLEAN_OR extends PHP_Token {}
 608 class PHP_Token_BOOL_CAST extends PHP_Token {}
 609 class PHP_Token_BREAK extends PHP_Token {}
 610 class PHP_Token_CARET extends PHP_Token {}
 611 class PHP_Token_CASE extends PHP_Token {}
 612 class PHP_Token_CATCH extends PHP_Token {}
 613 class PHP_Token_CHARACTER extends PHP_Token {}
 614
 615 class PHP_Token_CLASS extends PHP_Token_INTERFACE
 616 {
 617     /**
 618      * @return string
 619      */
 620     public function getName()
 621     {
 622         $next = $this->tokenStream[$this->id + 1];
 623
 624         if ($next instanceof PHP_Token_WHITESPACE) {
 625             $next = $this->tokenStream[$this->id + 2];
 626         }
 627
 628         if ($next instanceof PHP_Token_STRING) {
 629             return (string) $next;
 630         }
 631
 632         if ($next instanceof PHP_Token_OPEN_CURLY ||
 633             $next instanceof PHP_Token_EXTENDS ||
 634             $next instanceof PHP_Token_IMPLEMENTS) {
 635             return 'anonymous class';
 636         }
 637     }
 638 }
 639
 640 class PHP_Token_CLASS_C extends PHP_Token {}
 641 class PHP_Token_CLASS_NAME_CONSTANT extends PHP_Token {}
 642 class PHP_Token_CLONE extends PHP_Token {}
 643 class PHP_Token_CLOSE_BRACKET extends PHP_Token {}
 644 class PHP_Token_CLOSE_CURLY extends PHP_Token {}
 645 class PHP_Token_CLOSE_SQUARE extends PHP_Token {}
 646 class PHP_Token_CLOSE_TAG extends PHP_Token {}
 647 class PHP_Token_COLON extends PHP_Token {}
 648 class PHP_Token_COMMA extends PHP_Token {}
 649 class PHP_Token_COMMENT extends PHP_Token {}
 650 class PHP_Token_CONCAT_EQUAL extends PHP_Token {}
 651 class PHP_Token_CONST extends PHP_Token {}
 652 class PHP_Token_CONSTANT_ENCAPSED_STRING extends PHP_Token {}
 653 class PHP_Token_CONTINUE extends PHP_Token {}
 654 class PHP_Token_CURLY_OPEN extends PHP_Token {}
 655 class PHP_Token_DEC extends PHP_Token {}
 656 class PHP_Token_DECLARE extends PHP_Token {}
 657 class PHP_Token_DEFAULT extends PHP_Token {}
 658 class PHP_Token_DIV extends PHP_Token {}
 659 class PHP_Token_DIV_EQUAL extends PHP_Token {}
 660 class PHP_Token_DNUMBER extends PHP_Token {}
 661 class PHP_Token_DO extends PHP_Token {}
 662 class PHP_Token_DOC_COMMENT extends PHP_Token {}
 663 class PHP_Token_DOLLAR extends PHP_Token {}
 664 class PHP_Token_DOLLAR_OPEN_CURLY_BRACES extends PHP_Token {}
 665 class PHP_Token_DOT extends PHP_Token {}
 666 class PHP_Token_DOUBLE_ARROW extends PHP_Token {}
 667 class PHP_Token_DOUBLE_CAST extends PHP_Token {}
 668 class PHP_Token_DOUBLE_COLON extends PHP_Token {}
 669 class PHP_Token_DOUBLE_QUOTES extends PHP_Token {}
 670 class PHP_Token_ECHO extends PHP_Token {}
 671 class PHP_Token_ELSE extends PHP_Token {}
 672 class PHP_Token_ELSEIF extends PHP_Token {}
 673 class PHP_Token_EMPTY extends PHP_Token {}
 674 class PHP_Token_ENCAPSED_AND_WHITESPACE extends PHP_Token {}
 675 class PHP_Token_ENDDECLARE extends PHP_Token {}
 676 class PHP_Token_ENDFOR extends PHP_Token {}
 677 class PHP_Token_ENDFOREACH extends PHP_Token {}
 678 class PHP_Token_ENDIF extends PHP_Token {}
 679 class PHP_Token_ENDSWITCH extends PHP_Token {}
 680 class PHP_Token_ENDWHILE extends PHP_Token {}
 681 class PHP_Token_END_HEREDOC extends PHP_Token {}
 682 class PHP_Token_EQUAL extends PHP_Token {}
 683 class PHP_Token_EVAL extends PHP_Token {}
 684 class PHP_Token_EXCLAMATION_MARK extends PHP_Token {}
 685 class PHP_Token_EXIT extends PHP_Token {}
 686 class PHP_Token_EXTENDS extends PHP_Token {}
 687 class PHP_Token_FILE extends PHP_Token {}
 688 class PHP_Token_FINAL extends PHP_Token {}
 689 class PHP_Token_FOR extends PHP_Token {}
 690 class PHP_Token_FOREACH extends PHP_Token {}
 691 class PHP_Token_FUNC_C extends PHP_Token {}
 692 class PHP_Token_GLOBAL extends PHP_Token {}
 693 class PHP_Token_GT extends PHP_Token {}
 694 class PHP_Token_IF extends PHP_Token {}
 695 class PHP_Token_IMPLEMENTS extends PHP_Token {}
 696 class PHP_Token_INC extends PHP_Token {}
 697 class PHP_Token_INCLUDE extends PHP_Token_Includes {}
 698 class PHP_Token_INCLUDE_ONCE extends PHP_Token_Includes {}
 699 class PHP_Token_INLINE_HTML extends PHP_Token {}
 700 class PHP_Token_INSTANCEOF extends PHP_Token {}
 701 class PHP_Token_INT_CAST extends PHP_Token {}
 702 class PHP_Token_ISSET extends PHP_Token {}
 703 class PHP_Token_IS_EQUAL extends PHP_Token {}
 704 class PHP_Token_IS_GREATER_OR_EQUAL extends PHP_Token {}
 705 class PHP_Token_IS_IDENTICAL extends PHP_Token {}
 706 class PHP_Token_IS_NOT_EQUAL extends PHP_Token {}
 707 class PHP_Token_IS_NOT_IDENTICAL extends PHP_Token {}
 708 class PHP_Token_IS_SMALLER_OR_EQUAL extends PHP_Token {}
 709 class PHP_Token_LINE extends PHP_Token {}
 710 class PHP_Token_LIST extends PHP_Token {}
 711 class PHP_Token_LNUMBER extends PHP_Token {}
 712 class PHP_Token_LOGICAL_AND extends PHP_Token {}
 713 class PHP_Token_LOGICAL_OR extends PHP_Token {}
 714 class PHP_Token_LOGICAL_XOR extends PHP_Token {}
 715 class PHP_Token_LT extends PHP_Token {}
 716 class PHP_Token_METHOD_C extends PHP_Token {}
 717 class PHP_Token_MINUS extends PHP_Token {}
 718 class PHP_Token_MINUS_EQUAL extends PHP_Token {}
 719 class PHP_Token_MOD_EQUAL extends PHP_Token {}
 720 class PHP_Token_MULT extends PHP_Token {}
 721 class PHP_Token_MUL_EQUAL extends PHP_Token {}
 722 class PHP_Token_NEW extends PHP_Token {}
 723 class PHP_Token_NUM_STRING extends PHP_Token {}
 724 class PHP_Token_OBJECT_CAST extends PHP_Token {}
 725 class PHP_Token_OBJECT_OPERATOR extends PHP_Token {}
 726 class PHP_Token_OPEN_BRACKET extends PHP_Token {}
 727 class PHP_Token_OPEN_CURLY extends PHP_Token {}
 728 class PHP_Token_OPEN_SQUARE extends PHP_Token {}
 729 class PHP_Token_OPEN_TAG extends PHP_Token {}
 730 class PHP_Token_OPEN_TAG_WITH_ECHO extends PHP_Token {}
 731 class PHP_Token_OR_EQUAL extends PHP_Token {}
 732 class PHP_Token_PAAMAYIM_NEKUDOTAYIM extends PHP_Token {}
 733 class PHP_Token_PERCENT extends PHP_Token {}
 734 class PHP_Token_PIPE extends PHP_Token {}
 735 class PHP_Token_PLUS extends PHP_Token {}
 736 class PHP_Token_PLUS_EQUAL extends PHP_Token {}
 737 class PHP_Token_PRINT extends PHP_Token {}
 738 class PHP_Token_PRIVATE extends PHP_Token {}
 739 class PHP_Token_PROTECTED extends PHP_Token {}
 740 class PHP_Token_PUBLIC extends PHP_Token {}
 741 class PHP_Token_QUESTION_MARK extends PHP_Token {}
 742 class PHP_Token_REQUIRE extends PHP_Token_Includes {}
 743 class PHP_Token_REQUIRE_ONCE extends PHP_Token_Includes {}
 744 class PHP_Token_RETURN extends PHP_Token {}
 745 class PHP_Token_SEMICOLON extends PHP_Token {}
 746 class PHP_Token_SL extends PHP_Token {}
 747 class PHP_Token_SL_EQUAL extends PHP_Token {}
 748 class PHP_Token_SR extends PHP_Token {}
 749 class PHP_Token_SR_EQUAL extends PHP_Token {}
 750 class PHP_Token_START_HEREDOC extends PHP_Token {}
 751 class PHP_Token_STATIC extends PHP_Token {}
 752 class PHP_Token_STRING extends PHP_Token {}
 753 class PHP_Token_STRING_CAST extends PHP_Token {}
 754 class PHP_Token_STRING_VARNAME extends PHP_Token {}
 755 class PHP_Token_SWITCH extends PHP_Token {}
 756 class PHP_Token_THROW extends PHP_Token {}
 757 class PHP_Token_TILDE extends PHP_Token {}
 758 class PHP_Token_TRY extends PHP_Token {}
 759 class PHP_Token_UNSET extends PHP_Token {}
 760 class PHP_Token_UNSET_CAST extends PHP_Token {}
 761 class PHP_Token_USE extends PHP_Token {}
 762 class PHP_Token_USE_FUNCTION extends PHP_Token {}
 763 class PHP_Token_VAR extends PHP_Token {}
 764 class PHP_Token_VARIABLE extends PHP_Token {}
 765 class PHP_Token_WHILE extends PHP_Token {}
 766 class PHP_Token_WHITESPACE extends PHP_Token {}
 767 class PHP_Token_XOR_EQUAL extends PHP_Token {}
 768
 769 // Tokens introduced in PHP 5.1
 770 class PHP_Token_HALT_COMPILER extends PHP_Token {}
 771
 772 // Tokens introduced in PHP 5.3
 773 class PHP_Token_DIR extends PHP_Token {}
 774 class PHP_Token_GOTO extends PHP_Token {}
 775
 776 class PHP_Token_NAMESPACE extends PHP_TokenWithScope
 777 {
 778     /**
 779      * @return string
 780      */
 781     public function getName()
 782     {
 783         $tokens    = $this->tokenStream->tokens();
 784         $namespace = (string)$tokens[$this->id+2];
 785
 786         for ($i = $this->id + 3;; $i += 2) {
 787             if (isset($tokens[$i]) &&
 788                 $tokens[$i] instanceof PHP_Token_NS_SEPARATOR) {
 789                 $namespace .= '\\' . $tokens[$i+1];
 790             } else {
 791                 break;
 792             }
 793         }
 794
 795         return $namespace;
 796     }
 797 }
 798
 799 class PHP_Token_NS_C extends PHP_Token {}
 800 class PHP_Token_NS_SEPARATOR extends PHP_Token {}
 801
 802 // Tokens introduced in PHP 5.4
 803 class PHP_Token_CALLABLE extends PHP_Token {}
 804 class PHP_Token_INSTEADOF extends PHP_Token {}
 805 class PHP_Token_TRAIT extends PHP_Token_INTERFACE {}
 806 class PHP_Token_TRAIT_C extends PHP_Token {}
 807
 808 // Tokens introduced in PHP 5.5
 809 class PHP_Token_FINALLY extends PHP_Token {}
 810 class PHP_Token_YIELD extends PHP_Token {}
 811
 812 // Tokens introduced in PHP 5.6
 813 class PHP_Token_ELLIPSIS extends PHP_Token {}
 814 class PHP_Token_POW extends PHP_Token {}
 815 class PHP_Token_POW_EQUAL extends PHP_Token {}
 816
 817 // Tokens introduced in PHP 7.0
 818 class PHP_Token_COALESCE extends PHP_Token {}
 819 class PHP_Token_SPACESHIP extends PHP_Token {}
 820 class PHP_Token_YIELD_FROM extends PHP_Token {}
 821
 822 // Tokens introduced in HackLang / HHVM
 823 class PHP_Token_ASYNC extends PHP_Token {}
 824 class PHP_Token_AWAIT extends PHP_Token {}
 825 class PHP_Token_COMPILER_HALT_OFFSET extends PHP_Token {}
 826 class PHP_Token_ENUM extends PHP_Token {}
 827 class PHP_Token_EQUALS extends PHP_Token {}
 828 class PHP_Token_IN extends PHP_Token {}
 829 class PHP_Token_JOIN extends PHP_Token {}
 830 class PHP_Token_LAMBDA_ARROW extends PHP_Token {}
 831 class PHP_Token_LAMBDA_CP extends PHP_Token {}
 832 class PHP_Token_LAMBDA_OP extends PHP_Token {}
 833 class PHP_Token_ONUMBER extends PHP_Token {}
 834 class PHP_Token_NULLSAFE_OBJECT_OPERATOR extends PHP_Token {}
 835 class PHP_Token_SHAPE extends PHP_Token {}
 836 class PHP_Token_SUPER extends PHP_Token {}
 837 class PHP_Token_TYPE extends PHP_Token {}
 838 class PHP_Token_TYPELIST_GT extends PHP_Token {}
 839 class PHP_Token_TYPELIST_LT extends PHP_Token {}
 840 class PHP_Token_WHERE extends PHP_Token {}
 841 class PHP_Token_XHP_ATTRIBUTE extends PHP_Token {}
 842 class PHP_Token_XHP_CATEGORY extends PHP_Token {}
 843 class PHP_Token_XHP_CATEGORY_LABEL extends PHP_Token {}
 844 class PHP_Token_XHP_CHILDREN extends PHP_Token {}
 845 class PHP_Token_XHP_LABEL extends PHP_Token {}
 846 class PHP_Token_XHP_REQUIRED extends PHP_Token {}
 847 class PHP_Token_XHP_TAG_GT extends PHP_Token {}
 848 class PHP_Token_XHP_TAG_LT extends PHP_Token {}
 849 class PHP_Token_XHP_TEXT extends PHP_Token {}