Proc-Name in StringVariable & aufrufen

[JörgG]

Hallo zusammen, ich möchte einige proc's aus einer Schleife aufrufen (ca 25). Je nach Ereignis/Resultat soll die entsprechende Proc gestartet werden. Die Proc's heißen genau so, wie die möglichen Ereignisse/Resultate. Diese sind in einer Stringvariablen gespeichert.
So, Standardmäßig machen wir das ja jetzt so:

...
If res$ = "eins"
   eins 'proc 'eins' wird aufgerufen
Elseif res$ = "zwei"
   zwei 'proc 'zwei' wird aufgerufen
Elseif ...
... 'und das ganze jetzt 25x

Endif

Die proc's behandeln dabei unterschiedlichste Aufgaben (Es gibt da also keine Ähnlichkeiten, die man evtl. zusammenfassen könnte)
Jetzt möchte gerne stattdessen folgendes Model bauen:

...
res$ 'die proc aufrufen, deren name den Inhalt der von res$ entspricht :-)
...
'ich spar mir also die ganze If/Elseif/Endif-Abfragerei

Nun kann ich aber ja nicht einfach so zusammenhanglos eine Variable hinschreiben.. Ich bräuchte also etwas, damit der Interpreter weiß, das er eine proc anspringen soll, die so heißt wie der Inhalt der Stringvariablen.
Also sowas, wie das früher mit Gosub funzte (gosub res$)
Kennt ihr da einen Trick, wie man das Hinkriegt? Ich denke da an sowas wie:

call res$
 'oder:
jump res$

Wär doch geil

[_Joerg_]

Du kannst die Funktionsadressen der Prozeduren mit ProcAddr() ermitteln und in einer Liste oder einem Array speichern und dann aufrufen.

Cls

Proc Test
  Parameters l&
  Var txt$ = String$(l&,0)
  MessageBox( Txt$,"In der Prozedur",0)
EndProc


Declare function&,Parameter$
function& = ProcAddr("Test",1)
Parameter$ = "Es klappt!"
Call(function&,Addr(Parameter$))
WaitInput

Aber unbedingt beachten:

Zitat von Profan Hilfe

Es ist jedoch zwingend darauf zu achten, dass während des Aufrufs einer Prozedur von außerhalb über @ProcAddr das XProfan-Programm nicht weiterläuft, da XProfan derzeit nicht in der Lage ist, zwei Codeteile in einem Prozess parallel auftzurufen.

[JörgG]

Hi Jörg, Danke für das Beispiel. In dieser Richtung habe ich auch schon geforscht, aber es dann wieder verworfen. Irgendwie ist es am Ende deutlich mehr Code als If/ElseIf/EndIf und der Aufwand in der Schleife ist der Gleiche, nur das ich jetzt in einemArray/Liste nach dem entsprechenden Ausdruck suche & die dazu gehörige ProcAdresse rausgrabbel.
Und zusätzlich muß ich ja vorher dieses Array/Liste anlegen... Ich denke, da komm ich vom Regen in die Taufe
Obwohl der Anzatz der Richtige ist, der Pferdefuß ist, daß zum Ermitteln der ProcAdresse UNBEDINGT ein Stringliteral für den procNamen verwendet werden muß. Wenn das eine Variable sein dürfte, wär alles schick:

'test dynamische ereignisAuswertung
Declare sm$
cls

Proc 27
  end
EndProc

Proc 48
  Print "Null"
EndProc

Proc 49
  Print "Eins"
EndProc

Proc 50
  Print "Zwei"
EndProc

Proc 51
  Print "Drei"
EndProc

while 1
  WaitInput
  sm$ = Str$(%key) 'sm$ enthält den ereignisstring (hier einfach den keycode)
                   'es können aber auch andere ausdrücke sein zu denen dann
                   'exakt eine gleichnamige proc gibt
  Call(ProcAddr(sm$,1),0) 'so wär nicht schlecht
endwhile
 
end

[p. specht]

Naja, in der guten alten Zeit wäre das kein Problem gewesen:

