gluon-web-remote

Web remote Administration for big size of gluon routers
git clone git://archive.git.mtrnord.blog/MTRNord/gluon-web-remote.git
Log | Files | Refs | README

Token.php (25146B)

      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_VAR extends PHP_Token {}
    763 class PHP_Token_VARIABLE extends PHP_Token {}
    764 class PHP_Token_WHILE extends PHP_Token {}
    765 class PHP_Token_WHITESPACE extends PHP_Token {}
    766 class PHP_Token_XOR_EQUAL extends PHP_Token {}
    767 
    768 // Tokens introduced in PHP 5.1
    769 class PHP_Token_HALT_COMPILER extends PHP_Token {}
    770 
    771 // Tokens introduced in PHP 5.3
    772 class PHP_Token_DIR extends PHP_Token {}
    773 class PHP_Token_GOTO extends PHP_Token {}
    774 
    775 class PHP_Token_NAMESPACE extends PHP_TokenWithScope
    776 {
    777     /**
    778      * @return string
    779      */
    780     public function getName()
    781     {
    782         $tokens    = $this->tokenStream->tokens();
    783         $namespace = (string)$tokens[$this->id+2];
    784 
    785         for ($i = $this->id + 3;; $i += 2) {
    786             if (isset($tokens[$i]) &&
    787                 $tokens[$i] instanceof PHP_Token_NS_SEPARATOR) {
    788                 $namespace .= '\\' . $tokens[$i+1];
    789             } else {
    790                 break;
    791             }
    792         }
    793 
    794         return $namespace;
    795     }
    796 }
    797 
    798 class PHP_Token_NS_C extends PHP_Token {}
    799 class PHP_Token_NS_SEPARATOR extends PHP_Token {}
    800 
    801 // Tokens introduced in PHP 5.4
    802 class PHP_Token_CALLABLE extends PHP_Token {}
    803 class PHP_Token_INSTEADOF extends PHP_Token {}
    804 class PHP_Token_TRAIT extends PHP_Token_INTERFACE {}
    805 class PHP_Token_TRAIT_C extends PHP_Token {}
    806 
    807 // Tokens introduced in PHP 5.5
    808 class PHP_Token_FINALLY extends PHP_Token {}
    809 class PHP_Token_YIELD extends PHP_Token {}
    810 
    811 // Tokens introduced in PHP 5.6
    812 class PHP_Token_ELLIPSIS extends PHP_Token {}
    813 class PHP_Token_POW extends PHP_Token {}
    814 class PHP_Token_POW_EQUAL extends PHP_Token {}
    815 
    816 // Tokens introduced in PHP 7.0
    817 class PHP_Token_COALESCE extends PHP_Token {}
    818 class PHP_Token_SPACESHIP extends PHP_Token {}
    819 class PHP_Token_YIELD_FROM extends PHP_Token {}
    820 
    821 // Tokens introduced in HackLang / HHVM
    822 class PHP_Token_ASYNC extends PHP_Token {}
    823 class PHP_Token_AWAIT extends PHP_Token {}
    824 class PHP_Token_COMPILER_HALT_OFFSET extends PHP_Token {}
    825 class PHP_Token_ENUM extends PHP_Token {}
    826 class PHP_Token_EQUALS extends PHP_Token {}
    827 class PHP_Token_IN extends PHP_Token {}
    828 class PHP_Token_JOIN extends PHP_Token {}
    829 class PHP_Token_LAMBDA_ARROW extends PHP_Token {}
    830 class PHP_Token_LAMBDA_CP extends PHP_Token {}
    831 class PHP_Token_LAMBDA_OP extends PHP_Token {}
    832 class PHP_Token_ONUMBER extends PHP_Token {}
    833 class PHP_Token_SHAPE extends PHP_Token {}
    834 class PHP_Token_TYPE extends PHP_Token {}
    835 class PHP_Token_TYPELIST_GT extends PHP_Token {}
    836 class PHP_Token_TYPELIST_LT extends PHP_Token {}
    837 class PHP_Token_WHERE extends PHP_Token {}
    838 class PHP_Token_XHP_ATTRIBUTE extends PHP_Token {}
    839 class PHP_Token_XHP_CATEGORY extends PHP_Token {}
    840 class PHP_Token_XHP_CATEGORY_LABEL extends PHP_Token {}
    841 class PHP_Token_XHP_CHILDREN extends PHP_Token {}
    842 class PHP_Token_XHP_LABEL extends PHP_Token {}
    843 class PHP_Token_XHP_REQUIRED extends PHP_Token {}
    844 class PHP_Token_XHP_TAG_GT extends PHP_Token {}
    845 class PHP_Token_XHP_TAG_LT extends PHP_Token {}
    846 class PHP_Token_XHP_TEXT extends PHP_Token {}