PHP Inspection Unit

[mirage228]

Hallo,

ich habe mich die letzter Zeit ein wenig mit regulären Ausdrücken beschäftigt. Daraus ist die folgende Unit entstanden.

Mit ihr ist es möglich eine PHP Datei zu analysieren. Dabei werden Klassen und Interfaces mit deren Methoden und Variablen aufgelistet, sowie Methoden ohne Klassenbezug und eingebundene Dateien (über include, require, etc.).
Ab Version 1.9 gibt es auch eine vollständige Unterstützung für Konstanten jeglicher Art (define oder PHP5-Klassenkonstanten).

Das ganze wird hierarchisch in einer Klassenstruktur zusammengefasst. Die für Benutzer relevante Klasse sollte die Klasse TPHPSource in der Unit uPHPInspector.pas sein. Ihr wird beim Konstruktor der PHP Quelltext übergeben und daraus werden die Klassen etc. herausgeparsed. Die anderen Klassen in der Unit sollten nicht direkt instanziert werden.
Die Verwendung der Eigenschaften der einzelnen Klassen sollte relativ einfach sein. Bei Rückfragen, bitte hier in den Thread schreiben.

Zum Parsen verwende ich, wie gesagt, reguläre Ausdrücke. Da die native Delphi Bibliothek TRegExpr in einem für mich wichtigem Punkt nicht ganz vollständig war, bin ich auf die Wrapperklasse von http://www.renatomancuso.com umgestiegen. Der einzige Nachteile daraus ist der größere overhead, da Anwendungen die PCRE.dll mitliefern müssen, die mit knapp 200 KB zu Buche schlägt.

Neu ab Version 1.2:
Es lässt sich nun eine Syntaxprüfung durchführen. Dazu muss man die Funktion SyntaxCheck der Klasse TPHPSource aufrufen. Dabei kann man zwischen reiner Syntaxprüfung und einer vollständigen Ausführung der Datei wählen. Bei der Syntaxprüfung werden nur rein syntaktische Fehler erkannt. Nicht vorhandene Include-Dateien oder undefinierte Funktionen werden nicht erkannt. Dazu muss der erste Parameter auf TRUE gesetzt werden.
Im Zweiten Parameter "FileName" kann noch eine Datei zur Syntaxprüfung übergeben werden (Die Datei wird nicht automatisch von TPHPSource geparsed!)
Wichtig beim Testen eurer Sources ist, dass ihr die <? und ?> nicht vergessen dürft, da die Syntaxprüfung ansonsten immer = TRUE ergibt (der Text wird dann einfach ausgegeben ohne geparsed zu werden). Zudem wird euer Source dann nicht vom PHP Inspector geparsed, wenn die PHP-Tags (<? .. ?>) fehlen (ab Version 1.6).
Das Verhalten kann durch die StrictPHPTagCheck Eigenschaft beeinflusst werden.

Im Anhang befinden sich nun:

• PHPInspector.zip Der "PHP Inspector" in der Version 2.6 (PCRE.dll und Wrapper Units included; Version 5.0 vom 26. Oktober 2004)
• sample_application.zip Eine Beispielanwendung, samt Source.
• php_source_analyzer.jpg Ein Screenshot der Beispielanwendung.

Freue mich auf euer Feedback

mfG
mirage228

[mirage228]

Zitat von Pr0g:

DSeven scheint ja auch Interesse an dem Projekt zu haben, vielleicht sagt er dazu noch was. Wenns zu sehr auf die Zeit geht, dann lass es erstmal so.

Ja, ok, dann lasse ich es erstmal so, wie es ist.

Ahja, habe gerade den Thread Deines Programmes gelesen und da bin ich auf Folgendes gestoßen:

Zitat von mh166:

also ich hab mal nochn Bug gefunden: Ich hab folgenden Code:

Code:

$test := '?>';

Ab dem schließenden ">" interpretiert er den Rest nicht mehr als PHP.

Den Fehler gibt es derzeit auch bei mir musste ich feststellen
Werde den auch noch beheben.

mfG
mirage228

[mh166]

Zitat von mirage228:

Ahja, habe gerade den Thread Deines Programmes gelesen und da bin ich auf Folgendes gestoßen:

Zitat von mh166:

also ich hab mal nochn Bug gefunden: Ich hab folgenden Code:

Code:

$test := '?>';

Ab dem schließenden ">" interpretiert er den Rest nicht mehr als PHP.

Is doch schön zu wissen, dass man helfen kann! Was man nich alles machen kann, mit nur einem Beta-Test!

