: <?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/>.                                                                             
                 : */                                                                                                                                           
                 :                                                                                                                                              
                 :                                                                                                                                              
                 : /**                                                                                                                                          
                 :  * PHP Parser                                                                                                                                
                 :  * @package Parsers                                                                                                                          
                 :  * @author Josh Heidenreich                                                                                                                  
                 :  * @since 0.1                                                                                                                                
                 :  **/                                                                                                                                         
                 :                                                                                                                                              
                 : /**                                                                                                                                          
                 :  * This is the parser for PHP files. It converts a file from the raw PHP into a document tree                                                
                 :  *                                                                                                                                           
                 :  * @todo Convert to new parser system (e.g. Javascript parser)                                                                               
                 :  * @todo Add support for namespaces, even on PHP < 5.3                                                                                       
                 :  **/                                                                                                                                         
                 : class PhpParser                                                                                                                              
                 : {                                                                                                                                            
                 :                                                                                                                                              
                 :     /**                                                                                                                                      
                 :      * Parses a specific file                                                                                                                
                 :      **/                                                                                                                                     
                 :     function parseFile($base_dir, $filename)                                                                                                 
                 :     {                                                                                                                                        
                 :         // You can enable the following if you want to debug the parser                                                                      
                 :         // If you enable the line after it (the 'strpos' line) instead,                                                                      
                 :         // it will only debug files containing 'test' (e.g. 'php_test.php')                                                                  
              97 :         $debug = false;                                                                                                                      
                 :         // if (strpos ($filename, 'test') !== false) $debug = true;                                                                          
                 :                                                                                                                                              
              97 :         $source = @file_get_contents($base_dir . $filename);                                                                                 
              97 :         if ($source == null) return null;                                                                                                    
                 :                                                                                                                                              
              97 :         $tokens = @token_get_all($source);                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
              97 :         $current_file = new ParserFile ();                                                                                                   
              97 :         $current_file->name = $filename;                                                                                                     
              97 :         $current_file->source = $source;                                                                                                     
                 :                                                                                                                                              
              97 :         unset ($source);                                                                                                                     
                 :                                                                                                                                              
                 :         // the vars that make it tick                                                                                                        
              97 :         $current_function = null;                                                                                                            
              97 :         $inside_function = null;                                                                                                             
              97 :         $current_class = null;                                                                                                               
              97 :         $inside_class = null;                                                                                                                
              97 :         $current_constant = null;                                                                                                            
              97 :         $next = null;                                                                                                                        
              97 :         $namespace = 0;                                                                                                                      
              97 :         $brace_count = 0;                                                                                                                    
              97 :         $abstract = false;                                                                                                                   
              97 :         $static = false;                                                                                                                     
              97 :         $final = false;                                                                                                                      
              97 :         $next_comment = null;                                                                                                                
              97 :         $file_has_comment = false;                                                                                                           
                 :                                                                                                                                              
                 :         // debugger                                                                                                                          
              97 :         if ($debug) {                                                                                                                        
              57 :             echo '<style>';                                                                                                                  
               0 :             echo 'span {color: green;}';                                                                                                     
               0 :             echo 'h3 {border: 4px black solid; padding: 3px; margin-top: 2em;}';                                                             
               0 :             echo 'i {color: gray;}';                                                                                                         
               0 :             echo '</style>';                                                                                                                 
                 :                                                                                                                                              
               0 :             echo '<h3>', htmlspecialchars($filename), '</h3>';                                                                               
               0 :             echo '<pre>';                                                                                                                    
               0 :         }                                                                                                                                    
                 :                                                                                                                                              
              97 :         $argument = null;                                                                                                                    
              97 :         $visibility = null;                                                                                                                  
              97 :         $param_type = null;                                                                                                                  
              97 :         foreach ($tokens as $token) {                                                                                                        
              97 :             if (is_array($token) and $token[0] == T_WHITESPACE) continue;                                                                    
                 :                                                                                                                                              
                 :             // debugger                                                                                                                      
              97 :             if ($debug) {                                                                                                                    
               0 :                 echo "\n";                                                                                                                   
               0 :                 if (is_string($token)) {                                                                                                     
               0 :                     echo "BARE TEXT\n<i>" . htmlspecialchars($token) . "</i>\n";                                                             
               0 :                 } else {                                                                                                                     
               0 :                     echo htmlspecialchars(token_name($token[0])) . "\n<i>" . htmlspecialchars(str_replace("\n", '\n', $token[1])) . "</i>\n";
                 :                 }                                                                                                                            
               0 :             }                                                                                                                                
                 :                                                                                                                                              
              97 :             if (is_string($token)) {                                                                                                         
                 :                 // opening of a function or class block                                                                                      
              96 :                 if ($token == '{') {                                                                                                         
                 :                     // opening of function                                                                                                   
              94 :                     if ($current_function != null) {                                                                                         
              62 :                         if ($inside_class != null) {                                                                                         
              20 :                             if ($visibility != null) {                                                                                       
               4 :                                 $current_function->visibility = $visibility;                                                                 
               4 :                                 $visibility = null;                                                                                          
               4 :                             }                                                                                                                
              20 :                             $inside_class->functions[] = $current_function;                                                                  
                 :                                                                                                                                              
              20 :                         } else {                                                                                                             
              44 :                             $current_file->functions[] = $current_function;                                                                  
                 :                         }                                                                                                                    
                 :                                                                                                                                              
              62 :                         $current_function->post_load();                                                                                      
              62 :                         $inside_function = $current_function;                                                                                
              62 :                         $current_function = null;                                                                                            
              62 :                         $argument = null;                                                                                                    
                 :                                                                                                                                              
                 :                         // opening of class                                                                                                  
              94 :                     } else if ($current_class != null) {                                                                                     
              53 :                         if ($visibility != null) {                                                                                           
               0 :                             $current_class->visibility = $visibility;                                                                        
               0 :                             $visibility = null;                                                                                              
               0 :                         }                                                                                                                    
              53 :                         $current_file->classes[] = $current_class;                                                                           
              53 :                         $inside_class = $current_class;                                                                                      
              53 :                         $current_class = null;                                                                                               
              53 :                         $next = null;                                                                                                        
               3 :                                                                                                                                              
              53 :                     } else {                                                                                                                 
               9 :                         $brace_count++;                                                                                                      
                 :                     }                                                                                                                        
                 :                                                                                                                                              
                 :                                                                                                                                              
                 :                     // function in an interface                                                                                              
              96 :                 } else if ($token == ';') {                                                                                                  
              25 :                     if ($namespace == 1) {                                                                                                   
               5 :                         $namespace = 2;                                                                                                      
              25 :                     } else if ($current_function != null) {                                                                                  
               4 :                         if ($visibility != null) {                                                                                           
               0 :                             $current_function->visibility = $visibility;                                                                     
               0 :                             $visibility = null;                                                                                              
               0 :                         }                                                                                                                    
               4 :                         $current_function->post_load();                                                                                      
               4 :                         $inside_class->functions[] = $current_function;                                                                      
               4 :                         $current_function = null;                                                                                            
               4 :                     }                                                                                                                        
                 :                                                                                                                                              
                 :                                                                                                                                              
                 :                     // closing of a class or function block                                                                                  
              96 :                 } else if ($token == '}') {                                                                                                  
              94 :                     if ($brace_count == 0) {                                                                                                 
              94 :                         if ($inside_function != null) {                                                                                      
              62 :                             $inside_function = null;                                                                                         
              94 :                         } else if ($inside_class != null) {                                                                                  
              53 :                             $inside_class = null;                                                                                            
              53 :                         }                                                                                                                    
                 :                                                                                                                                              
              94 :                     } else {                                                                                                                 
               9 :                         $brace_count--;                                                                                                      
                 :                     }                                                                                                                        
              94 :                 }                                                                                                                            
                 :                                                                                                                                              
              96 :             } else {                                                                                                                         
                 :                 // token array                                                                                                               
              97 :                 list($id, $text, $linenum) = $token;                                                                                         
                 :                                                                                                                                              
                 :                 switch ($id) {                                                                                                               
              97 :                 case T_CURLY_OPEN:                                                                                                           
               0 :                     $brace_count++;                                                                                                          
               0 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
              97 :                 case T_DOC_COMMENT:                                                                                                          
              44 :                     if ($next_comment and ! $file_has_comment) {                                                                             
               2 :                         $current_file->applyComment($next_comment);                                                                          
               2 :                         $next_comment = null;                                                                                                
               2 :                         $file_has_comment = true;                                                                                            
               2 :                     }                                                                                                                        
              44 :                     $next_comment = $text;                                                                                                   
              44 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
              97 :                 case T_FUNCTION:                                                                                                             
              64 :                     if ($inside_function != null) {                                                                                          
               8 :                         break;                                                                                                               
                 :                     }                                                                                                                        
              64 :                     $current_function = new ParserFunction();                                                                                
              64 :                     $current_function->linenum = $linenum;                                                                                   
              64 :                     if ($abstract) {                                                                                                         
               1 :                         $current_function->abstract = true;                                                                                  
               1 :                         $abstract = false;                                                                                                   
               1 :                     }                                                                                                                        
              64 :                     if ($static) {                                                                                                           
               1 :                         $current_function->static = true;                                                                                    
               1 :                         $static = false;                                                                                                     
               1 :                     }                                                                                                                        
              64 :                     if ($final) {                                                                                                            
               1 :                         $current_function->final = true;                                                                                     
               1 :                         $final = false;                                                                                                      
               1 :                     }                                                                                                                        
              64 :                     if ($next_comment) {                                                                                                     
              34 :                         $current_function->applyComment($next_comment);                                                                      
              34 :                         $next_comment = null;                                                                                                
              34 :                     }                                                                                                                        
              64 :                     $param_type = null;                                                                                                      
              64 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
              97 :                 case T_CLASS:                                                                                                                
              45 :                     $current_class = new ParserClass();                                                                                      
              45 :                     $current_class->linenum = $linenum;                                                                                      
              45 :                     if ($abstract) {                                                                                                         
               1 :                         $current_class->abstract = true;                                                                                     
               1 :                         $abstract = false;                                                                                                   
              45 :                     } else if ($final) {                                                                                                     
               0 :                         $current_class->final = true;                                                                                        
               0 :                         $final = false;                                                                                                      
               0 :                     }                                                                                                                        
              45 :                     if ($next_comment) {                                                                                                     
               9 :                         $current_class->applyComment($next_comment);                                                                         
               9 :                         $next_comment = null;                                                                                                
               9 :                     }                                                                                                                        
              45 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
              97 :                 case T_INTERFACE:                                                                                                            
              10 :                     $current_class = new ParserInterface();                                                                                  
              10 :                     $current_class->linenum = $linenum;                                                                                      
              10 :                     if ($next_comment) {                                                                                                     
               4 :                         $current_class->applyComment($next_comment);                                                                         
               4 :                         $next_comment = null;                                                                                                
               4 :                     }                                                                                                                        
              10 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
                 :                     // variables are added according to scope                                                                                
                 :                     // will become a ParserVariable or a ParserArgument                                                                      
              97 :                 case T_VARIABLE:                                                                                                             
              37 :                     if ($current_function != null) {                                                                                         
              22 :                         $argument = new ParserArgument();                                                                                    
              22 :                         $argument->linenum = $linenum;                                                                                       
              22 :                         $argument->name = $text;                                                                                             
              22 :                         if ($param_type != null) {                                                                                           
              10 :                             $argument->type = $param_type;                                                                                   
              10 :                             $param_type = null;                                                                                              
              10 :                         }                                                                                                                    
              22 :                         $current_function->args[] = $argument;                                                                               
                 :                                                                                                                                              
              37 :                     } else if (($inside_class != null) && ($inside_function == null)) {                                                      
               8 :                         $variable = new ParserVariable();                                                                                    
               8 :                         $variable->linenum = $linenum;                                                                                       
               8 :                         $variable->name = $text;                                                                                             
               8 :                         $variable->visibility = $visibility ?: 'private';                                                                    
               8 :                         $visibility = null;                                                                                                  
               8 :                         if ($static) {                                                                                                       
               0 :                             $variable->static = true;                                                                                        
               0 :                             $static = false;                                                                                                 
               0 :                         }                                                                                                                    
               8 :                         if ($next_comment) {                                                                                                 
               3 :                             $variable->applyComment($next_comment);                                                                          
               3 :                             $next_comment = null;                                                                                            
               3 :                         }                                                                                                                    
               8 :                         $inside_class->variables[] = $variable;                                                                              
               8 :                     }                                                                                                                        
              37 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
                 :                     // A string my become an extends, implements                                                                             
                 :                     // function name or class name                                                                                           
                 :                     // it could also be 'define' or 'null'                                                                                   
              97 :                 case T_STRING:                                                                                                               
              96 :                     if ($next != null) {                                                                                                     
              11 :                         if ($next == T_EXTENDS) {                                                                                            
               4 :                             $current_class->extends = $text;                                                                                 
              11 :                         } else if ($next == T_IMPLEMENTS) {                                                                                  
               5 :                             $current_class->implements[] = $text;                                                                            
               5 :                             break;                                                                                                           
               5 :                         } else if ($next == T_NAMESPACE and $namespace == 0) {                                                               
               5 :                             $current_file->namespace = array($text);                                                                         
               5 :                             $namespace = 1;                                                                                                  
               5 :                         } else if ($next == T_NS_SEPARATOR and $namespace == 1) {                                                            
               4 :                             $current_file->namespace[] = $text;                                                                              
               4 :                         }                                                                                                                    
               9 :                         $next = null;                                                                                                        
                 :                                                                                                                                              
              96 :                     } else if (strcasecmp($text, 'null') == 0) {                                                                             
               0 :                         if ($current_constant) {                                                                                             
               0 :                             $current_constant->value = 'NULL';                                                                               
               0 :                             $current_file->constants[] = $current_constant;                                                                  
               0 :                             $current_constant = null;                                                                                        
                 :                                                                                                                                              
               0 :                         } else if ($argument) {                                                                                              
               0 :                             $argument->default = 'NULL';                                                                                     
               0 :                         }                                                                                                                    
                 :                                                                                                                                              
              96 :                     } else if (strcasecmp($text, 'true') == 0) {                                                                             
               2 :                         if ($current_constant) {                                                                                             
               1 :                             $current_constant->value = 'TRUE';                                                                               
               1 :                             $current_file->constants[] = $current_constant;                                                                  
               1 :                             $current_constant = null;                                                                                        
                 :                                                                                                                                              
               2 :                         } else if ($argument) {                                                                                              
               0 :                             $argument->default = 'TRUE';                                                                                     
               0 :                         }                                                                                                                    
                 :                                                                                                                                              
              96 :                     } else if (strcasecmp($text, 'false') == 0) {                                                                            
               0 :                         if ($current_constant) {                                                                                             
               0 :                             $current_constant->value = 'FALSE';                                                                              
               0 :                             $current_file->constants[] = $current_constant;                                                                  
               0 :                             $current_constant = null;                                                                                        
                 :                                                                                                                                              
               0 :                         } else if ($argument) {                                                                                              
               0 :                             $argument->default = 'FALSE';                                                                                    
               0 :                         }                                                                                                                    
                 :                                                                                                                                              
              96 :                     } else if ($current_function != null) {                                                                                  
              64 :                         if ($current_function->name == '') {                                                                                 
              64 :                             $current_function->name = $text;                                                                                 
              64 :                         } else {                                                                                                             
               4 :                             $param_type = $text;                                                                                             
                 :                         }                                                                                                                    
                 :                                                                                                                                              
              96 :                     } else if ($current_class != null) {                                                                                     
              53 :                         $current_class->name = $text;                                                                                        
                 :                                                                                                                                              
              56 :                     } else if (strcasecmp($text, 'define') == 0) {                                                                           
               4 :                         $current_constant = new ParserConstant();                                                                            
               4 :                         $current_constant->linenum = $linenum;                                                                               
               4 :                         if ($next_comment) {                                                                                                 
               2 :                             $current_constant->applyComment($next_comment);                                                                  
               2 :                             $next_comment = null;                                                                                            
               2 :                         }                                                                                                                    
                 :                                                                                                                                              
               4 :                     }                                                                                                                        
              96 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
              97 :                 case T_ARRAY:                                                                                                                
               6 :                     if ($current_function != null) {                                                                                         
               6 :                         $param_type = $text;                                                                                                 
               6 :                     }                                                                                                                        
               6 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
              97 :                 case T_CONSTANT_ENCAPSED_STRING:                                                                                             
                 :                     // removes quotes, etc                                                                                                   
               5 :                     $name_search = array("\'", '\"', "'", '"');                                                                              
               5 :                     $name_replace = array("'", '"', '', '');                                                                                 
               5 :                     $text = str_replace($name_search, $name_replace, $text);                                                                 
                 :                                                                                                                                              
               5 :                     if ($current_constant) {                                                                                                 
               4 :                         if ($current_constant->name == null) {                                                                               
               4 :                             $current_constant->name = $text;                                                                                 
               4 :                         } else {                                                                                                             
               3 :                             $current_constant->value = $text;                                                                                
               3 :                             $current_file->constants[] = $current_constant;                                                                  
               3 :                             $current_constant = null;                                                                                        
                 :                         }                                                                                                                    
                 :                                                                                                                                              
               5 :                     } else if ($argument) {                                                                                                  
               1 :                         $argument->default = $text;                                                                                          
               1 :                     }                                                                                                                        
               5 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
              97 :                 case T_LNUMBER:                                                                                                              
              97 :                 case T_DNUMBER:                                                                                                              
               1 :                     if ($current_constant) {                                                                                                 
               0 :                         if ($current_constant->name != null) {                                                                               
               0 :                             $current_constant->value = $text;                                                                                
               0 :                             $current_file->constants[] = $current_constant;                                                                  
               0 :                             $current_constant = null;                                                                                        
               0 :                         }                                                                                                                    
                 :                                                                                                                                              
               1 :                     } else if ($argument) {                                                                                                  
               0 :                         $argument->default = $text;                                                                                          
               0 :                     }                                                                                                                        
               1 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
                 :                     // visibility                                                                                                            
              97 :                 case T_PRIVATE:                                                                                                              
               5 :                     $visibility = 'private';                                                                                                 
               5 :                     break;                                                                                                                   
                 :                                                                                                                                              
              97 :                 case T_PROTECTED:                                                                                                            
               2 :                     $visibility = 'protected';                                                                                               
               2 :                     break;                                                                                                                   
                 :                                                                                                                                              
              97 :                 case T_PUBLIC:                                                                                                               
               3 :                     $visibility = 'public';                                                                                                  
               3 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                                                                                                                                              
                 :                     // the next token after one of these does the grunt work                                                                 
              97 :                 case T_EXTENDS:                                                                                                              
              97 :                 case T_IMPLEMENTS:                                                                                                           
              97 :                 case T_NAMESPACE:                                                                                                            
              97 :                 case T_NS_SEPARATOR:                                                                                                         
              11 :                     $next = $id;                                                                                                             
              11 :                     break;                                                                                                                   
                 :                                                                                                                                              
              97 :                 case T_ABSTRACT:                                                                                                             
               2 :                     $abstract = true;                                                                                                        
               2 :                     break;                                                                                                                   
                 :                                                                                                                                              
              97 :                 case T_STATIC:                                                                                                               
               1 :                     if (! $inside_function) $static = true;                                                                                  
               1 :                     break;                                                                                                                   
                 :                                                                                                                                              
              97 :                 case T_FINAL:                                                                                                                
               1 :                     $final = true;                                                                                                           
               1 :                     break;                                                                                                                   
                 :                                                                                                                                              
                 :                 }                                                                                                                            
                 :             }                                                                                                                                
              97 :         }                                                                                                                                    
                 :                                                                                                                                              
                 :         // If there is a comment left that never got assigned,                                                                               
                 :         // assign it to the file                                                                                                             
              97 :         if ($next_comment and ! $file_has_comment) {                                                                                         
               1 :             $current_file->applyComment($next_comment);                                                                                      
               1 :             $next_comment = null;                                                                                                            
               1 :             $file_has_comment = true;                                                                                                        
               1 :         }                                                                                                                                    
                 :                                                                                                                                              
              97 :         if ($debug) echo '</pre>';                                                                                                           
                 :                                                                                                                                              
                 :                                                                                                                                              
              97 :         return $current_file;                                                                                                                
                 :     }                                                                                                                                        
                 :                                                                                                                                              
                 :                                                                                                                                              
                 : }                                                                                                                                            
                 :                                                                                                                                              
                 :                                                                                                                                              
                 : ?>