PHP Token::getType方法代码示例

 /**
  * Check if the token is operator
  *
  * @param Token $token
  * @return boolean
  */
 public function isOperator(Token $token)
 {
     if (T_STRING == $token->getType()) {
         if (isset($this->byPass[$token->getValue()])) {
             return false;
         }
         return isset($this->operatorsStrings[$token->getValue()]);
     }
     return isset($this->operators[$token->getType()]);
 }

 public function testGetters()
 {
     $token = new Token(Token::IDENTIFIER, 'foobar', 7);
     $this->assertNotEquals(Token::TEXT, $token->getType());
     $this->assertEquals(Token::IDENTIFIER, $token->getType());
     $this->assertNotEquals('foo', $token->getValue());
     $this->assertEquals('foobar', $token->getValue());
     $this->assertNotEquals(6, $token->getLine());
     $this->assertEquals(7, $token->getLine());
 }

 public function testWithersReturnNewModifiedInstance()
 {
     $value = 'bob';
     $newValue = 'alice';
     $type = new TokenType(TokenType::DYNAMIC_ARRAY_TYPE);
     $token = new Token($value, $type);
     $newToken = $token->withValue($newValue);
     $this->assertEquals($value, $token->getValue());
     $this->assertEquals($type->getValue(), $token->getType());
     $this->assertInstanceOf(Token::class, $newToken);
     $this->assertEquals($newValue, $newToken->getValue());
     $this->assertEquals($type->getValue(), $newToken->getType());
 }

 public function addToken(Token $token)
 {
     switch ($token->getType()) {
         // This block is basically a whitelist of token types permissible before
         // seeing a T_FUNCTION. If we hit anything else, the docblock isn't
         // attached to something we care about.
         case T_DOC_COMMENT:
             $this->docblock = $token;
             // fall through
         // fall through
         case T_WHITESPACE:
         case T_PUBLIC:
         case T_PROTECTED:
         case T_PRIVATE:
         case T_STATIC:
         case T_ABSTRACT:
             break;
         case Token::SINGLE_CHARACTER:
             if ($token->is('{')) {
                 $this->has_started = true;
                 $this->depth++;
             } elseif ($token->is('}')) {
                 $this->depth--;
             }
             break;
         case T_FUNCTION:
             $this->track = false;
             break;
         case T_STRING:
             if (!$this->has_started) {
                 $this->name = $token->getValue();
             }
             // fall through
         // fall through
         default:
             if ($this->track) {
                 $this->no_op = true;
             }
             break;
     }
     if ($this->has_started) {
         $this->body[] = $token;
     } else {
         $this->head[] = $token;
     }
     return $this;
 }

 public function FromToken(Token $oldToken)
 {
     $text = $oldToken->getText();
     $type = $oldToken->getType();
     $line = $oldToken->getLine();
     $index = $oldToken->getTokenIndex();
     $charPositionInLine = $oldToken->getCharPositionInLine();
     $channel = $oldToken->getChannel();
     if ($oldToken instanceof CommonToken) {
         $start = $oldToken->start;
         $stop = $oldToken->stop;
     }
     $token = new CommonToken(null, $type, $channel, $start, $stop);
     $token->text = $text;
     $token->line = $line;
     $token->index = $index;
     $token->charPositionInLine = $charPositionInLine;
     return $token;
 }

 public function addToken(Token $token)
 {
     switch ($token->getType()) {
         case T_WHITESPACE:
             break;
         case T_VARIABLE:
             if ($this->current_th) {
             } else {
                 $this->addProvidedTypehint();
             }
             break;
         default:
             $this->current_th .= $token;
             break;
     }
     $this->tokens[] = $token;
     if ($token->is(',')) {
         $this->argno++;
         $this->current_th = '';
     }
 }

 /**
  * Given the set of matches, nest them according to their types
  *
  * @param \ArrayIterator $result Iterator of match results
  * @param  \SalesforceEng\Breakout\Token $latest Token instance
  * @return array Set of nested token instances (arrays)
  */
 public function nest(&$result, $latest = null)
 {
     $container = [];
     if (!$result instanceof \ArrayIterator) {
         $result = new \ArrayIterator($result);
     }
     while ($result->valid()) {
         $current = new Token($result->current());
         $result->next();
         if ($current->getType() == 'block') {
             // see if we're closing it out
             $content = trim($current->getContent());
             if ($content !== 'endif' && $content !== 'endfor' && $content !== 'else' && $content !== 'endraw') {
                 $group = [$current];
                 $found = $this->nest($result, $current);
                 $current = array_merge($group, $found);
             } else {
                 if ($latest !== null) {
                     $latestType = explode(' ', trim($latest->getContent()))[0];
                     if ($latestType == 'if' && trim($current->getContent()) == 'endif') {
                         $container[] = $current;
                         return $container;
                     } elseif ($latestType == 'for' && trim($current->getContent()) == 'endfor') {
                         $container[] = $current;
                         return $container;
                     } elseif ($latestType == 'raw' && trim($current->getContent()) == 'endraw') {
                         $container[] = $current;
                         return $container;
                     }
                 }
             }
         }
         $container[] = $current;
     }
     return $container;
 }

 /**
  * Checks if the given token is a keyword in the current strict mode state
  * 
  * @param Token $token Token to checks
  * 
  * @return bool
  */
 public function isStrictModeKeyword($token)
 {
     return $token->getType() === Token::TYPE_KEYWORD && (in_array($token->getValue(), $this->keywords) || $this->strictMode && in_array($token->getValue(), $this->strictModeKeywords));
 }

 protected function shouldSkipToken(Token $t)
 {
     return $t->getType() === 'e';
 }

 protected function procAssignment(Token $token)
 {
     $this->debug(__METHOD__, __LINE__, "identifier: {$token->getValue()}");
     // Validate the leftside
     if ($token->getType() != TokenType::IDENTIFIER) {
         throw new SyntaxException($token->getLine(), $token->getColumn() - mb_strlen($token->getValue()) + 1, "Invalid assignment identifier: '{$token->getValue()}'", __FILE__, __LINE__);
     }
     $name = $token->getValue();
     $token = $this->getToken();
     // Validate the operator
     switch ($token->getType()) {
         case TokenType::SYMBOL:
             switch ($token->getValue()) {
                 case ';':
                     if (!$this->memory->hasVar($name)) {
                         throw new SyntaxException($token->getLine(), $token->getColumn() - mb_strlen($name) + 1, "Unknown identifier: '{$name}'", __FILE__, __LINE__);
                     }
                     // Do nothing :\
                     return;
                     break;
                 case '=':
                     // allow =
                     break;
                 case '++':
                 case '--':
                     // allow ++ and --
                     break;
                 default:
                     throw new SyntaxException($token->getLine(), $token->getColumn() - mb_strlen($token->getValue()) + 1, "Invalid assignment operator: '{$token->getValue()}'", __FILE__, __LINE__);
             }
             break;
         default:
             throw new SyntaxException($token->getLine(), $token->getColumn() - mb_strlen($token->getValue()) + 1, "Invalid assignment operator: '{$token->getValue()}'", __FILE__, __LINE__);
     }
     $operator = $token->getValue();
     // Evaluate the rightside
     $type = $this->evalExp($value);
     // Perform action
     switch ($operator) {
         case '=':
             $this->memory->setVar($name, $value, $type);
             break;
         case '++':
             // number only
         // number only
         case '--':
             if (!$this->memory->hasVar($name)) {
                 throw new SyntaxException($token->getLine(), $token->getColumn(), "Unknown identifier: '{$name}'", __FILE__, __LINE__);
             }
             $value = $this->memory->getVar($name);
             if ($operator == '++') {
                 $newval = intval($value + 1);
             } else {
                 $newval = intval($value - 1);
             }
             $this->memory->setVar($name, $newval, $type);
             break;
         default:
             throw new SyntaxException($token->getLine(), $token->getColumn() - mb_strlen($operator) + 1, "Unknown operator: '{$operator}'", __FILE__, __LINE__);
             break;
     }
 }

 protected function buildNumberToken(Token $token, Character $char)
 {
     $token->setType(TokenType::INTEGER);
     $buffer = '';
     do {
         $buffer .= $char->getValue();
         try {
             $char = $this->getCharacter();
         } catch (EofException $e) {
             throw new SyntaxException($char->getLine(), $char->getColumn() - mb_strlen($buffer) + 1, "Found EOF reading number: '{$buffer}'", __FILE__, __LINE__);
         }
     } while ($char->isNumber() || $char->getValue() == '.');
     $this->ungetCharacter();
     // If number contains a period, is a FLOAT
     if (mb_strpos($buffer, '.') !== FALSE) {
         $token->setType(TokenType::FLOAT);
         // If period is not followed by numbers
         if (mb_substr($buffer, -1) == '.') {
             throw new SyntaxException($token->getLine(), $token->getColumn(), "Invalid FLOAT value: '{$buffer}'", __FILE__, __LINE__);
         }
     }
     switch ($token->getType()) {
         case TokenType::FLOAT:
             $token->setValue(floatval($buffer));
             break;
         case TokenType::INTEGER:
             $token->setValue(intval($buffer));
             break;
         default:
             throw new SyntaxException($char->getLine(), $char->getColumn(), 'Unknown number token type: "' . $buffer . '"', __FILE__, __LINE__);
             break;
     }
     return $token;
 }

 /**
  * Equals
  *
  * @param \PHP\Manipulator\Token $token
  * @return boolean
  */
 public function equals(Token $token, $strict = false)
 {
     $match = false;
     if ($this->getType() === $token->getType() && $this->getValue() === $token->getValue()) {
         $match = true;
     }
     if (true === $strict && $this->_linenumber !== $token->getLinenumber()) {
         $match = false;
     }
     return $match;
 }