mfg, mh166

[mirage228]

Zitat von mh166:

Is doch schön zu wissen, dass man helfen kann!

Also mit der neuen Version bin ich weitesgehend fertig, morgen früh lade ich es dann hoch - falls ihr nichts zu beanstanden habt

mfG
mirage228

[mirage228]

Hi,

Jetzt gibt es wieder was Spannendes, mit Spiel und Schokolade - Es ist die Version 1.9

Folgende Fehler habe ich berichtigt:

• Fehler in der Berechnung der Eigenschaften BeginBracket und EndBracket in der Klasse TPHPClassMethod behoben.
• Fehler behoben, dass Konstanten in Klassen nur erkannt wurden, falls sie einfache Hochkommata eingebettet waren.
• Bei einem Include werden eventuelle Leerzeichen bis zum Semikolon nicht mehr in die IncludeFileName Eigenschaft übernommen.
• Fehler bei der Erkennung von PHP-Tags behoben, falls ein Tag in einen Kommentar oder String eingebettet war.
• Fehler behoben, der verursachte, dass bei deaktivierter StrictPHPTagCheck Eigenschaft Source ohne ?> trotzdem nicht erkannt wurde.

Die Downloads befinden sich, wie immer, im ersten Beitrag

mfG
mirage228

[DSeven]

Guten Tag,

Also die version gefällt mir jetzt
Werde es noch weiter Testen mal schauen.

mfg,
DSeven

[DSeven]

Guten Tag,

So habe einen Fehler gefunden.
Undzwar funktioniert FindEntityAt immernoch nicht richtig. Ich bekomme im folgenden Code bei der aller letzten Funktion, die Funktion test ein nil zurück.

Code:

<?php
include('FJ');
class sql
{
   // Variablen werden Deklariert
   var $server;
   var $user;
   var $pw;
   var $db;
   var $query;
   var $result;
   var $zaehler;

   // Funktion um eine Verbindung mit MySQL zu erstellen
   // und eine Datenbank auszuwählen
   function sql ($sql_server, $sql_user, $sql_pw, $sql_db)
   {
      // Variablen werden gesetzt
      // um sie in der class zu benutzen
      $this ->server = $sql_server;
      $this ->user = $sql_user;
      $this ->pw = $sql_pw;
      $this ->db = $sql_db;

      // Verbindung wird gesetzt Handle an Variable übergeben
      $connect = @mysql_connect($this ->server, $this ->user, $this ->pw);

      // Verbindung wird überprüft
      if (!($connect))
      {
         // Falls keine Verbindung hergestellt werden konnte
         // wird ein Hinweis angezeigt
         echo "Keine News";
         // exit;
      }
      else
      {
         // Falls Verbindung erfolgreich
         // wird die Datenbank ausgewählt
         @mysql_select_db($this ->db);
         return true;
      }
   }

   // Funktion zum verarbeiten von querys
   function myquery($query)
   {
      $this ->query = mysql_query($query);
      If ($this ->query)
         return True;
      else
         return False;
   }

   // Funktion zur leichteren Handhabung von
   // mysql_fetch Array
   function fetchArray($query)
   {
      $this ->query = mysql_query($query);
      $this ->result = mysql_fetch_array($this ->query);
      return $this ->result;
   }

   // Funktion zum auslesen des ganzen
   // Inhaltes
   protected function fetchMultiple($query)
   {
      $this ->query = @mysql_query($query);
      $this ->zaehler = 0;
      while ($this ->result = mysql_fetch_array($this ->query))
      {
         $this->result_multiple[$this->zaehler] = array($this->result);
         $this->zaehler++;
      }
      return $this->result_multiple;
   }


   // MySQL Verbindung wird geschlossen
   private function close()
   {
      if (@mysql_close())
         return True;
      else
         return False;
   }
}

?>
<?php
class BaseClass {
   function __construct() {
      print "In BaseClass constructor\n";
   }
}

class SubClass extends BaseClass {
   function __construct() {
      parent::__construct();
      print "In SubClass constructor\n";
   }
}

$obj = new BaseClass();
$obj = new SubClass();
?>
<?php

class MyClass {
   public $public = "MyClass::public!\n";
   protected $protected  = "MyClass::Protected!\n";
   protected $protected2 = "MyClass::Protected2!\n";
   private   $private   = "MyClass::private!\n";

   function printHello() {
      print "MyClass::printHello() " . $this->private;
      print "MyClass::printHello() " . $this->protected;
      print "MyClass::printHello() " . $this->protected2;
   }
}