Randomize:Cls rnd(8^8):Var c$="1 2 3 4" ' steuert Abfolge
Declare s$[]:s$[]=explode(c$," ")
WhileLoop 0,sizeof(s$[])-1:gosub s$[&Loop]:Endwhile:WaitInput:End:1:
Print "jaja, 1!":return:2:
Print "Und 2":return:3:
print "sowie 3, oder ":return:4:
Print "etwa gar 4 ?":return

... aber wenn man halt unbedingt Proc verwenden will... ähm...

[_Joerg_]

Das geht alles - erfordert etwas mehr Aufwand aber wenn man wirklich viele Procs hat...

Declare ArrHdl$[4,2],Aufruf$,FunktionsAddr&,Index%

Proc Test1
  Print "Proc Test1"
EndProc

Proc Test2
  Print "Proc Test2"
EndProc

Proc NochEinTest
  Print "Proc NochEinTest"
EndProc

Proc GanzWasAnderes
  Print "Proc GanzWasAnderes"
EndProc
Var Procs$ = "Test1,Test2,NochEinTest,GanzWasAnderes"

Cls
'Hier könnte man noch festlegen, ob die Schreibweise berücksichtigt wird
'wenn Du alles klein oder groß schreibst, erfolgt die Übergabe dann mit Upper$/Lower$
ArrHdl$[0,0] = "Test1"
ArrHdl$[0,1] = Str$(ProcAddr(Test1,0))
ArrHdl$[1,0] = "Test2"
ArrHdl$[1,1] = Str$(ProcAddr(Test2,0))
ArrHdl$[2,0] = "NochEinTest"
ArrHdl$[2,1] = Str$(ProcAddr(NochEinTest,0))
ArrHdl$[3,0] = "GanzWasAnderes"
ArrHdl$[3,1] = Str$(ProcAddr(GanzWasAnderes,0))
  Print "Befehle sind:",Procs$
  Print "Bitte eingeben..."

While 1
  'WaitInput
  Input Aufruf$
  If Instr(Aufruf$,Procs$)
    Index% = IndexOf(ArrHdl$[],Aufruf$)
    FunktionsAddr& = Val(ArrHdl$[Index%,1])
    Call(FunktionsAddr&)
  ElseIf Aufruf$ = "q"
    Break
  EndIf
Wend

Wenn's wirklich viele Prozeduren sind, würde ich mir ein kleines Programm schreiben, daß den benötigten Code zur Befüllung des Arrays schreibt.
Sowas wie das hier:

Declare s$
WhileLoop 22
   s$ = s$ + "Dim Bereich" + Format$("00",&Loop) + "#,500\n"
Wend
ClearClip
PutClip s$

[RGH]

Also ich würde DRINGENDST davon abraten, ProcAddr derart zu missbrauchen. Das wird auf Dauer schiefgehen.

Gruß
Roland

[JörgG]

Hi Jörg, da haben wir wohl beide parallel getüftelt . Ich habe noch mal deinen Anzatz mit ProcAddr & call überdacht. Das ist rausgekommen:

'test dynamische ereignisAuswertung
Declare sm$
Declare a#, n#
'---------------------------------------------------------
Proc *27*
  dispose a#, n# 
  end  
EndProc

Proc *48*
  Print "Null"
EndProc

Proc *49*
  Print "Eins"
EndProc

Proc *50*
  Print "Zwei"
EndProc

Proc *51*
  Print "Drei"
EndProc
'-----------------------------------------------------
Proc regist 'hier hänge ich einfach jeden neuen procNamen (=ereignis) an
 Dim a#, 20 'bereich für procAdressen
 Dim n#, 30 'bereich für procNamen
  'alle adressen der procs hintereinander in den bereich für die addressen schreiben
 Long a#, 0 = ProcAddr(*27*,0), ProcAddr(*48*,0), ProcAddr(*49*,0), ProcAddr(*50*,0), ProcAddr(*51*,0)
  'alle namen in der gleichen reihenfolge in den bereich für die procnamen schreiben
  'direkt vor jeden namen steht die position der adresse im adressbereich
 Char n#, 0 = "00*27*", "04*48*", "08*49*", "12*50*", "16*51*"
