Beat: Ich schwimme: variables Package

Ich kann zur runzeit erst ein pm laden, also mit require.
Der name des files wird vom User gegeben. (filepfad ist limitiert, kein problem)

Hacke mich derzeit erfolglos durch compile time Errormessages durch.

  
sub __load_perl_module{  
   # $_[0] sollte "html.pm" enthalten  
   $_[0] =~ /^([a-z]+)\.pm$/  
       or return 'ERROR Bad Module Name' . $_[0];  
  
   require $_[0];  
  
   $_[0] =~ s/^([a-z]+)\.pm/$1/; # sollte nun "html" enthalten.  
  
   # hier will ich an eine Variable %html::export gelangen  
   foreach( keys ( "%" . $_[0] ."::export" ) ){  
       next if /^__/;  
       exists $c_self->{function}{$_}  
          or $c_self->{function}{$_} = $$_[0]->{function}{$_};  
   }  
}  

Wie muss ich die Variable zusammensetzen, damit sie als solche erkannt wird?

mfg Beat

--
Woran ich arbeite:
X-Torah
><o(((°>           ><o(((°>
   <°)))o><                     ><o(((°>o
  1. # hier will ich an eine Variable %html::export gelangen
       foreach( keys ( "%" . $_[0] ."::export" ) ){

    so sollte es gehen

    foreach( keys %{$_[0] . '::export'} ){

    Struppi.

    1. # hier will ich an eine Variable %html::export gelangen
         foreach( keys ( "%" . $_[0] ."::export" ) ){

      so sollte es gehen

      foreach( keys %{$_[0] . '::export'} ){

      leider nein
      [Sun Jan  4 13:06:46 2009] Parser.pm: Warning: Use of "keys" without parentheses is ambiguous at C:...../Parser.pm line 421.
      [Sun Jan  4 13:06:46 2009] Parser.pm: Scalar found where operator expected at C:....../Parser.pm line 421, near "%( $mod"
      [Sun Jan  4 13:06:46 2009] Parser.pm:  (Missing operator before  $mod?)

      Und mit Klammer
      foreach( keys( %{$_[0] . '::export'} ) ){

      [Sun Jan  4 13:08:45 2009] Parser.pm: Scalar found where operator expected at C:.../Parser.pm line 421, near "%( $mod"
      [Sun Jan  4 13:08:45 2009] Parser.pm:  (Missing operator before  $mod?)

      Werde da mal den Fehler isolieren und mich deinem indizierten "can" widmen.

      mfg Beat

      --
      ><o(((°>           ><o(((°>
         <°)))o><                     ><o(((°>o
      1. # hier will ich an eine Variable %html::export gelangen
           foreach( keys ( "%" . $_[0] ."::export" ) ){

        so sollte es gehen

        foreach( keys %{$_[0] . '::export'} ){

        leider nein

        Dann ist was anders falsch:

        #! /usr/bin/perl -w  
        use strict;  
          
        package html;  
          
        %html::export = (a => 1 , b => 2);  
          
        package main;  
          
        my $n = 'html';  
        no strict 'refs';  
          
        foreach( keys %{$n . '::export'} ){  
        print "$_\n";  
        }
        

        Struppi.

        1. leider nein

          Dann ist was anders falsch:

          #! /usr/bin/perl -w

          use strict;

          package html;

          %html::export = (a => 1 , b => 2);

          package main;

          my $n = 'html';
          no strict 'refs';

          foreach( keys %{$n . '::export'} ){
          print "$_\n";
          }

          
          >   
          > Struppi.  
            
          Entwarnung.  
          Ich bin nun Fehlerfrei über die Kompilationsphase  
            
          Sorry habe ${$\_[0]} gegen my $mod=shift ausgetauscht.  
            
          ~~~perl
            
          sub __load_perl_module{  
             my $mod = "html.pm";  
             $mod =~ /^([a-z]+)\.pm$/ or return 'ERROR Bad Module Name' . $mod;  
             require $mod;  
             $mod =~ s/^([a-z]+)\.pm/$1/;  
             foreach( keys ( %$mod::export  )  ){  
                next if /^__/;  
                print $_, "\n";  
          #     exists $c_self->{function}{$_} or $c_self->{function}{$_} = $$mod->{function}{$_};  
             }  
          }  
          
          

          Ich muss jetzt zuerst den Testcase bauen, im dann auch das runtime Verhalten zu sehen.

          Danke

          mfg Beat

          --
          Woran ich arbeite:
          X-Torah
          ><o(((°>           ><o(((°>
             <°)))o><                     ><o(((°>o
          1. foreach( keys ( %$mod::export  )  ){

            Das funktioniert nicht. Ich hatte dir doch gezeigt wie es geht.

            Struppi.

            1. foreach( keys ( %$mod::export  )  ){
              Das funktioniert nicht. Ich hatte dir doch gezeigt wie es geht.

              Habs eingesehen.
              Habe deinen Vorschlag übernommen.

              Allerdings.
              Verwende ich no strict refs compiliert PC::Parser nicht
              Verwende ich kein no strict refs

              dann habe ich jetzt:
              Can't use string ("html::export") as a HASH ref while "strict refs" in use at C:.../PC/Parser.pm line 423, <> line 1.

              für

                
              foreach( keys ( %{$mod . '::export' }  )  )  
              
              

              Jetzt habe ich das gemacht:

                
              my %hash = eval{ '%' .$mod . '::export'};  
              foreach( keys ( %hash  )  ){...}  
              
              

              Die Folge ist die Kopie des Hashes, was mir auch recht ist.
              Mache mal weiter und arbeite die Tests durch.

              mfg Beat;

              --
              Woran ich arbeite:
              X-Torah
              ><o(((°>           ><o(((°>
                 <°)))o><                     ><o(((°>o
              1. Allerdings.
                Verwende ich no strict refs compiliert PC::Parser nicht

                Wieso nicht? Du musst das doch nur dort machen wo du den HASH erzeugen willst.

                Struppi.

                1. Allerdings.
                  Verwende ich no strict refs compiliert PC::Parser nicht

                  Wieso nicht? Du musst das doch nur dort machen wo du den HASH erzeugen willst.

                  kann ich dir echt nicht sagen...
                  Habe mein Konzept geändert bis Lektüre und Können zusammenfallen.
                  Ist schliesslich mein erstes wirkliches Modul.

                  Aber hier mal, was ich hab:

                  Dies steht im Modul PC::Parser

                    
                  sub __load_perl_module{  
                    my $mod = shift;  
                    our %ex;  
                    require $mod. ".pm";  
                    foreach( keys %ex ){  
                      print $_, ':' , $ex{$_}, "\n";  
                    }  
                  }  
                  
                  

                  Dies steht im einzubindenden .pm

                    
                  use strict;  
                  use warnings;  
                  our %ex = (a=>1);  
                  
                  

                  Ich muss noch überlegen ob das eine gute Lösung ist.
                  Letztlich will ich ja den Inhalt von %ex in Object Hashes kopieren.
                  Ich muss nicht mit den eingebundenen Funktionen in ihren ursprünglichen Files/packages arbeiten.

                  mfg Beat;

                  --
                  Woran ich arbeite:
                  X-Torah
                  ><o(((°>           ><o(((°>
                     <°)))o><                     ><o(((°>o
                  1. Allerdings.
                    Verwende ich no strict refs compiliert PC::Parser nicht

                    Wieso nicht? Du musst das doch nur dort machen wo du den HASH erzeugen willst.

                    kann ich dir echt nicht sagen...

                    Ich benutze solche Konstrukte öfters und die Skripte erzeugen keine Warnungen oder Fehler.

                    Habe mein Konzept geändert bis Lektüre und Können zusammenfallen.
                    Ist schliesslich mein erstes wirkliches Modul.

                    Mir scheint dein Konzept nicht optimal zu sein. our verwende ich selten, aber mir ist nicht so ganz klar was du vor hast.

                    Ich muss noch überlegen ob das eine gute Lösung ist.
                    Letztlich will ich ja den Inhalt von %ex in Object Hashes kopieren.
                    Ich muss nicht mit den eingebundenen Funktionen in ihren ursprünglichen Files/packages arbeiten.

                    Das muss ja kein Nachteil sein, ich finde z.b. ganz praktisch das bei use automatisch die import Funktion aufgerufen wird.

                    Struppi.

                    1. kann ich dir echt nicht sagen...

                      Ich benutze solche Konstrukte öfters und die Skripte erzeugen keine Warnungen oder Fehler.

                      Möglicherweise geschah jener 'unknown error' weil die require Routine gleich zweimal ausgeführt wurde.

                      Habe mein Konzept geändert bis Lektüre und Können zusammenfallen.
                      Ist schliesslich mein erstes wirkliches Modul.

                      Mir scheint dein Konzept nicht optimal zu sein. our verwende ich selten, aber mir ist nicht so ganz klar was du vor hast.

                      Mal sehen, ob sich das bewährt. Die Bausteine zum hauptmodul sind ja keine vollen Module sondern nur Sammlungen von Datenhashes die auch anonyme subs enthalten.

                      Ich muss noch überlegen ob das eine gute Lösung ist.
                      Letztlich will ich ja den Inhalt von %ex in Object Hashes kopieren.
                      Ich muss nicht mit den eingebundenen Funktionen in ihren ursprünglichen Files/packages arbeiten.

                      Das muss ja kein Nachteil sein, ich finde z.b. ganz praktisch das bei use automatisch die import Funktion aufgerufen wird.

                      Also ich erzähl mal.

                      Ich habe einen Parser im Sinn der Sprache nach der Syntax [p:c] verarbeitet.
                      Der kern des ganzen (für Perl) ist ein parser mit ein paar notwendigen grundfunktionen.
                      Während der Parser nur die Objectmethoden $obj->new()$obj->parse() und $obj->(init) zulässt (Der Initalisierungscode ist selbst in [p:c]), sollen Mdoule mit weiteren [p:c] Funktionen geladen werden können.
                      Hier soll es zwei Arten von [p:c] Mdule geben. Reine Textdateien die [p:c] Code enthalten und eben Perlmodule.

                      Nun möchte ich also, dass man Perlmodule schreiben kann und diese dann via obj->init() durch eine [p:c] Syntax einbinden kann. Das heisst, ich kann diese Module erst während der Laufzeit einbinden.

                      Nun möchte ich die API für diese Module möglichst einfach halten.
                      In dieser API gibt es eine Methode $PC->() um an verschiedene Daten zu gelangen, die vom Kern bereitgestellt werden.

                      Nur das problem: $PC existiert im Coremodul. Es nützt mir nichts, ein solches zu deklarieren in den Modulen.

                      Hier ein beispiel einer Funktion, wie sie in einem Modul geschrieben sein könnte.

                        
                      our %ex = (  
                        
                          #   Hier wird eine Funktione für [title:] deklariert  
                          #   Es gibt die funktion und defaultwerte.  
                        
                         title => {  
                            function => sub {  
                                ${$_[0]} = '<h2';  
                                $PC->('children', 'class') and ${$_[0]} .= ' class="' . $PC->('children', 'class') . '"';  
                                ${$_[0]} .= '>'. parser( $PC->('children', 'c') ) .'</h2>';  
                            },  
                        
                            default => { element => 'h2', class => 'title', },  
                        
                         },  
                        
                      );  
                      
                      

                      Die obige Funktion läuft, wenn ich sie in analoger Stelle im Hauptmodul schreibe den anderen Corefunktionen notiere.
                      Sie bastelt
                      aus [title:Beispiel] ein <h2>Beispiel</h2>
                      aus [title+[class=spezial][c:Beispiel]] ein <h2 class="spezial">Beispiel</h2>
                      wobei der content "Beispiel" nochmals durch den Parser gejagd wird.

                      Das ist mein Vorhaben.
                      Mit dem Hauptmodul komme ich gut zurecht, aber mit dem Erweiterungen, das sehe ich, kann das so nicht gehen.

                      Update
                      ______________
                      Jetzt red ich so daher, korrigiere einen Fehler, und es funzt ganz funzig....
                      Sowas aber auch.

                      Jetzt muss ich testen.....
                      Morgen gibts Bericht und eventuell auch eine Gesamtdarstellung zum Modulstand.

                      Ich brauche nämlich Kritik über das ganze Konzept.
                      Aber wehe... da ist viel Lektüre für die Kritiker.

                      mfg Beat

                      --
                      ><o(((°>           ><o(((°>
                         <°)))o><                     ><o(((°>o
                      1. our %ex = (

                        #   Hier wird eine Funktione für [title:] deklariert
                            #   Es gibt die funktion und defaultwerte.

                        title => {
                              function => sub {
                                  ${$[0]} = '<h2';
                                  $PC->('children', 'class') and ${$
                        [0]} .= ' class="' . $PC->('children', 'class') . '"';
                                  ${$_[0]} .= '>'. parser( $PC->('children', 'c') ) .'</h2>';
                              },

                        default => { element => 'h2', class => 'title', },

                        },

                        );

                        
                        >   
                        
                        ......  
                        
                        > Update  
                        > \_\_\_\_\_\_\_\_\_\_\_\_\_\_  
                        > Jetzt red ich so daher, korrigiere einen Fehler, und es funzt ganz funzig....  
                          
                        nope....  
                        Man soll in Ruhe testen.  
                          
                        Ich muss den perlcode als reinen Text importieren und im Context des Hauptscripts eval{}uieren.  
                        Kann nicht anders gehen, ausser ich will 1000 mal self->(irgendwas) schreiben.  
                          
                        mfg Beat  
                           <°)))o><                     ><o(((°>o  
                        
                        
                        1. Dies im zu improtierenden Modulmodul

                            
                            
                          our $PC;  
                          # auch wenn ich dann auf die Variable im Hauptmodulzugreife, ich brauche sie hier wegen der Compilierphase und runtime bei require.  
                            
                          our %ex = (  
                            
                               #   Hier wird eine Funktione für [title:] deklariert  
                               #   Es gibt die funktion und defaultwerte.  
                          
                          

                          Im Hauptscript brauche ich auch!!!

                          our $PC = sub{...};

                          Das ist der springende Punkt und meine heutige Erkenntnis.

                          Wenn ich in ein Modul oder Programm Data aus einem anderen Modul importieren will, dann müssen in importierten Modul Varailen als stubs mit our deklariert werden.
                          Aber auch im einbindenden Modul muss jetzt jede Variable, auf die eine importierte sub zugreift, mit our deklariert werden.

                          Uff...

                          Nicht das ich das in der Doku gefunden hätte, aber ich war im Abschnitt perlsub wo nochmals über den Zusammenhang von my und our, bzw ihren Unterschied, gesprochen wird.

                          my gehört zu keinem package. my hat nichts mit packages zu tun, sondern mit Blockscope.
                          our gehört zum package, in dem es deklariert wird. Es lässt sich immer adressieren über den package Namen. our ist frei von Blockscope.

                          na dann machen wir mal weiter...

                          mfg Beat

                          --
                          Woran ich arbeite:
                          X-Torah
                          ><o(((°>           ><o(((°>
                             <°)))o><                     ><o(((°>o
                          1. Ich bin nicht sicher, ob ich alles verstanden habe. Aber ich finde nach wie vor, dass dein Weg sehr umständlich klingt oder zumindest verwirrend ist.

                            Wenn ich Variabeln exportieren möchte, benutze ich Exporter.

                            Das ist der springende Punkt und meine heutige Erkenntnis.

                            Wenn ich in ein Modul oder Programm Data aus einem anderen Modul importieren will, dann müssen in importierten Modul Varailen als stubs mit our deklariert werden.
                            Aber auch im einbindenden Modul muss jetzt jede Variable, auf die eine importierte sub zugreift, mit our deklariert werden.

                            Uff...

                            Wie schonmal gesagt, ich persönlich benutze so gut wie nie our. Das ist aus Sicht von OOP auch keine saubere Lösung, ein Variabel oder Objektattribut öffentlich zu machen, daher vermeide ich dies wo immer ich kann. Ausser z.b. bei Konstanten.

                            my gehört zu keinem package. my hat nichts mit packages zu tun, sondern mit Blockscope.
                            our gehört zum package, in dem es deklariert wird. Es lässt sich immer adressieren über den package Namen. our ist frei von Blockscope.

                            Was das angeht hat Siechfred einen passenden Artikel  übersetzt.

                            na dann machen wir mal weiter...

                            Wenn ich dich jetzt richtig verstanden habe, hast du ein Hauptmodul, dass Perl Module nachlädt, die Text verarbeiten/parsen sollen. Dieser enthält Funktionen und Attribute, ist also am Schluss ein Objekt.

                            Wenn die Module Zugriff auf die Instanz des Hauptmoduls haben sollen, solltest du diese z.b. dem Konstruktor übergeben oder an der Stelle wo der Text geparst wird.

                            Und um ein bisschen konkret zu werden.

                            Ich hab an deinem Konzept nicht verstanden, was mit den geparsten Modulen passieren soll.
                            Du hast einmal die Texte und Module mit einem Hash %ex, aber was soll dann mit $PC passieren? Soll $PC erweitert werden? Mit einem Namensraum oder mit Funktionen?
                            Und wenn mit Funktionen, heißt das, das immer nur ein Modul geparst werden kann? Oder mehrere die sich eventuell gegenseitig überschreiben?

                            Und, bist du sicher, das dein Ansatz ein Vorteil gegenüber einem gängigen Templatesystem ist?

                            Struppi.

                            1. na dann machen wir mal weiter...
                              Wenn ich dich jetzt richtig verstanden habe, hast du ein Hauptmodul, dass Perl Module nachlädt, die Text verarbeiten/parsen sollen. Dieser enthält Funktionen und Attribute, ist also am Schluss ein Objekt.

                              Fast. Der letzte teil ist nicht korrekt.
                              Die importierten Funktionen sind keine Objekte.

                              Objekte sind Instanzen von verschiendenen im hauptscript erzeugten Objekte.
                              Jede Instanz hat seine eigene Initialisierung, seinen eigenen Datenzustand, und seine eigene importierte PC-Funktionen.

                              Allerdings denke ich, dass die Arbeit mit mehreren Objekten eher die Ausnahme ist.

                              Wenn die Module Zugriff auf die Instanz des Hauptmoduls haben sollen, solltest du diese z.b. dem Konstruktor übergeben oder an der Stelle wo der Text geparst wird.

                              Und um ein bisschen konkret zu werden.
                              Ich hab an deinem Konzept nicht verstanden, was mit den geparsten Modulen passieren soll.
                              Du hast einmal die Texte und Module mit einem Hash %ex, aber was soll dann mit $PC passieren? Soll $PC erweitert werden? Mit einem Namensraum oder mit Funktionen?
                              Und wenn mit Funktionen, heißt das, das immer nur ein Modul geparst werden kann? Oder mehrere die sich eventuell gegenseitig überschreiben?

                              Und, bist du sicher, das dein Ansatz ein Vorteil gegenüber einem gängigen Templatesystem ist?

                              Ich bin mir leider, was OOP in perl betrifft, in gar nichts sicher.
                              Ich weiss, dass our kein geeigneter Weg ist, wenn man Daten privat halten will. Aber dann ist OOP in perl überhaupt kein guter Ansatz.

                              Wichtiger als die privatisierung ist die einheitliche öffentliche Schnittstelle, und diese soll dann unabhängig von der inneren Struktur sein.
                              Das ist mein Ziel.

                                
                              use PC::Parser # es wird new() exportiert  
                              my $ob->PC::Parser new(); # typisch ausgeführt mit:  
                                
                              #...  
                              #im Modul  
                                
                              sub new { # classref,  
                                 my $class = shift;  
                                 my $self = {  
                                    option => {},  
                                    storage => {},  
                                    default => {},  
                                    'system' => {  
                                        stripslashatend => 1,  
                                        error => '',  
                                    },  
                                 };  
                                 bless $self, $class;  
                                 $c_self = $self;  
                                 $self->__initialize();  
                                 return $self;  
                              }  
                              
                              

                              Es ist einfach so, dass jede sub, der ich ein $self übergebe
                              automatisch öffentlich wird für das Hauptscript.

                              $self->__initialize(); #kopiert ein hashtmplate mit
                                                         corefunktionen in die Instanz

                              Nun Hauptscript ist die primäre Anwenderschicht des Moduls.
                              Die sekundäre wird dann die Nutzung des hauptscripts sein.
                              Die sekundäre Schicht schreibt puren Text mit pc Codes. Da ist
                              kein Problem.

                              Nun habe ich einige methoden
                              sub init
                              sub initfile
                              sub parse

                              Die öffentlich sind. Sie tauschen das Self aus

                              Dann habe ich aber einen ganzen Stapel von nicht öffentlichen Funktionen
                              und von core oder modul pc-funktionen.
                              Da will ich nicht jedesmal $self übergeben.
                              Statt dessen überlege ich mir:
                              Zwischen Aufrufen der öffentlichen Methoden bleibt die bearbeitete
                              Instanz konstant.
                              Deshalb kopiere ich in new() das $self in $c_self, das mit my privat ist.
                              Es kann also nur innerhalb des eigenen Moduls verwendet werden.

                              nun ist also $c_self ein alias zum gegenwärtigen $self
                              ich kann also in meinen vielen privaten Funktionen $c_self->{option} etc abfragen und setzen. Aber es bleibt privat.

                              Aber ich brauche etwas um Daten zu holen für Funktionen, die in einem anderen package oder file kompiliert werden. Hier kommt die Funktion:

                                
                              our $PC = sub{  
                                 if( $_[0] ){  
                                    if( $_[0] eq 'option'){  
                                        ( exists $c_self->{option}   and  
                                          exists $c_self->{option}{ $_[1] } )  
                                         ? return $c_self->{ option }{ $_[1] }  
                                         : return '';  
                                    }  
                                    if( $_[0] eq 'default'){  
                                       ( exists $c_self->{default}{ $_[1] } and  
                                         exists $c_self->{default}{ $_[1] }{ $_[2] } )  
                                        ? return $c_self->{ default }{ $_[1] }{ $_[2] }  
                                        : return '';  
                                    }  
                                  }  
                                  else{ return $c_self; }   # DIESE ZEILE kann ich auch unterlassen.  
                              };  
                              
                              

                              $PC->() gibt also das $self zurück
                              $PC->() ist ein getter für die Daten in $self->{}

                              Diese Subref stelle ich nun in den Untermodulen zur Verfügung.

                              Das sieht dann in meinem konkreten Test-Untermodul  so aus:

                                
                              our $PC;  
                              our %export = (  
                                 title => {  
                                    function => sub {  
                                       ${$_[0]} = '<';  
                                       ${$_[0]} .= $PC->('option', 'element') || $PC->('default', 'title', 'element');  
                                       $PC->('option', 'class') || $PC->('default', 'title', 'class')  
                                            and ${$_[0]} .= ' class="' . $PC->('option', 'class') || $PC->('default', 'title', 'class') . '"';  
                                       ${$_[0]} .= '>'. parser( $PC->('option', 'c') ) .'</';  
                                       ${$_[0]} .= $PC->('option', 'element') || $PC->('default', 'title', 'element');  
                                      ${$_[0]} .= '>';  
                                    },  
                                    default => { element => 'h2', class => 'title', },  
                                 },  
                              );  
                              
                              

                              Ich muss jetzt nur noch dokumentieren:
                              Es gibt eine $Scalarref, welche den hganzen Content übergibt.
                              Wurde eine Funktion als Listenfunktion notiert.
                              Beispiel
                                  [somlistf+[option=value][otheroption=value]]
                              Dann kann auf die immer zur Verfügung gestellten gegenwärtigen Optionen zugegriffen werden, über $PC->('option', 'whichoption').
                              Ditto kann ich defaultwerte welche die Funktion selbst definiert
                              gegen lokale Überschreibungen vergleichen
                              $PC->('default', 'thisfunkton', 'defaultoption' )

                              Das macht die Dokumentation klar.

                              Ich will nicht dass Autoren von PC--perlfunktionssammlunen direkt auf
                              $self->{} zugreifen können. Ebenso will ich nicht, dass ich meine innere Datenstruktur von ihnen abhängig mache.

                              Das ist die Rolle von $PC->().

                              Wie gesagt, ich möchte das der Selfcommunity zur Kritik noch alles vorlegen.
                              Dann will ich aber auch Testcases und alles mitliefern.
                              Ich muss ja auch dokumentieren, was [p:c] ist, warum [p+c], [p:c] und [p=c] vorkommen.

                              mfg Beat

                              --

                              ><o(((°>           ><o(((°>
                                 <°)))o><                     ><o(((°>o
                              1. Hoi.

                                Ich habe das alles jetzt mehrfach gelesen und muss zugegeben: ich raff nix ;-)

                                Trotzdem kam mir der Gedanke, ob Du evtl. hiermit glücklich werden könntest:
                                http://perldoc.perl.org/perltoot.html#Inheritance

                                Du definierst also Deine Basisklasse mit allem was da so reingehört:
                                PC::Base

                                Will nun einer PC::XYZ implementieren, so leitet er von PC::Base ab und implementiert den spezifischen Code(vermutlich der Parserteil)...

                                Grüße von dem, der nie exportiert, nie importiert(qw()) und noch nie our benutzt hat(muss nix heissen, bin bestimmt kein Perl Crack)...

                                PS:
                                Ich sehe hier sehr komprimierten "Coding Style"... sowas hat seinen Beitrag bzgl. Perls schlechtem Ruf ;-)

                              2. Wichtiger als die privatisierung ist die einheitliche öffentliche Schnittstelle, und diese soll dann unabhängig von der inneren Struktur sein.
                                Das ist mein Ziel.

                                Ich glaube hier möchtest du ein singleton haben, das sich in Perl auch leicht realisieren läßt.

                                #! /usr/bin/perl -w  
                                use strict;  
                                  
                                package Test;  
                                my $self = bless {}, __PACKAGE__;  
                                sub new {  
                                 return $self;  
                                }  
                                sub addSub {  
                                   shift; #falls du die Funktion mit $instanz->addSub ansprechen musst  
                                   my($name, $sub) = @_;  
                                  
                                   no strict 'refs';  
                                   *{ (ref $self ) .'::' . $name} = $sub;  
                                }  
                                  
                                package main;  
                                  
                                my $o = new Test();  
                                  
                                $o->addSub('test', \&hallo);  
                                $o->test('hallo');  
                                  
                                sub hallo {  
                                 shift;  
                                 print shift;  
                                }
                                

                                Es ist einfach so, dass jede sub, der ich ein $self übergebe
                                automatisch öffentlich wird für das Hauptscript.

                                Meinst du, dass du deinem Objekt Funktionen hinzufügen möchtest?

                                #! /usr/bin/perl -w  
                                use strict;  
                                  
                                package Test;  
                                my $self = bless {}, __PACKAGE__;  
                                sub new {  
                                 return $self;  
                                }  
                                sub addSub {  
                                   shift; #falls du die Funktion mit $instanz->addSub ansprechen musst  
                                   my($name, $sub) = @_;  
                                  
                                   no strict 'refs';  
                                   *{__PACKAGE__ .'::' . $name} = $sub;  
                                }  
                                  
                                package main;  
                                  
                                my $o = new Test();  
                                  
                                $o->addSub('test', \&hallo);  
                                $o->test('hallo');  
                                  
                                sub hallo {  
                                 shift;  
                                 print shift;  
                                }  
                                
                                

                                Zwischen Aufrufen der öffentlichen Methoden bleibt die bearbeitete
                                Instanz konstant.
                                Deshalb kopiere ich in new() das $self in $c_self, das mit my privat ist.
                                Es kann also nur innerhalb des eigenen Moduls verwendet werden.

                                Das ist ein singleton, wie oben beschrieben.

                                Dann kann auf die immer zur Verfügung gestellten gegenwärtigen Optionen zugegriffen werden, über $PC->('option', 'whichoption').
                                Ditto kann ich defaultwerte welche die Funktion selbst definiert
                                gegen lokale Überschreibungen vergleichen
                                $PC->('default', 'thisfunkton', 'defaultoption' )

                                Ein Sache, die gerne in Büchern empfohlen wird, ist, nicht zuviel Funktionalität in eine Funktion packen. Sie wird dadurch immer schwerer benutzbarer und auch die Fehlersuche kann sich erheblich erschweren.

                                Der Rest ist auch für mich nicht 100% verständlich, bzw. ist mir nicht klar was am Ende rauskommen soll. Aber bei dem was ich verstehe scheint es mir du machst es dir umständlich, bzw. willst du zuviel. Ich habe auch lange versucht Funktionen so universell wie möglich zu halten, habe aber mittlerweile eingesehen, dass ein Aufruf von "Hand" oft der Übersichtlichkeit dient und im Zweifelsfall nutze ich lieber Funktionalität die Perl sowieso schon bietet (oder vorhandene Module) bevor ich mir mit komplexen Strukturen oder Funktionen selbst in's Knie schiesse.

                                Struppi.

      2. und schon wieder ein NAchtrag.

        leider nein

        at C:....../Parser.pm line 421, near "%( $mod"

        Das entspricht nicht dem Code den du uns gezeigt hast. Das sind wenn, die Fehler aus deinem ursprünglichen Code.

        Struppi.

  2. Ich kann zur runzeit erst ein pm laden, also mit require.

    Ach noch ein Nachtrag.

    Ich verwende in so einem Fall meistens eval "use $modul;" was oft bequemer ist. Und um zu prüfen ob eine Funktion existiert bevorzuge ich can('funktion').

    Struppi.