class MyClass2 extends MyClass {
   protected $protected = "MyClass2::protected!\n";

   function printHello() {

      MyClass::printHello();

      print "MyClass2::printHello() " . $this->public;
      print "MyClass2::printHello() " . $this->protected;
      print "MyClass2::printHello() " . $this->protected2;

      /* Will result in a Fatal Error: */
      //print "MyClass2::printHello() " . $this->private; /* Fatal Error */

   }
}

$obj = new MyClass();

print "Main:: " . $obj->public;
//print $obj->private; /* Fatal Error */
//print $obj->protected;  /* Fatal Error */
//print $obj->protected2;  /* Fatal Error */

$obj->printHello(); /* Should print */

$obj2 = new MyClass2();
print "Main:: " . $obj2->private; /* Undefined */

//print $obj2->protected;   /* Fatal Error */
//print $obj2->protected2;  /* Fatal Error */

$obj2->printHello();
?>
<?php

abstract class AbstractClass {

   /* Force Extending class to define this method */
   abstract protected function getValue();

   /* Common method */
   public function print2() {
   print $this->getValue();
   }
}

class ConcreteClass1 extends AbstractClass {
   protected function getValue() {
      return "ConcreteClass1";
   }
}

class ConcreteClass2 extends AbstractClass {
   protected function getValue() {
      return "ConcreteClass2";
   }
}

$class1 = new ConcreteClass1;
$class1->print2();

$class2 = new ConcreteClass2;
$class2->print2();
?>
<?php
interface ITemplate
{
   public function setVariable($name, $var);
   public function getHtml($template);
}


class Template implements ITemplate
{
   private $vars = array();

   public function setVariable($name, $var)
   {
      $this->vars[$name] = $var;
   }

   public function getHtml($template)
   {
      foreach($this->vars as $name => $value) {
         $template = str_replace('{'.$name.'}', $value, $template);
      }
      return $template;
   }
}
?>
<?php
class Setter {
   public $n;
   private $x = array("a" => 1, "b" => 2, "c" => 3);

   function __get($nm) {
      print "Getting [$nm]\n";

      if (isset($this->x[$nm])) {
         $r = $this->x[$nm];
         print "Returning: $r\n";
         return $r;
      } 
      else {
         print "Nothing!\n";
      }
   }

   function __set($nm, $val) {
      print "Setting [$nm] to $val\n";

      if (isset($this->x[$nm])) {
         $this->x[$nm] = $val;
         print "OK!\n";
      } 
      else {
         print "Not OK!\n";
      }
   }
}

$foo = new Setter();
$foo->n = 1;
$foo->a = 100;
$foo->a++;
$foo->z++;
var_dump($foo);

$sql = new sql('hallo1', 'hallo2', 'hallo3');
echo('Fjhgjghhjfghjfg');

function test($ein_test)
{

}
?>

Ahja und hier der link zu den globalen Konstanten:
http://www.php.net/manual/function.define.php

PHPEdit erkennt auf diese weise definierte Konstanten.


mfg,
DSeven

[mirage228]

Hi,

habe den Fehler gefunden.
Es ist der selbe Fehler, den ich schon bei TPHPClassMethod behoben hatte - aber bei TPHPMethod hab ichs vergessen

Das mit den defines habe ich auch noch mit mit hineingebracht
Zudem habe ich eine kleinen Fehler bei den Includes behoben (habe das [^$] durch eine Assertion ersetzt (?<!\$) - Damit liefs bei mir auch etwas schneller )

Der Download der verbesserten Version ist im ersten Beitrag zu finden 8)

mfG
mirage228

[Pr0g]

Warum ist bei Konstanten kein "TextPos" verfügbar, fände gut, wenn das mit angegeben wird

[mirage228]

Zitat von Pr0g:

Warum ist bei Konstanten kein "TextPos" verfügbar, fände gut, wenn das mit angegeben wird

Ähm, ich weiss ja nicht was für eine Version Du hast, aber alle von TPHPEntity abgeleiteten Klassen haben eine automatisch geerbte TextPos property im Public-Abschnitt - dazu gehört auch TPHPConstant

mfG
mirage228

[Pr0g]

Hm, stimmt. Delphi hatte es nicht in der Liste aufgeführt (die spinnt manchmal), daher dachte ich es geht net. Aber was anderes. Aus irgend einem Grund ist "ConstantCount" immer 0. Woran kann das liegen?