Zerfetzen von Codezeilen

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Zerfetzen von Codezeilen

    Hallo,

    ich suche nach einer Möglichkeit eine Programmzeile effektiv und sicher zu trennen.

    Problemstellung:
    Jede Programmzeile ist individuell und besteht möglicherweise aus einer Menge faktoren.

    Beispiel(unabhängig vom Sinn)
    $wert .= trim(ltrim(rtrim(stripsplashes(htmlspecialchars("Mein komischer <html> Wert ist ein wenig ausser rand und band")))));

    Demnach gibt es in diesem Beispiel folgendes:

    die Variable $wert
    eine Stringverkettung .=
    Die Funktion trim() mit Inhalt:
    ltrim(rtrim(stripsplashes(htmlspecialchars("Mein komischer <html> Wert ist ein wenig ausser rand und band"))))

    Die Funktion ltrim() mit Inhalt:
    rtrim(stripsplashes(htmlspecialchars("Mein komischer <html> Wert ist ein wenig ausser rand und band")))

    Die Funktion rtrim mit Inhalt:
    stripsplashes(htmlspecialchars("Mein komischer <html> Wert ist ein wenig ausser rand und band"))

    Die Funktion
    htmlspecialchars() mit Inhalt:
    "Mein komischer <html> Wert ist ein wenig ausser rand und band"

    und einem Semikolon ; am ende.


    Habt Ihr eine Idee, wie ich da vorgehen kann?
    Die meiste Unwissenheit könnte besiegt werden. Wir eignen uns nur deshalb keine Kenntnisse an, weil wir sie nicht wünschen.

  • #2
    mit RegEx vielleicht ... ich bin aber super faul in Sachen RegEx ... warte mal bis derHund rein schaut.

    Sonst betrachte den String als 'array of characters' dann kannst du mit den Positionen von ( und ) entsprechend den String auseinander nehmen, ist vielleicht nicht elegant, aber schon simple

    Kommentar


    • #3
      Re: Zerfetzen von Codezeilen

      Habt Ihr eine Idee, wie ich da vorgehen kann?
      da hast du dir ja was vorgenommen, ich hoffe, du bist dir des aufwands bewußt, ich zumindest stelle ihn mir enorm vor ...

      - schau in den source des php-parsers, der muß das ja auch irgendwie machen ....

      wenn du wirklich jede mögliche codezeile aufteilen willst, machst du dich tot ...

      nur mal stur auf dein bespiel bezogen:
      - du holst dir das trim(...) raus mittels regexp (schau mal manual, pattern syntax, recht weit unten, recursive pattern) ... damit kriegste du schonmal den befehl, die matchenden klammern + inhalt, und das sicher (soweit ich das verstanden hab)
      - das ganze machst du rekursiv solange, bis ... du in den klammern keine klammern mehr hast ... denn bei den rec.pattern kannst du (soweit ich das verstanden hab) keine recursionslevel angeben, es match halt recursiv soweit, wie es matched ...
      - den vorderen/hinteren teil mußt du getrennt betrachten, die grenzen ergeben sich aus den oben genannten recursive pattern.

      das war jetzt nur auf dein eines beispiel bezogen, mögliche weitere parameter mal ganz bei seite gelassen. sollte die zeile immer nur diese oder eine recht ähnliche struktur haben, mag es noch gehen.

      aber wie gesagt, für alle möglichen machst du dich tot.

      darum: schau in den quellcode von php, dort muß es zu finden sein.

      wozu das ganze?
      Die Zeit hat ihre Kinder längst gefressen

      Kommentar


      • #4
        wozu das ganze?

        Es soll eine art Scriptoptimierung sein. Die Optimierung von "schlechtem" Code.

        Es gibt Beispielsweise Code, der Syntaktisch zwar "ok" ist, aber zum debuggen ungeeignet, weil beispielsweise ein @ vor einem Befehl steht.

        PHP-Code:
        $link = @mysql_connect($hostname,$username,$password); 
        Empfehlung: Um mögliche Fehler zu vermeiden, lassen Sie das @ Zeichen weg und bauen Sie ein mysql_error ein. (oder sowas)




        Ein anderes Beispiel ist das unnötige Parsen von normalem Text.

        PHP-Code:
        $variable "Das ist mein Text mit der Anzahl von $zeichen Zeichen";
        Diese Zeile macht Sinn.

        $variable "Hier steht nur normaler Text drin";

        wäre es nicht so besser?

        $variable 'Hier steht nur normaler Text drin'
        Ein anderes Beispiel sind gebilde wie:

        PHP-Code:
        if($bla == 1){
          
        //
          
        }
          elseif(
        $bla == 2){
          
        //
          
        }
          elseif(
        $bla == 3){
          
        //
          
        }
          elseif(
        $bla == 4){
          
        //
          

        usw.

        Hier würde ich beispielsweise eine switch anweisung empfehlen wollen.

        Ein anderes Beispiel sind Variablen, die niemals einen Wert enthalten.
        Weiterhin verdopplungen von Variablen, die immer den selben wert enthalten.

        Beispiel:

        PHP-Code:
        function abc(){
        $hostname 'localhost';
        $username 'userabc';
        $password 'password';

        $link mysql_connect($hostname,$username,$password);

        }

        function 
        def(){
        $hostname 'localhost';
        $username 'userabc';
        $password 'password';

        $link mysql_connect($hostname,$username,$password);


        Hier würde es Sinn machen $hostname, $username, $password global zu definieren.


        Es gibt eine menge Beispiele, die ich nennen könnte.
        Es ist quasi ein kleiner minicompiler, der den Inhalt auf verbesserungsmöglichkeiten überprüft.



        Viele Grüsse

        David


        P.S. Habe mir die Source von Php geladen und reingeschaut....
        Fazit: Es ist unmöglich auf die Schnelle eine Lösung zu finden...
        Die meiste Unwissenheit könnte besiegt werden. Wir eignen uns nur deshalb keine Kenntnisse an, weil wir sie nicht wünschen.

        Kommentar


        • #5
          Fazit: Es ist unmöglich auf die Schnelle eine Lösung zu finden...
          ja, du sagst es doch selbst, quasi nen eigenen compiler/interpreter schreiben ...

          btw: die idee einer automatischen code-optimierung finde ich garnicht so schlecht ...
          Die Zeit hat ihre Kinder längst gefressen

          Kommentar


          • #6
            Die Idee ist super und das Vorhaben ist sinnvoll, aber die umsetzung wird sicher schwierig

            mit genug fleiss und einsatz sollte es aber zu schaffen sein

            aber wäre es nicht sinnvoll, das ganze mit einem programm zu machen ? z.B. in c# geschrieben


            An mich bitte keine unaufgeforderten E-Mails senden (ausser ihr seid bereit geld zu zahlen, dann gerne )

            Kommentar


            • #7
              Ich werde es definitiv umsetzen. Ich finde ebenfalls, dass es ein nützliches Werkzeug wäre (wenn es denn so funktioniert).
              Wie lange ich brauche ist was anderes
              Aber um eine mächtige Regex-maschinerie und rekursives Zeilenauseinandernehmen werde ich nicht herumkommen...

              Ich würde mich jedenfalls freuen, wenn jemand mich mit dem einen oder anderen Tip oder einer Idee unterstützen würde. Ich werde euch auf dem laufenden halten.


              Viele Grüsse

              David
              Die meiste Unwissenheit könnte besiegt werden. Wir eignen uns nur deshalb keine Kenntnisse an, weil wir sie nicht wünschen.

              Kommentar


              • #8
                Bin mir nicht ganz sicher, ob ich das Problem/das Vorhaben richtig verstanden habe, aber u. U. kann dir der Tokenizer behilflich sein.
                "Ach was soll's? Dann bau ich mir halt meinen eigenen Vergnügungspark mit Blackjack und Nutten." - Bender

                Kommentar


                • #9
                  So....


                  Und schon sind wir an die grenzen gelangt:

                  Ich bräuchte einen regex, bei dem ich in einer Zeile herausfinden kann,
                  ob eine Funktion oder eine Kontrollstruktur vorhanden ist.

                  Beispiele:

                  $bla = trim(rtrim(" hallo "));

                  oder
                  if($bla = 1){

                  }

                  Ich brauche davon 2 Varianten.
                  Die erste:

                  Falls vorhanden: Gebe mir die Funktion:

                  In dem Fall: trim(rtrim(" hallo "));

                  Die erste Variante habe ich schon:

                  preg_match_all ("/(?<![a-z_0-9$])([a-z_][a-z_0-9]*)\s*\(.*\)/Ui", $str, $out, PREG_PATTERN_ORDER);

                  Klappt wunderbar...


                  Dann gebe mir (gegebenenfalls nur den Inhalt der Funktion)

                  In dem Fall:
                  rtrim(" hallo ")

                  Die brächte ich noch... Ich sehe den Wald nämlich vor lauter Bäumen nicht mehr.




                  Viele Grüsse

                  David
                  Die meiste Unwissenheit könnte besiegt werden. Wir eignen uns nur deshalb keine Kenntnisse an, weil wir sie nicht wünschen.

                  Kommentar


                  • #10
                    Ich revidiere....... Der reguläre Ausdruck funktioniert nicht...

                    PHP-Code:

                    //MEIN AUSDRUCK
                    preg_match_all ("/(?<![a-z_0-9$])([a-z_][a-z_0-9]*)\s*\(.*\)/Ui"$str
                    $outPREG_PATTERN_ORDER); 



                    Das hier:
                    PHP-Code:
                      $query mysql_query("SELECT * FROM banner ORDER BY RAND() LIMIT 1",$link); 
                    wird leider zu:
                    PHP-Code:
                    mysql_query("SELECT * FROM banner ORDER BY RAND() 

                    Dann wird:
                    PHP-Code:
                              while($row mysql_fetch_row($query)){ 

                    leider zu:

                    PHP-Code:
                    while($row mysql_fetch_row($query

                    oder

                    PHP-Code:
                         $count preg_match_all("/\[code\](.*)\[\/code\]/msiU"$text,$show,PREG_SET_ORDER); 
                    wird zu:


                    PHP-Code:
                    preg_match_all("/\[code\](.*) 


                    Das ist natürlich nicht so gedacht gewesen
                    Kann mir jemand damit helfen?
                    Die meiste Unwissenheit könnte besiegt werden. Wir eignen uns nur deshalb keine Kenntnisse an, weil wir sie nicht wünschen.

                    Kommentar


                    • #11
                      Das ist natürlich nicht so gedacht gewesen
                      Kann mir jemand damit helfen?
                      schau dir im manual die recursiven pattern an, die sind afaiui zum finden solcher konstrukte gemacht. damit findest du, wie gesagt, immer die passenden klammern ... aber jeweils nur die äußeren, da die rekursion erst bei nicht mehr finden abbricht ... du must den erhaltenen unreausdruck dann erneut recursive parsen ... bis nix mehr geht.

                      der im manual gegebene regexp paßt schon perfekt auf dein vorhaben, copy&paste reicht dann ...
                      Die Zeit hat ihre Kinder längst gefressen

                      Kommentar


                      • #12
                        schau dir im manual die recursiven pattern an, die sind afaiui zum finden solcher konstrukte gemacht. damit findest du, wie gesagt, immer die passenden klammern ... aber jeweils nur die äußeren, da die rekursion erst bei nicht mehr finden abbricht ... du must den erhaltenen unreausdruck dann erneut recursive parsen ... bis nix mehr geht.

                        der im manual gegebene regexp paßt schon perfekt auf dein vorhaben, copy&paste reicht dann ...
                        Hab es gemacht...

                        Habe die Folgende Zeile (auch wenn übertrieben und Sinnlos und falsch) genommen, um einfach viele Klammern zu simulieren:

                        PHP-Code:
                        $show ltrim(rtrim(trim(stripslashes(settype($value,"integer"))))); 
                        Dazu die auf der Seite:
                        http://de3.php.net/manual/de/referen...ern.syntax.php
                        rekursive Syntax:

                        PHP-Code:
                                    $_cont_preg preg_match('/\((((?>[^()]+)|(?R))*)\)/',$out[0][0],$klammern);
                                    print 
                        "<pre>";
                                    
                        print_r($klammern);
                                    print 
                        "</pre>"
                        Ausgabe:

                        Array
                        (
                        [0] => (rtrim(trim(stripslashes(settype($value,"integer")))))
                        [1] => rtrim(trim(stripslashes(settype($value,"integer"))))
                        [2] => (trim(stripslashes(settype($value,"integer"))))
                        )


                        Dabei steht im manual (falls ich es richtig verstanden habe, dass er duch das (?R) rekursiv ausliesst:

                        This particular example pattern contains nested unlimited repeats, and so the use of a once-only subpattern for matching strings of non-parentheses is important when applying the pattern to strings that do not match.


                        Warum macht er dann nicht weiter?
                        Die meiste Unwissenheit könnte besiegt werden. Wir eignen uns nur deshalb keine Kenntnisse an, weil wir sie nicht wünschen.

                        Kommentar


                        • #13
                          also,
                          Warum macht er dann nicht weiter?
                          ich habe kein problem damit, das jetzt hier zum dritten mal zu erwähnen.

                          das recursive pattern dient einzig und allein dazu, (in deinem fall) die passenden teile zu finden. es erzeugt keinesfalls alle recursiven untergruppen als subpattern, afaik. ich war btw. auch enttäuscht, als ich es (anscheinend) verstanden hatte.
                          du mußt also den gewonnenen unterausdruck erneut parsen, sofern er noch weitere klammerausdrücke enthält. die rekursion läßt sich nicht einschränken, es matched solange es matched.

                          hast du dich hierzu
                          aber u. U. kann dir der Tokenizer behilflich sein.
                          mal schlau gemacht? scheint doch recht brauchbar zu sein?
                          Die Zeit hat ihre Kinder längst gefressen

                          Kommentar


                          • #14
                            nachdem ich geschrieben habe, habe ich dämlicherweise nochmal das manual durchgeschaut. Dämlicherweise hab ich nicht genau genug gelesen.
                            Ich bin dann auch darauf gekommen, dass ich manuelle Rekursion durchführen muss.

                            Und siehe da: Es klappt...

                            Vorgehensweise:

                            PHP-Code:
                                 while (!feof($handle))
                                       {
                                       
                            $buffer fgets($handle4096);
                                       
                            $count preg_match ("/(?<![a-z_0-9$])([a-z_][a-z_0-9]*)\s*\(.*\)/",
                                                            
                            $buffer,
                                                            
                            $out,
                                                            
                            PREG_OFFSET_CAPTURE);

                                       
                            $temp $out[0][0];

                                       for (
                            $i=0$i<$count$i++)
                                           {
                                           if (!
                            eregi('array',$out[1][$i]))
                                              {
                                              
                            $cnt substr_count($out[0][0],"(");
                                              for(
                            $i=0;$i<$cnt;$i++)
                                                 {
                                                 
                            $_cont_preg preg_match_all('/\((((?>[^()]+)|(?R))*)\)/',
                                                                              
                            $out[0][0],$klammer,
                                                                              
                            PREG_PATTERN_ORDER);
                                                 
                            array_push($many_func,$klammer[1][0]);
                                                 
                            $out[0][0] = $klammer[1][0];
                                                 }
                                              
                            $temp_arr = array();
                                              
                            $temp_arr array_reverse($many_func);
                                              
                            array_push($temp_arr,$temp);
                                              
                            $many_func array_reverse($temp_arr);
                                              }
                                           }
                                       }
                                  
                            fclose($handle);
                                }

                            Ausgabe:

                            Array
                            (
                            [0] => ltrim(rtrim(trim(stripslashes(settype($value,"integer")))))
                            [1] => rtrim(trim(stripslashes(settype($value,"integer"))))
                            [2] => trim(stripslashes(settype($value,"integer")))
                            [3] => stripslashes(settype($value,"integer"))
                            [4] => settype($value,"integer")
                            [5] => $value,"integer"
                            )


                            Nun geht's an das Auswerten.
                            Die meiste Unwissenheit könnte besiegt werden. Wir eignen uns nur deshalb keine Kenntnisse an, weil wir sie nicht wünschen.

                            Kommentar


                            • #15
                              Nun geht's an das Auswerten.
                              OffTopic:
                              schön, schön
                              Die Zeit hat ihre Kinder längst gefressen

                              Kommentar

                              Lädt...
                              X