EndProc
regist 'proc-adressen registrieren
'-------------------------------------------------------
cls
Print "Bitte Testweise die Zifferntasten 0-3 (nicht NumBlock) drücken"
Print "ESC = Ende"
Print

while 1 'dynamische ereignisschleife
  WaitInput
  sm$ = Str$(%key) 'sm$ enthält den ereignisstring (hier einfach den keycode)
  Call(long(a#,val(Char$(n#,MemPos(n#,0,"*" + sm$ + "*")-2,2)))) 'so gehts
endwhile
end

Die Ereignisschleife bleibt sehr kompakt
Zu jeder neuen proc muß ich nur in der proc 'regist' in den zwei Zeilen die Parameter anhängen & die Bereiche vergrößern
Die Ereignisse kommen aus einer Auswahlbox, die ständig größer wird. Also es werden immer mehr Proc's (aber nicht ewig).
Das Beispiel ist sofort Lauffähig - aber keine anderen Tasten Drücken!
Was haltet ihr von dieser Technik? Wie gesagt - da die Ereignisse aus eine Auswahllistbox kommen, kann Userseitig später nichts schiefgehen
Und Die Ereignisschleife bleibt immer sehr kompakt - sie wird nicht größer

[JörgG]

@Jörg, ich werde mir jetzt mal deinen letzten Vorschlag reinziehen

[_Joerg_]

was Roland davon hält, hat er ja geschrieben. Ich finde die Idee grundsätzlich nicht schlecht, halte mich da aber lieber an Rolands Empfehlung.

[_Joerg_]

sm$ = Str$(%key)

So geht's nur seeehr begrenzt. Nach jedem Ereignis, das WaitInput durchbricht,, wird ja sofort per Call was aufgerufen. Wer weiß, was Du da mal erwischst. Das ist, wie mit 'ner Schrotflinte im dunklen Kino rumschießen...
Mein Input ist ja auch nur als Beispiel gedacht. du könntest ein Editfeld erzeugen, das Du dann bei Enter oder Buttonklick ausliest und dann die entsprechende Prozedur aufrufst.

[JörgG]

Ja, das weiß ich, dies sollte doch nur als Demo die Funktionsweise zeigen. Später kommen die Ereignisse nicht von der Tastatur sondern aus einer Auswahlbox, aus der der User was auswählt.

[Frabbing]

Ich würds lieber klassisch machen. Wenn die If-Schleifen dir zu aufwendig erscheinen, könntest du mal Select/Case probieren.

[JörgG]

...Wenn die If-Schleifen dir zu aufwendig erscheinen, könntest du mal probieren.

Najaa, mir geht es nicht NUR um den Aufwand von If/Else. Die EreignisSchleife ist dadurch sehr übersichtlich - und bleibt es auch - egal, wie viel verschiedene Ereignisse & Procs hinzukommen (sie ist praktisch wartungsfrei).
Ich muß so nur eine neue proc schreiben & in der proc 'regist' die neuen Werte anhängen.
Im Grunde genommen ist dieser Aufwand auch nicht kleiner als einfach einen neuen ElseIf-Zweig anzuhängen . Aber vllt. löppt das so ein Tick schneller, weil ja nicht mehr zig-mal abgefragt werden muß, sondern sofort die passende proc angesprungen wird.
Und ich wollt halt mal 'ne andere Strategie erforschen
Select/Case hatte ich in Erwägung gezogen, nur hätte ich in der Schleife eine kaum nennenswerte Zeileneinsparung... und ich glaube, irgendwo im Forum gelesen zu haben, das Case nicht ganz so schnell arbeitet, wie If/ElseIf. Bin mir aber nicht sicher...

[Frabbing]

Versuch macht ja bekanntlich klug.
Kannst ja hier mal berichten, wenn doch irgendwann Probleme mit der Methode auftauchen sollten.

[JörgG]

Jo, mach ich
Diese Methode wird ja auch nur auf dieses Projekt beschränken...