: <?php                                                                                                                                     
                 : /*                                                                                                                                        
                 : Copyright 2008 Josh Heidenreich                                                                                                           
                 :                                                                                                                                           
                 : This file is part of Pelzini.                                                                                                             
                 :                                                                                                                                           
                 : Pelzini is free software: you can redistribute it and/or modify                                                                           
                 : it under the terms of the GNU General Public License as published by                                                                      
                 : the Free Software Foundation, either version 3 of the License, or                                                                         
                 : (at your option) any later version.                                                                                                       
                 :                                                                                                                                           
                 : Pelzini is distributed in the hope that it will be useful,                                                                                
                 : but WITHOUT ANY WARRANTY; without even the implied warranty of                                                                            
                 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                                                             
                 : GNU General Public License for more details.                                                                                              
                 :                                                                                                                                           
                 : You should have received a copy of the GNU General Public License                                                                         
                 : along with Pelzini.  If not, see <http://www.gnu.org/licenses/>.                                                                          
                 : */                                                                                                                                        
                 :                                                                                                                                           
                 :                                                                                                                                           
                 : /**                                                                                                                                       
                 :  * Contains the {@link Analyser} class                                                                                                    
                 :  *                                                                                                                                        
                 :  * @package Parsers                                                                                                                       
                 :  * @author Josh                                                                                                                           
                 :  * @since 0.2                                                                                                                             
                 :  **/                                                                                                                                      
                 :                                                                                                                                           
                 : /**                                                                                                                                       
                 :  * Generic language analyser. Analysers are used to tranform the language-specific tokens into a set of {@link CodeParserItem ParserItems}
                 :  **/                                                                                                                                      
                 : abstract class Analyser                                                                                                                   
                 : {                                                                                                                                         
                 :     private $tokens;                                                                                                                      
                 :     private $pos;                                                                                                                         
                 :     private $token_pos;                                                                                                                   
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Resets the analyser ready for more parsing work                                                                                    
                 :      **/                                                                                                                                  
                 :     public function resetState()                                                                                                          
                 :     {                                                                                                                                     
               3 :         $this->tokens = array();                                                                                                          
               3 :         $this->pos = 0;                                                                                                                   
               3 :         $this->token_pos = 0;                                                                                                             
               3 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Processes a set of token and populates a {@link ParserFile}                                                                        
                 :      **/                                                                                                                                  
                 :     abstract public function process($tokens, $parser_file);                                                                              
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Tells the analyser what tokens it should use                                                                                       
                 :      **/                                                                                                                                  
                 :     final protected function setTokens($tokens)                                                                                           
                 :     {                                                                                                                                     
               6 :         $this->tokens = $tokens;                                                                                                          
               6 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Sets the current position                                                                                                          
                 :      **/                                                                                                                                  
                 :     final protected function setPos($pos)                                                                                                 
                 :     {                                                                                                                                     
               6 :         $this->pos = $pos;                                                                                                                
               6 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Moves the internal token pointer forwards                                                                                          
                 :      *                                                                                                                                    
                 :      * @param $num integer The number of positions to move the pointer forwards                                                           
                 :      **/                                                                                                                                  
                 :     final protected function movePosForward($num = 1)                                                                                     
                 :     {                                                                                                                                     
               1 :         $this->pos += $num;                                                                                                               
               1 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Moves the internal token pointer backwards                                                                                         
                 :      *                                                                                                                                    
                 :      * @param $num integer The number of positions to move the pointer backwards                                                          
                 :      **/                                                                                                                                  
                 :     final protected function movePosBackward($num = 1)                                                                                    
                 :     {                                                                                                                                     
               0 :         $this->pos -= $num;                                                                                                               
               0 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Returns a token at a specific position                                                                                             
                 :      * If no position is specified, uses the current position                                                                             
                 :      **/                                                                                                                                  
                 :     final protected function getToken($pos = null)                                                                                        
                 :     {                                                                                                                                     
               6 :         if ($pos === null) $pos = $this->pos;                                                                                             
               6 :         return $this->tokens[$pos];                                                                                                       
                 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Returns the current position                                                                                                       
                 :      **/                                                                                                                                  
                 :     final protected function getPos()                                                                                                     
                 :     {                                                                                                                                     
               0 :         return $this->pos;                                                                                                                
                 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Finds a token looking forward from the current position.                                                                           
                 :      * Searching starts after the current token.                                                                                          
                 :      * The token must be of the type specified                                                                                            
                 :      *                                                                                                                                    
                 :      * @param mixed $token_types A token type constant, or an array of token type constants                                               
                 :      * @param mixed $stop_list Token(s) that should stop the search process                                                               
                 :      * @return Token The found token, or null if nothing was found                                                                        
                 :      **/                                                                                                                                  
                 :     final protected function findTokenForwards($token_types, $stop_list = null)                                                           
                 :     {                                                                                                                                     
               6 :         if (! is_array($token_types)) $token_types = array($token_types);                                                                 
               6 :         if (! is_array($stop_list)) $stop_list = array($stop_list);                                                                       
                 :                                                                                                                                           
               6 :         $pos = $this->pos;                                                                                                                
               6 :         if ($pos != 0) $pos++;                                                                                                            
                 :                                                                                                                                           
               6 :         while (true) {                                                                                                                    
               6 :             if (empty($this->tokens[$pos])) break;                                                                                        
                 :                                                                                                                                                       
               6 :             $tok = $this->tokens[$pos];                                                                                                   
               6 :             if (in_array($tok->getType(), $stop_list)) {                                                                                  
               0 :                 break;                                                                                                                    
                 :             }                                                                                                                             
                 :                                                                                                                                           
               6 :             if (in_array($tok->getType(), $token_types)) {                                                                                
               6 :                 $this->token_pos = $pos;                                                                                                  
               6 :                 return $tok;                                                                                                              
                 :             }                                                                                                                             
                 :                                                                                                                                           
               6 :             ++$pos;                                                                                                                       
               6 :         }                                                                                                                                 
                 :                                                                                                                                           
               6 :         return null;                                                                                                                      
                 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Finds a token looking backwards from the current position.                                                                         
                 :      * Searching starts before the current token.                                                                                         
                 :      * The token must be of the type specified                                                                                            
                 :      *                                                                                                                                    
                 :      * @param mixed $token_types A token type constant, or an array of token type constants                                               
                 :      * @param mixed $stop_list Token(s) that should stop the search process                                                               
                 :      * @return Token The found token, or null if nothing was found                                                                        
                 :      **/                                                                                                                                  
                 :     final protected function findTokenBackwards($token_types, $stop_list = null)                                                          
                 :     {                                                                                                                                     
               6 :         if (! is_array($token_types)) $token_types = array($token_types);                                                                 
               6 :         if (! is_array($stop_list)) $stop_list = array($stop_list);                                                                       
                 :                                                                                                                                           
               6 :         $pos = $this->pos - 1;                                                                                                            
               6 :         while (true) {                                                                                                                    
               6 :             if (empty($this->tokens[$pos])) break;                                                                                        
                 :                                                                                                                                                       
               5 :             $tok = $this->tokens[$pos];                                                                                                   
               5 :             if (in_array($tok->getType(), $stop_list)) {                                                                                  
               1 :                 break;                                                                                                                    
                 :             }                                                                                                                             
                 :                                                                                                                                           
               5 :             if (in_array($tok->getType(), $token_types)) {                                                                                
               5 :                 $this->token_pos = $pos;                                                                                                  
               5 :                 return $tok;                                                                                                              
                 :             }                                                                                                                             
                 :                                                                                                                                           
               1 :             --$pos;                                                                                                                       
               1 :         }                                                                                                                                 
                 :                                                                                                                                           
               5 :         return null;                                                                                                                      
                 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 :     /**                                                                                                                                   
                 :      * Gets the position of the last token found using one of the search functions                                                        
                 :      **/                                                                                                                                  
                 :     final protected function getTokenPos()                                                                                                
                 :     {                                                                                                                                     
               6 :         return $this->token_pos;                                                                                                          
                 :     }                                                                                                                                     
                 :                                                                                                                                           
                 :                                                                                                                                           
                 : }                                                                                                                                         
                 :                                                                                                                                           
                 :                                                                                                                                           
                 : ?>