Funktionen aus Modul parsen (gelöst) (Allgemeines zu Perl)

[thread]17209[/thread]

Funktionen aus Modul parsen [gelöst]

Tags: perl5 Ähnliche Threads

Leser: 17

Articles: hide open all | hide show old branches

+7 replies
rosti

2012-03-01 18:46

User since
2011-03-19
3492 Artikel
BenutzerIn

Hi,

geparst werden soll das, was zwischen den {} steht als String, dazu der Name der sub und idealerweise kriege ich mit dem Parser einen Hash mit allen Methoden einer Moduldatei dem Funktionsnamen als Key zugeordnet. Gibt es da was???

Wäre schön ;)

Viele Grüße,
Rosti
- +6 replies
- GwenDragon
  
  2012-03-01 19:14
  
  User since
  2005-01-17
  14759 Artikel
  Admin1
  
  Mal PPI ansehen ;)
  
  Oder willst du nur Text parsen? Dann würde das zwischen {} mit Text::Balanced gut rausgezogen werden.
  Last edited: 2012-03-01 19:16:15 +0100 (CET)
  die Drachin Gwen
  
  Meine Perl-Artikel · perldev – verschiedene Perl-Versionen unter Windows starten
  - +5 replies
  - rosti
    
    2012-03-01 19:35
    
    User since
    2011-03-19
    3492 Artikel
    BenutzerIn
    
    Danke Dir, das Letztere kommt in die nährere Auswahl, kling schonmal gut...
    
    Viele Grüße,
    Rosti
    
    PS/Edit, zum Hintergrund: Nach dem Prizip AutoLoad, AutoSplit, SelfLoad möchte ich einige Methoden auslagern, jedoch nicht in einzelne Dateien, nicht unter __DATA__ und nicht unter __END__ sondern in eine Binärdatei. Diese Binary wird mit einem meiner eigens entwickelten Module auf einen Hash gelesen, jeder Eintrag hat also einen Namen (der Name der Methode) und das was bei einer sub[} zwischen den {} steht als String.
    
    Es handelt sich um Methoden, die für normale Seitenaufrufe nicht gebraucht werden sondern erst, wenn das Management von Inhalten über den Browser erfolgt. Die Response-Klasse meines kleinen aber feinen Frameworks hat sehr viele Methoden für eine Instanz, mit UNIVERSAL::can wird von der jeweils namentlich angeforderten Methode der Code auf eine anonyme Refererenz gelegt und beim Ausführen auf Exception getestet...
    
    So läuft das bisher, wobei wie gewöhnlich infolge use der Code einer _jeden_ Methode in den Hauptspeicher geladen wird, auch für Methoden, die gar nicht sooft gebraucht werden. Einer der üblichen Gründe für AutoLoad/SelfLoad: Methods on demand, ich werde das nur ein bischen kompakter machen mit den Demand-Methods in einem Hash, welcher aus einer Binary erzeugt wird (eigener Algorithmus serialize/deserialize).
    
    Zu UNIVERSAL::can, Suche nach Code in der Response-Klasse kommt demnächst ein elsif(exists $methodHash($name}){} hinzu, was nur einen kleinen Eingriff in die bisherige Kontrollstruktur erfordert.
    
    Die Hauptaufgabe besteht jetzt darin, die dafür bestimmten Methoden aus dem Modul meiner Response-Klasse rauszunehmen und in den Hash zu schreiben.
    
    Wahrscheinlich wirds mehr Handarbeit, egal, was dabei rauskommen soll funktioniert wie geschmiert ;)
    Last edited: 2012-03-01 20:10:07 +0100 (CET)
    - +4 replies
    - rosti
      
      2012-03-02 14:27
      
      User since
      2011-03-19
      3492 Artikel
      BenutzerIn
      
      Quote
      u UNIVERSAL::can, Suche nach Code in der Response-Klasse kommt demnächst ein elsif(exists $methodHash($name}){} hinzu,
      
      Das kann entfallen, wenn die Subs im Hash als Stub deklariert werden. Es wird AutoLoad eingebunden und eine eigene Methode AUTOLOAD geschrieben. Damit erkennt UNIVERSAL::can auch diese Methoden, die nur bei Bedarf compiliert werden. Für Interessenten ein bischen Code:
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
      
      #!/usr/bin/perl package main; use strict; use warnings; use AutoLoader; use Data::Dumper; # Deklariere die Methoden # damit diese von AUTOLOAD gefunden werden sub foo; sub bar; # diese methoden liegen als source in einem hash # solch hash könnte z.B. mit DB_File als Datei angebunden sein my %mh = ( foo => q( my $self = shift; $self->{FOO} = 1; print "foo! @_\n"; ), bar => q( my $self = shift; $self->{BAR} = 1; print "bar!\n"; ), ); my $mo = main->new; # Instanz der main class # jetzt gucken wir mal, ob UNIVERSAL::can die Methode findet my $code = $mo->can('foo') or die "no method found"; $mo->$code(arg => 123); print Dumper $mo; # weitere Kontrolle, ob Attribut hinzugekommen ist # methods in class sub new{ my $class = shift; my $self = bless{}, $class; return $self; } # overload AUTOLOAD sub AUTOLOAD{ my $self = shift; my $sub = our $AUTOLOAD; $sub =~ s/.*:://; # extrahiere Klassen Name if(exists $mh{$sub}){ # aus der Source den Code erzeugen und ausführen my $code = eval "sub{$mh{$sub}}"; $self->$code(@_); } else{ return undef; } }
      
      Im Prinzip ist das eine Alternative zum Verzeichnis lib/auto/
      Also keine *.al-Dateien mit einzelnen Methoden, sondern diese Methoden in einem Hash. Schön kompakt ;)
      
      Viele Grüße,
      Rosti
      - +3 replies
      - Gast wer
        
        2012-03-02 17:32
        
        schneller verhindert doppeltes compilieren:
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7
        
        if(exists $mh{$sub}){ # aus der Source den Code erzeugen und ausführen if(ref($mh{$sub} ne 'CODE')){ $mh{$sub}=eval "sub{$mh{$sub}}"; } return $mh{$sub}->(@_); }
        
        Last edited: 2012-03-02 17:39:58 +0100 (CET)
        
        rosti
        
        2012-03-02 18:23
        
        User since
        2011-03-19
        3492 Artikel
        BenutzerIn
        
        Vielen Dank!!! Jow, so würde das ohne AutoLoader aussehen. Ist das so, dass mit dem AutoLoader zweimal kompiliert wird???
        
        Mir gehts seit heute morgen darum, meine bisherige Kontrollstruktur beizubehalten, deswegen die Idee mit dem AutoLoader. In der bisherigen Kontrollstruktur wird ohnehin der Code einer jeden Methode per UNIVERSAL::can auf eine anonyme Referenz gelegt und beim Ausführen auf Exceptions getestet (was Einiges vereinfacht). Nochmal das Wesentliche:
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
        
        my $mo = main->new; my $code = $mo->can('foo') or die "Die Methode wurde nicht gefunden"; $mo->$code(); # execute print Dumper $mo; # INCR => 1 sub new{ return bless{INCR => 0}, shift } sub AUTOLOAD{ my $self = shift; my $subname = our $AUTOLOAD; $subname =~ s/.*:://; # extrahiere Klassen Name if(exists $mh{$subname}){ # compiliert wird hier my $code = eval "sub{$mh{$subname}}"; return $self->$code(@_); } }
        
        Die Stelle, wo compiliert wird, habe ich mal eingezeichnet ;)
        Last edited: 2012-03-02 23:08:28 +0100 (CET)
        
        rosti
        
        2012-03-05 08:43
        
        User since
        2011-03-19
        3492 Artikel
        BenutzerIn
        
        Quote
        schneller verhindert doppeltes compilieren:
        
        Habs mir noch einmal genauer angeschaut, AUTOLOAD ruft DESTROY, hier also aufpassen, dass nicht zweimal compiliert wird.
        
        Frage beantwortet ;)

View all threads created 2012-03-01 18:46.