Übergeben Sie eine Methode eines bestimmten Objekts als Eingabeargument in Tcl

Question

Ich schreibe ein EDA-Dienstprogramm, das auf einer TCL 8.6-konforme API beruht. Meine Herausforderung ist wie folgt:
Mein Dienstprogramm läuft auf Transistoren Modelle in der Datenbank und führt einige Analyse, mit einem TCL-API-Befehl eines EDA-Lieferanten. Ich kann den TCL-Befehlen einen TCL-Prozedurnamen/-zeiger übergeben, und die Analyse wird sich eher auf meinen Code als auf den Code der EDA-Hersteller stützen. Die interne geschriebene Prozedur akzeptiert als ein Argument einen Zeiger auf die spezifische Transistorinstanz in der Datenbank des EDA-Anbieters. Jetzt ermöglicht der EDA-Hersteller TCL 8.6, was bedeutet, dass ich lieber als einen globalen proc-Namen oder einen Namensraum proc-Namen, den Namen/Zeiger des spezifischen Objekts den Namen übergeben möchte. Wie mache ich das? Im Codebeispiel:

oo:class create foo { 
    constructor {} { 
     variable numy 2 
    } 
    method fooshta { mos_pointer } { 
     puts "now in mosy [get name $mos_pointer ]" 
    } 
    destructor {} 
} 
foo create bar 
analyse_tx -proc < how do I refer to bar's method fooshta?> 

In einem nicht OOP Zusammenhang würde der Code wie folgt aussehen:

proc fooshta { mos_pointer } { 
     puts "now in mosy [get name $mos_pointer ]" 
    } 
analyse_tx -proc fooshta 

Wie man sehen kann, ich bin auf der Suche nach der Antwort für < how do I refer to bar's method fooshta, so that the EDA tool will invoke it for each transistors' instance? and pass the parameter?>
Dank.

Answer 1

Sie können nicht, nicht direkt, zumindest nicht, wenn es wie folgt aufgerufen werden soll:

$procname $thing_to_give_to_your_code 

Wenn stattdessen wird es wie folgt aufgerufen:

{*}$procname $thing_to_give_to_your_code 

Dazu kann tun, indem es in Befehlspräfix übergibt.

analyse_tx -proc [list bar fooshta] 

Dies ist die, die ich empfehlen würde. Es könnte funktionieren auch, wenn die invoke wie dies geschehen ist:

eval $procname [list $thing_to_give_to_your_code] 

Dergleichen ist groß, da es auch Sie apply usw. gebunden passieren in Dinge wie Lambda-Ausdrücke können. Es ist ein sehr flexibles System (da es tatsächlich als allgemeine Funktion Currymechanismus funktioniert) und es ist ziemlich einfach.

Wenn Sie jedoch mit dieser Art von invoke stecken:

$procname $thing_to_give_to_your_code 

dann müssen wir einen indirekten Mechanismus verwenden: ein Intra-Interpreter alias wird uns einen Befehl machen lassen (so ja, es wird einen Namen haben), dass die Delegierten der Methode:

# The {} are to indicate that this command is aliasing from and to the current interpreter context 
interp alias {} delegate-bar-fooshta {} bar fooshta 

Dann können wir nur delegate-bar-fooshta in als Befehlsnamen übergeben. Wenn Sie dies häufig tun, sollten Sie die Delegaten wahrscheinlich in den Namespace-Kontext des Objekts einfügen. es ist wahrscheinlich am einfachsten, eine Methode, um für die Einstellung Dinge:

oo::class create foo { 
    constructor {} { 
     variable numy 2 
    } 
    method fooshta { mos_pointer } { 
     puts "now in mosy [get name $mos_pointer ]" 
    } 
    destructor {} 

    method delegate {method args} { 
     # We'll also bind in any extra arguments you choose to use 
     interp alias {} [self namespace]::delegate-$method \ 
       {} [self] $method {*}$args 
     return [namespace which delegate-$method] 
    } 
} 

foo create bar 
analyse_tx -proc [bar delegate fooshta] 

Durch es, wie dies zu tun, wird das Objekt auch mit den üblichen Mechanismen Abtötung entfernt die Delegierten-Befehle, die es besitzt. Dies ist sehr praktisch in einem komplexen Programm, da es mehr von den Hausaufgaben an Tcl selbst aus Ihrem Skript auslagert.