[Summary view] [Print] [Text view]

   1  <?php
   2  /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   3  
   4  // +----------------------------------------------------------------------+
   5  // | Akelos Framework - http://www.akelos.org                             |
   6  // +----------------------------------------------------------------------+
   7  // | Copyright (c) 2002-2006, Akelos Media, S.L.  & Bermi Ferrer Martinez |
   8  // | Released under the GNU Lesser General Public License, see LICENSE.txt|
   9  // +----------------------------------------------------------------------+
  10  
  11  require_once(AK_VENDOR_DIR.DS.'pear'.DS.'PHP'.DS.'Compat'.DS.'Constant'.DS.'T.php');
  12  
  13  /**
  14  * @todo Avoid the ussage of globals in the PHP parser
  15  */
  16  
  17  /**
  18   * This is a modified version of the pear/PHP_Shell package by Jan Kneschke
  19   * and is used for validating PHP in the interactive shell
  20   * before terminating execution with fatal errors.
  21   * 
  22   * @package ActiveSupport
  23   * @subpackage Console
  24   * @author Jan Kneschke <jan@kneschke.de>
  25   * @author Bermi Ferrer <bermi a.t akelos c.om>
  26   * @copyright Copyright (c) 2002-2006, Akelos Media, S.L. http://www.akelos.org
  27   * @license GNU Lesser General Public License <http://www.gnu.org/copyleft/lesser.html>
  28   */
  29  class AkPhpParser
  30  {
  31      var $errors = array();
  32      var $code = '';
  33  
  34      function AkPhpParser($code)
  35      {
  36          $this->code = trim($code);
  37      }
  38      /**
  39      * parse the PHP code
  40      *
  41      * we parse before we eval() the code to
  42      * - fetch fatal errors before they come up
  43      * - know about where we have to wait for closing braces
  44      *
  45      * @return int 0 if a executable statement is in the code-buffer, non-zero otherwise
  46      */
  47      function parse()
  48      {
  49  
  50          $this->code = trim($this->code);
  51          if (empty($this->code)){
  52              return 1;
  53          }
  54  
  55          $t = token_get_all('<?php '.$this->code.' ?>');
  56  
  57          $need_semicolon = 1; /* do we need a semicolon to complete the statement ? */
  58          $need_return = 1;    /* can we prepend a return to the eval-string ? */
  59          $eval = '';          /* code to be eval()'ed later */
  60          $braces = array();   /* to track if we need more closing braces */
  61  
  62          $methods = array();  /* to track duplicate methods in a class declaration */
  63          $ts = array();       /* tokens without whitespaces */
  64  
  65          foreach ($t as $ndx => $token) {
  66              if (is_array($token)) {
  67                  $ignore = 0;
  68  
  69                  switch($token[0]) {
  70                      case T_WHITESPACE:
  71                      case T_OPEN_TAG:
  72                      case T_CLOSE_TAG:
  73                      $ignore = 1;
  74                      break;
  75                      case T_FOREACH:
  76                      case T_DO:
  77                      case T_WHILE:
  78                      case T_FOR:
  79  
  80                      case T_IF:
  81                      case T_RETURN:
  82  
  83                      case T_CLASS:
  84                      case T_FUNCTION:
  85                      case T_INTERFACE:
  86  
  87                      case T_PRINT:
  88                      case T_ECHO:
  89  
  90                      case T_COMMENT:
  91                      case T_UNSET:
  92  
  93                      case T_INCLUDE:
  94                      case T_REQUIRE:
  95                      case T_INCLUDE_ONCE:
  96                      case T_REQUIRE_ONCE:
  97                      case T_TRY:
  98                      $need_return = 0;
  99                      break;
 100                      case T_VARIABLE:
 101                      case T_STRING:
 102                      case T_NEW:
 103                      case T_EXTENDS:
 104                      case T_IMPLEMENTS:
 105                      case T_OBJECT_OPERATOR:
 106                      case T_DOUBLE_COLON:
 107                      case T_INSTANCEOF:
 108  
 109                      case T_CATCH:
 110  
 111                      case T_ELSE:
 112                      case T_AS:
 113                      case T_LNUMBER:
 114                      case T_DNUMBER:
 115                      case T_CONSTANT_ENCAPSED_STRING:
 116                      case T_ENCAPSED_AND_WHITESPACE:
 117                      case T_CHARACTER:
 118                      case T_ARRAY:
 119                      case T_DOUBLE_ARROW:
 120  
 121                      case T_CONST:
 122                      case T_PUBLIC:
 123                      case T_PROTECTED:
 124                      case T_PRIVATE:
 125                      case T_ABSTRACT:
 126                      case T_STATIC:
 127                      case T_VAR:
 128  
 129                      case T_INC:
 130                      case T_DEC:
 131                      case T_SL:
 132                      case T_SL_EQUAL:
 133                      case T_SR:
 134                      case T_SR_EQUAL:
 135  
 136                      case T_IS_EQUAL:
 137                      case T_IS_IDENTICAL:
 138                      case T_IS_GREATER_OR_EQUAL:
 139                      case T_IS_SMALLER_OR_EQUAL:
 140  
 141                      case T_BOOLEAN_OR:
 142                      case T_LOGICAL_OR:
 143                      case T_BOOLEAN_AND:
 144                      case T_LOGICAL_AND:
 145                      case T_LOGICAL_XOR:
 146                      case T_MINUS_EQUAL:
 147                      case T_PLUS_EQUAL:
 148                      case T_MUL_EQUAL:
 149                      case T_DIV_EQUAL:
 150                      case T_MOD_EQUAL:
 151                      case T_XOR_EQUAL:
 152                      case T_AND_EQUAL:
 153                      case T_OR_EQUAL:
 154  
 155                      case T_FUNC_C:
 156                      case T_CLASS_C:
 157                      case T_LINE:
 158                      case T_FILE:
 159  
 160                      /* just go on */
 161                      break;
 162                      default:
 163                      /* debug unknown tags*/
 164                      error_log(sprintf("unknown tag: %d (%s): %s".PHP_EOL, $token[0], token_name($token[0]), $token[1]));
 165  
 166                      break;
 167                  }
 168                  if (!$ignore) {
 169                      $eval .= $token[1]." ";
 170                      $ts[] = array("token" => $token[0], "value" => $token[1]);
 171                  }
 172              } else {
 173                  $ts[] = array("token" => $token, "value" => '');
 174  
 175                  $last = count($ts) - 1;
 176  
 177                  switch ($token) {
 178                      case '(':
 179                      /* walk backwards through the tokens */
 180  
 181                      if ($last >= 3 &&
 182                      $ts[$last - 1]['token'] == T_STRING &&
 183                      $ts[$last - 2]['token'] == T_OBJECT_OPERATOR &&
 184                      $ts[$last - 3]['token'] == T_VARIABLE ) {
 185  
 186                          /* $object->method( */
 187  
 188                          /* $object has to exist and has to be a object */
 189                          $objname = $ts[$last - 3]['value'];
 190  
 191                          if (!isset($GLOBALS[ltrim($objname, '$')])) {
 192                              $this->addError(sprintf('Variable \'%s\' is not set', $objname));
 193                          }
 194  
 195                          $k = ltrim($objname, '$');
 196  
 197                          if(isset($GLOBALS[$k])){
 198                              $object = $GLOBALS[$k];
 199  
 200                              if (!is_object($object)) {
 201                                  $this->addError(sprintf('Variable \'%s\' is not a class', $objname));
 202                              }
 203  
 204                              $method = $ts[$last - 1]['value'];
 205  
 206                              /* obj */
 207  
 208                              if (!method_exists($object, $method)) {
 209                                  $this->addError(sprintf("Variable %s (Class '%s') doesn't have a method named '%s'",
 210                                  $objname, get_class($object), $method));
 211                              }
 212                          }
 213                      } else if ($last >= 3 &&
 214                      $ts[$last - 1]['token'] == T_VARIABLE &&
 215                      $ts[$last - 2]['token'] == T_OBJECT_OPERATOR &&
 216                      $ts[$last - 3]['token'] == T_VARIABLE ) {
 217  
 218                          /* $object->$method( */
 219  
 220                          /* $object has to exist and has to be a object */
 221                          $objname = $ts[$last - 3]['value'];
 222  
 223                          if (!isset($GLOBALS[ltrim($objname, '$')])) {
 224                              $this->addError(sprintf('Variable \'%s\' is not set', $objname));
 225                          }
 226                          $object = $GLOBALS[ltrim($objname, '$')];
 227  
 228                          if (!is_object($object)) {
 229                              $this->addError(sprintf('Variable \'%s\' is not a class', $objname));
 230                          }
 231  
 232                          $methodname = $ts[$last - 1]['value'];
 233  
 234                          if (!isset($GLOBALS[ltrim($methodname, '$')])) {
 235                              $this->addError(sprintf('Variable \'%s\' is not set', $methodname));
 236                          }
 237                          $method = $GLOBALS[ltrim($methodname, '$')];
 238  
 239                          /* obj */
 240  
 241                          if (!method_exists($object, $method)) {
 242                              $this->addError(sprintf("Variable %s (Class '%s') doesn't have a method named '%s'",
 243                              $objname, get_class($object), $method));
 244                          }
 245  
 246                      } else if ($last >= 6 &&
 247                      $ts[$last - 1]['token'] == T_STRING &&
 248                      $ts[$last - 2]['token'] == T_OBJECT_OPERATOR &&
 249                      $ts[$last - 3]['token'] == ']' &&
 250                      /* might be anything as index */
 251                      $ts[$last - 5]['token'] == '[' &&
 252                      $ts[$last - 6]['token'] == T_VARIABLE ) {
 253  
 254                          /* $object[...]->method( */
 255  
 256                          /* $object has to exist and has to be a object */
 257                          $objname = $ts[$last - 6]['value'];
 258  
 259                          if (!isset($GLOBALS[ltrim($objname, '$')])) {
 260                              $this->addError(sprintf('Variable \'%s\' is not set', $objname));
 261                          }
 262                          $array = $GLOBALS[ltrim($objname, '$')];
 263  
 264                          if (!is_array($array)) {
 265                              $this->addError(sprintf('Variable \'%s\' is not a array', $objname));
 266                          }
 267  
 268                          $andx = $ts[$last - 4]['value'];
 269  
 270                          if (!isset($array[$andx])) {
 271                              $this->addError(sprintf('%s[\'%s\'] is not set', $objname, $andx));
 272                          }
 273  
 274                          $object = $array[$andx];
 275  
 276                          if (!is_object($object)) {
 277                              $this->addError(sprintf('Variable \'%s\' is not a class', $objname));
 278                          }
 279  
 280                          $method = $ts[$last - 1]['value'];
 281  
 282                          /* obj */
 283  
 284                          if (!method_exists($object, $method)) {
 285                              $this->addError(sprintf("Variable %s (Class '%s') doesn't have a method named '%s'",
 286                              $objname, get_class($object), $method));
 287                          }
 288  
 289                      } else if ($last >= 3 &&
 290                      $ts[$last - 1]['token'] == T_STRING &&
 291                      $ts[$last - 2]['token'] == T_DOUBLE_COLON &&
 292                      $ts[$last - 3]['token'] == T_STRING ) {
 293  
 294                          /* Class::method() */
 295  
 296                          /* $object has to exist and has to be a object */
 297                          $classname = $ts[$last - 3]['value'];
 298  
 299                          if (!class_exists($classname)) {
 300                              $this->addError(sprintf('Class \'%s\' doesn\'t exist', $classname));
 301                          }
 302  
 303                          $method = $ts[$last - 1]['value'];
 304  
 305                          if (!empty($method) && !in_array($method, (array)get_class_methods($classname))) {
 306                              $this->addError(sprintf("Class '%s' doesn't have a method named '%s'",
 307                              $classname, $method));
 308                          }
 309                      } else if ($last >= 3 &&
 310                      $ts[$last - 1]['token'] == T_VARIABLE &&
 311                      $ts[$last - 2]['token'] == T_DOUBLE_COLON &&
 312                      $ts[$last - 3]['token'] == T_STRING ) {
 313  
 314                          /* Class::method() */
 315  
 316                          /* $object has to exist and has to be a object */
 317                          $classname = $ts[$last - 3]['value'];
 318  
 319                          if (!class_exists($classname)) {
 320                              $this->addError(sprintf('Class \'%s\' doesn\'t exist', $classname));
 321                          }
 322  
 323                          $methodname = $ts[$last - 1]['value'];
 324  
 325                          if (!isset($GLOBALS[ltrim($methodname, '$')])) {
 326                              $this->addError(sprintf('Variable \'%s\' is not set', $methodname));
 327                          }
 328                          $method = $GLOBALS[ltrim($methodname, '$')];
 329  
 330                          if (!in_array($method, get_class_methods($classname))) {
 331                              $this->addError(sprintf("Class '%s' doesn't have a method named '%s'",
 332                              $classname, $method));
 333                          }
 334  
 335                      } else if ($last >= 2 &&
 336                      $ts[$last - 1]['token'] == T_STRING &&
 337                      $ts[$last - 2]['token'] == T_NEW ) {
 338  
 339                          /* new Class() */
 340  
 341                          $classname = $ts[$last - 1]['value'];
 342  
 343                          if (!class_exists($classname)) {
 344                              $this->addError(sprintf('Class \'%s\' doesn\'t exist', $classname));
 345                          }
 346  
 347                          if(AK_PHP5){
 348                              $r = new ReflectionClass($classname);
 349  
 350                              if ($r->isAbstract()) {
 351                                  $this->addError(sprintf("Can't instantiate abstract Class '%s'", $classname));
 352                              }
 353  
 354                              if (!$r->isInstantiable()) {
 355                                  $this->addError(sprintf('Class \'%s\' can\'t be instantiated. Is the class abstract ?', $classname));
 356                              }
 357                          }
 358  
 359                      } else if ($last >= 2 &&
 360                      $ts[0]['token'] != T_CLASS &&
 361                      $ts[$last - 1]['token'] == T_STRING &&
 362                      $ts[$last - 2]['token'] == T_FUNCTION ) {
 363  
 364                          /* make sure we are not a in class definition */
 365  
 366                          /* function a() */
 367  
 368                          $func = $ts[$last - 1]['value'];
 369  
 370                          if (function_exists($func)) {
 371                              $this->addError(sprintf('Function \'%s\' is already defined', $func));
 372                          }
 373                      } else if ($last >= 4 &&
 374                      $ts[0]['token'] == T_CLASS &&
 375                      $ts[1]['token'] == T_STRING &&
 376                      $ts[$last - 1]['token'] == T_STRING &&
 377                      $ts[$last - 2]['token'] == T_FUNCTION ) {
 378  
 379                          /* make sure we are not a in class definition */
 380  
 381                          /* class a { .. function a() ... } */
 382  
 383                          $func = $ts[$last - 1]['value'];
 384                          $classname = $ts[1]['value'];
 385  
 386                          if (isset($methods[$func])) {
 387                              $this->addError(sprintf("Can't redeclare method '%s' in Class '%s'", $func, $classname));
 388                          }
 389  
 390                          $methods[$func] = 1;
 391  
 392                      } else if ($last >= 1 &&
 393                      $ts[$last - 1]['token'] == T_STRING ) {
 394                          /* func() */
 395                          $funcname = $ts[$last - 1]['value'];
 396  
 397                          if (!function_exists($funcname)) {
 398                              $this->addError(sprintf("Function %s() doesn't exist", $funcname));
 399                          }
 400                      } else if ($last >= 1 &&
 401                      $ts[$last - 1]['token'] == T_VARIABLE ) {
 402  
 403                          /* $object has to exist and has to be a object */
 404                          $funcname = $ts[$last - 1]['value'];
 405  
 406                          if (!isset($GLOBALS[ltrim($funcname, '$')])) {
 407                              $this->addError(sprintf('Variable \'%s\' is not set', $funcname));
 408                          }
 409                          $k = ltrim($funcname, '$');
 410  
 411                          if(isset($GLOBALS[$k])){
 412                              $func = $GLOBALS[$k];
 413  
 414                              if (!function_exists($func)) {
 415                                  $this->addError(sprintf("Function %s() doesn't exist", $func));
 416                              }
 417                          }
 418  
 419                      }
 420  
 421                      array_push($braces, $token);
 422                      break;
 423                      case '{':
 424                      $need_return = 0;
 425  
 426                      if ($last >= 2 &&
 427                      $ts[$last - 1]['token'] == T_STRING &&
 428                      $ts[$last - 2]['token'] == T_CLASS ) {
 429  
 430                          /* class name { */
 431  
 432                          $classname = $ts[$last - 1]['value'];
 433  
 434                          if (class_exists($classname)) {
 435                              $this->addError(sprintf("Class '%s' can't be redeclared", $classname));
 436                          }
 437                      } else if ($last >= 4 &&
 438                      $ts[$last - 1]['token'] == T_STRING &&
 439                      $ts[$last - 2]['token'] == T_EXTENDS &&
 440                      $ts[$last - 3]['token'] == T_STRING &&
 441                      $ts[$last - 4]['token'] == T_CLASS ) {
 442  
 443                          /* class classname extends classname { */
 444  
 445                          $classname = $ts[$last - 3]['value'];
 446                          $extendsname = $ts[$last - 1]['value'];
 447  
 448                          if (class_exists($classname, false)) {
 449                              $this->addError(sprintf("Class '%s' can't be redeclared",
 450                              $classname));
 451                          }
 452                          if (!class_exists($extendsname, false)) {
 453                              $this->addError(sprintf("Can't extend '%s' from not existing Class '%s'",
 454                              $classname, $extendsname));
 455                          }
 456                      } else if ($last >= 4 &&
 457                      $ts[$last - 1]['token'] == T_STRING &&
 458                      $ts[$last - 2]['token'] == T_IMPLEMENTS &&
 459                      $ts[$last - 3]['token'] == T_STRING &&
 460                      $ts[$last - 4]['token'] == T_CLASS ) {
 461  
 462                          /* class name implements interface { */
 463  
 464                          $classname = $ts[$last - 3]['value'];
 465                          $implements = $ts[$last - 1]['value'];
 466  
 467                          if (class_exists($classname, false)) {
 468                              $this->addError(sprintf("Class '%s' can't be redeclared",
 469                              $classname));
 470                          }
 471                          if (!interface_exists($implements, false)) {
 472                              $this->addError(sprintf("Can't implement not existing Interface '%s' for Class '%s'",
 473                              $implements, $classname));
 474                          }
 475                      }
 476  
 477                      array_push($braces, $token);
 478                      break;
 479                      case '}':
 480                      $need_return = 0;
 481                      case ')':
 482                      array_pop($braces);
 483                      break;
 484                  }
 485  
 486                  $eval .= $token;
 487              }
 488          }
 489  
 490          $last = count($ts) - 1;
 491          if ($last >= 2 &&
 492          $ts[$last - 0]['token'] == T_STRING &&
 493          $ts[$last - 1]['token'] == T_DOUBLE_COLON &&
 494          $ts[$last - 2]['token'] == T_STRING ) {
 495  
 496              /* Class::constant */
 497  
 498              /* $object has to exist and has to be a object */
 499              $classname = $ts[$last - 2]['value'];
 500  
 501              if (!class_exists($classname)) {
 502                  $this->addError(sprintf('Class \'%s\' doesn\'t exist', $classname));
 503              }
 504  
 505              $constname = $ts[$last - 0]['value'];
 506  
 507              if(AK_PHP5){
 508                  $c = new ReflectionClass($classname);
 509                  if (!$c->hasConstant($constname)) {
 510                      $this->addError(sprintf("Class '%s' doesn't have a constant named '%s'",
 511                      $classname, $constname));
 512                  }
 513              }
 514          } else if ($last == 0 &&
 515          $ts[$last - 0]['token'] == T_VARIABLE ) {
 516  
 517              /* $var */
 518  
 519              $varname = $ts[$last - 0]['value'];
 520  
 521              if (!isset($GLOBALS[ltrim($varname, '$')])) {
 522                  $this->addError(sprintf('Variable \'%s\' is not set', $varname));
 523              }
 524          }
 525  
 526  
 527          $need_more = count($braces);
 528  
 529          if ($need_more || ';' === $token) {
 530              $need_semicolon = 0;
 531          }
 532  
 533          if ($need_return) {
 534              $eval = "return ".$eval;
 535          }
 536  
 537          /* add a traling ; if necessary */
 538          if ($need_semicolon){
 539              $eval .= ';';
 540          }
 541  
 542          if (!$need_more) {
 543              $this->code = $eval;
 544          }
 545  
 546          return $need_more;
 547      }
 548  
 549      function addError($error)
 550      {
 551          $this->errors[$error] = '';
 552      }
 553  
 554      function hasErrors()
 555      {
 556          return !empty($this->errors);
 557      }
 558  
 559      function getErrors()
 560      {
 561          return array_keys($this->errors);
 562      }
 563  
 564  }
 565  
 566  ?>