vendor/PHPCodeAnalyzer/PHPCodeAnalyzer.php

   1 <?php
   2 /**
   3 * A class for performing code analysis for php scripts
   4 * It is designed to be the heart of a code limiting script
   5 * to use with Savant {@link http://phpsavant.com}
   6 *
   7 * This code should be php4 compatiable but i've only run it in php5 and some of the Tokenizer constants have changed
   8 *
   9 * @author       Joshua Eichorn <josh@bluga.net>
  10 * @copyright    Joshua Eichorn 2004
  11 * @package      PHPCodeAnalyzer
  12 *
  13 * This program is free software; you can redistribute it and/or modify
  14 * it under the terms of the GNU Lesser General Public License as
  15 * published by the Free Software Foundation; either version 2.1 of the
  16 * License, or (at your option) any later version.
  17 *
  18 * This program is distributed in the hope that it will be useful, but
  19 * WITHOUT ANY WARRANTY; without even the implied warranty of
  20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 * Lesser General Public License for more details.
  22 *
  23 * @license http://www.gnu.org/copyleft/lesser.html LGPL
  24 */
  25
  26 /**#@+
  27 * compat tokeniezer defines
  28 */
  29 if (! defined('T_OLD_FUNCTION')) {
  30     define('T_OLD_FUNCTION', T_FUNCTION);
  31 }
  32 if (!defined('T_ML_COMMENT')) {
  33     define('T_ML_COMMENT', T_COMMENT);
  34 } else {
  35     define('T_DOC_COMMENT', T_ML_COMMENT);
  36 }
  37 /**#@-*/
  38
  39 /**
  40 * Code Analysis class
  41 *
  42 * Example Usage:
  43 * <code>
  44 * $analyzer = new PHPCodeAnalyzer();
  45 * $analyzer->source = file_get_contents(__FILE__);
  46 * $analyzer->analyze();
  47 * print_r($analyzer->calledMethods);
  48 * </code>
  49 *
  50 * @todo is it important to grab the details from creating new functions defines classes?
  51 * @todo support php5 only stuff like interface
  52 *
  53 * @version      0.4
  54 * @license http://www.gnu.org/copyleft/lesser.html LGPL
  55 * @copyright    Joshua Eichorn 2004
  56 * @package      PHPCodeAnalyzer
  57 * @author       Joshua Eichorn <josh@bluga.net>
  58 */
  59 class PHPCodeAnalyzer
  60 {
  61     /**
  62         * Source code to analyze
  63         */
  64     var $source = "";
  65
  66     /**
  67         * functions called
  68         */
  69     var $calledFunctions = array();
  70
  71     /**
  72         * Called constructs
  73         */
  74     var $calledConstructs = array();
  75
  76     /**
  77         * methods called
  78         */
  79     var $calledMethods = array();
  80
  81     /**
  82         * static methods called
  83         */
  84     var $calledStaticMethods = array();
  85
  86     /**
  87         * new classes instantiated
  88         */
  89     var $classesInstantiated = array();
  90
  91     /**
  92         * variables used
  93         */
  94     var $usedVariables = array();
  95
  96     /**
  97         * member variables used
  98         */
  99     var $usedMemberVariables = array();
 100
 101     /**
 102         * classes created
 103         */
 104     var $createdClasses = array();
 105
 106     /**
 107         * functions created
 108         */
 109     var $createdFunctions = array();
 110
 111     /**
 112         * Files includes or requried
 113         */
 114     var $filesIncluded = array();
 115
 116     // private variables
 117     /**#@+
 118     * @access private
 119     */
 120     var $currentString = null;
 121     var $currentStrings = null;
 122     var $currentVar = false;
 123     var $staticClass = false;
 124     var $inNew = false;
 125     var $inInclude = false;
 126     var $lineNumber = 1;
 127     var $_previousToken = null;
 128     /**#@-*/
 129
 130     /**
 131         * parse source filling informational arrays
 132         */
 133     function analyze()
 134     {
 135         $tokens = token_get_all($this->source);
 136
 137         // mapping of token to method to call
 138         $handleMap = array(
 139         T_STRING => 'handleString',
 140         T_CONSTANT_ENCAPSED_STRING => 'handleString',
 141         T_ENCAPSED_AND_WHITESPACE => 'handleString',
 142         T_CHARACTER => 'handleString',
 143         T_NUM_STRING => 'handleString',
 144         T_DNUMBER => 'handleString',
 145         T_FUNC_C => 'handleString',
 146         T_CLASS_C => 'handleString',
 147         T_FILE => 'handleString',
 148         T_LINE => 'handleString',
 149         T_DOUBLE_ARROW => 'handleString',
 150
 151         T_ARRAY => 'handleClearStrings',
 152         T_CONCAT_EQUAL => 'handleClearStrings',
 153
 154         T_DOUBLE_COLON => 'handleDoubleColon',
 155         T_NEW => 'handleNew',
 156         T_OBJECT_OPERATOR => 'handleObjectOperator',
 157         T_VARIABLE => 'handleVariable',
 158         T_FUNCTION => 'handleFunction',
 159         T_OLD_FUNCTION => 'handleFunction',
 160         T_CLASS => 'handleClass',
 161         T_WHITESPACE => 'handleWhitespace',
 162         T_INLINE_HTML => 'handleWhitespace',
 163         T_OPEN_TAG => 'handleWhitespace',
 164         T_CLOSE_TAG => 'handleWhitespace',
 165
 166         T_AS    => 'handleAs',
 167
 168         T_ECHO => 'handleConstruct',
 169         T_EVAL => 'handleConstruct',
 170         T_UNSET => 'handleConstruct',
 171         T_ISSET => 'handleConstruct',
 172         T_PRINT => 'handleConstruct',
 173         T_FOR   => 'handleConstruct',
 174         T_FOREACH=> 'handleConstruct',
 175         T_EMPTY => 'handleConstruct',
 176         T_EXIT  => 'handleConstruct',
 177         T_CASE  => 'handleConstruct',
 178         T_GLOBAL=> 'handleConstruct',
 179         T_UNSET => 'handleConstruct',
 180         T_WHILE => 'handleConstruct',
 181         T_DO    => 'handleConstruct',
 182         T_IF    => 'handleConstruct',
 183         T_LIST  => 'handleConstruct',
 184         T_RETURN=> 'handleConstruct',
 185         T_STATIC=> 'handleConstruct',
 186         T_ENDFOR=> 'handleConstruct',
 187         T_ENDFOREACH=> 'handleConstruct',
 188         T_ENDIF=> 'handleConstruct',
 189         T_ENDSWITCH=> 'handleConstruct',
 190         T_ENDWHILE=> 'handleConstruct',
 191
 192         T_INCLUDE => 'handleInclude',
 193         T_INCLUDE_ONCE => 'handleInclude',
 194         T_REQUIRE => 'handleInclude',
 195         T_REQUIRE_ONCE => 'handleInclude',
 196         );
 197
 198         foreach($tokens as $token)
 199         {
 200             if (is_string($token))
 201             {
 202                 // we have a simple 1-character token
 203                 $this->handleSimpleToken($token);
 204             }
 205             else
 206             {
 207                 list($id, $text) = $token;
 208                 if (isset($handleMap[$id]))
 209                 {
 210                     $call = $handleMap[$id];
 211                     $this->$call($id,$text);
 212                 }
 213                 /*else * /
 214                 {
 215                 echo token_name($id).": $text<br>\n";
 216                 } /* */
 217             }
 218         }
 219     }
 220
 221     /**
 222         * Handle a 1 char token
 223         * @access private
 224         */
 225     function handleSimpleToken($token)
 226     {
 227         if ($token !== ";")
 228         {
 229             $this->currentStrings .= $token;
 230         }
 231         switch($token)
 232         {
 233             case "(":
 234                 // method is called
 235                 if ($this->staticClass !== false)
 236                 {
 237                     if (!isset($this->calledStaticMethods[$this->staticClass][$this->currentString]))
 238                     {
 239                         $this->calledStaticMethods[$this->staticClass][$this->currentString]
 240                         = array();
 241                     }
 242                     $this->calledStaticMethods[$this->staticClass][$this->currentString][]
 243                     = $this->lineNumber;
 244                     $this->staticClass = false;
 245                 }
 246                 else if ($this->currentVar !== false)
 247                 {
 248                     if (!isset($this->calledMethods[$this->currentVar][$this->currentString]))
 249                     {
 250                         $this->calledMethods[$this->currentVar][$this->currentString] = array();
 251                     }
 252                     $this->calledMethods[$this->currentVar][$this->currentString][] = $this->lineNumber;
 253                     $this->currentVar = false;
 254                 }
 255                 else if ($this->inNew !== false)
 256                 {
 257                     $this->classInstantiated();
 258                 }
 259                 else if ($this->currentString !== null)
 260                 {
 261                     $this->functionCalled();
 262                 }
 263                 //$this->currentString = null;
 264                 break;
 265             case "=":
 266             case ";":
 267             case "?":
 268             case ":":
 269                 if ($this->inNew !== false)
 270                 {
 271                     $this->classInstantiated();
 272                 }
 273                 else if ($this->inInclude !== false)
 274                 {
 275                     $this->fileIncluded();
 276                 }
 277                 else if ($this->currentVar !== false)
 278                 {
 279                     $this->useMemberVar();
 280                 }
 281                 $this->currentString = null;
 282                 $this->currentStrings = null;
 283                 break;
 284
 285             case ']':
 286                 $this->useMemberVar(false);
 287                 break;
 288             case '{':
 289                 if($this->_previousToken == ')'){
 290                     $this->currentVar = false;
 291                     $this->currentString = null;
 292                 }
 293                 break;
 294         }
 295         $this->_previousToken = $token;
 296     }
 297
 298     /**
 299         * handle includes and requires
 300         * @access private
 301         */
 302     function handleInclude($id,$text)
 303     {
 304         $this->inInclude = true;
 305         $this->handleConstruct($id,$text);
 306     }
 307
 308     /**
 309         * handle String tokens
 310         * @access private
 311         */
 312     function handleString($id,$text)
 313     {
 314         $this->currentString = $text;
 315         $this->currentStrings .= $text;
 316     }
 317
 318     /**
 319         * handle String tokens
 320         * @access private
 321         */
 322     function handleClearStrings($id,$text)
 323     {
 324         $this->currentString = '';
 325     }
 326
 327     /**
 328         * handle variables
 329         * @access private
 330         */
 331     function handleVariable($id,$text)
 332     {
 333         $this->currentString = $text;
 334         $this->currentStrings .= $text;
 335         $this->useVariable();
 336     }
 337
 338
 339     /**
 340         * handle Double Colon tokens
 341         * @access private
 342         */
 343     function handleDoubleColon($id,$text)
 344     {
 345         $this->staticClass = $this->currentString;
 346         $this->currentString = null;
 347     }
 348
 349     /**
 350         * handle new keyword
 351         * @access private
 352         */
 353     function handleNew($id,$text)
 354     {
 355         $this->inNew = true;
 356     }
 357
 358     /**
 359         * handle function
 360         * @access private
 361         */
 362     function handleFunction($id,$text)
 363     {
 364         $this->createdFunctions[] = $this->lineNumber;
 365     }
 366
 367     /**
 368         * handle class
 369         * @access private
 370         */
 371     function handleClass($id,$text)
 372     {
 373         $this->createdClasses[] = $this->lineNumber;
 374     }
 375
 376     /**
 377         * Handle ->
 378         * @access private
 379         */
 380     function handleObjectOperator($id,$text)
 381     {
 382         $this->currentVar = $this->currentString;
 383         $this->currentString = null;
 384         $this->currentStrings .= $text;
 385     }
 386
 387     /**
 388         * handle whitespace to figure out line counts
 389         * @access private
 390         */
 391     function handleWhitespace($id,$text)
 392     {
 393         $this->lineNumber+=substr_count($text,"\n");
 394         if ($id == T_CLOSE_TAG)
 395         {
 396             $this->handleSimpleToken(";");
 397         }
 398     }
 399
 400
 401     /**
 402         * as has been used we must have a var before it
 403         *
 404         * @access private
 405         */
 406     function handleAs($id,$text)
 407     {
 408         $this->handleSimpleToken(";");
 409     }
 410
 411     /**
 412         * a language construct has been called record it
 413         * @access private
 414         */
 415     function handleConstruct($id,$construct)
 416     {
 417         if (!isset($this->calledConstructs[$construct]))
 418         {
 419             $this->calledConstructs[$construct] = array();
 420         }
 421         $this->calledConstructs[$construct][] = $this->lineNumber;
 422         $this->currentString = null;
 423     }
 424
 425     /**
 426         * a class was Instantiated record it
 427         * @access private
 428         */
 429     function classInstantiated()
 430     {
 431         if (!isset($this->classesInstantiated[$this->currentString]))
 432         {
 433             $this->classesInstantiated[$this->currentString] = array();
 434         }
 435         $this->classesInstantiated[$this->currentString][] = $this->lineNumber;
 436         $this->inNew = false;
 437     }
 438
 439     /**
 440         * a file was included record it
 441         * @access private
 442         */
 443     function fileIncluded()
 444     {
 445         if (!isset($this->filesIncluded[$this->currentStrings]))
 446         {
 447             $this->filesIncluded[$this->currentStrings] = array();
 448         }
 449         $this->filesIncluded[$this->currentStrings][] = $this->lineNumber;
 450         $this->inInclude = false;
 451         $this->currentString = null;
 452         $this->currentStrings = "";
 453     }
 454
 455     /**
 456         * a function was called record it
 457         * @access private
 458         */
 459     function functionCalled($id = false)
 460     {
 461         $function_name = trim(rtrim($this->currentStrings,'('));
 462         if(empty($this->currentStrings) || substr($function_name,-1) != ']'){
 463             $function_name = $this->currentString;
 464             if(strstr('"\'',substr($function_name,-1))){
 465                 $this->currentString = null;
 466                 return ;
 467             }
 468         }
 469
 470         if (!isset($this->calledFunctions[$function_name]))
 471         {
 472             $this->calledFunctions[$function_name] = array();
 473         }
 474
 475         $this->calledFunctions[$function_name][] = $this->lineNumber;
 476         $this->currentString = null;
 477     }
 478
 479     /**
 480         * we used a member variable record it
 481         * @access private
 482         */
 483     function useMemberVar($reset = true)
 484     {
 485         if (!isset($this->usedMemberVariables[$this->currentVar][$this->currentString])){
 486             $this->usedMemberVariables[$this->currentVar][$this->currentString] = array();
 487         }
 488         $this->usedMemberVariables[$this->currentVar][$this->currentString][] = $this->lineNumber;
 489         if($reset){
 490             $this->currentVar = false;
 491             $this->currentString = null;
 492         }
 493     }
 494
 495     /**
 496         * we used a variable record it
 497         * @access private
 498         */
 499     function useVariable()
 500     {
 501         if (!isset($this->usedVariables[$this->currentString]))
 502         {
 503             $this->usedVariables[$this->currentString] = array();
 504         }
 505         $this->usedVariables[$this->currentString][] = $this->lineNumber;
 506     }
 507 }
 508 ?>