Welche Variablen wurden definiert?

[ingmar]

Eine Frage, die Kollege harm dankenswerterweise schon vor Jahren gelöst hatte : - )

Aber wenn ich richtig verstehe, kommen wir zur Zeit nicht mehr ans Archiv ran.

Ich möchte ein File einlesen, in dem Variablen definiert werden, und anschließend möchte ich gerne wissen, welch Variablen dort genau definiert wurden. Statt das File sozusagen "zu Fuß" zu parsen, wäre die bessere Lösung,
1. Eine Liste aller existierenden Variablennamen anzufertigen
2. Das gewünschte File einzulesen
3. Noch einmal alle existierenden Variablennamen zu sammeln, dabei in der zweiten Liste aber diejenigen rauszulassen, die in der ersten Liste schon enthalten waren.

Um sowas wie ein Minimalbeispiel zu liefern:

File "new-variables.ly":

Code Auswählen Erweitern

version = "2.20.0"
language = "english"

a = 15
bbbb = "hokuspokus"
ccccccccc = \relative { c'2 d4 e f g a b c1 }
% d = 399
ee = ##F

Dann, in ein em anderen File:

Code Auswählen Erweitern

version = "2.20.0"

variables-before = [... <scheme-zauberei> ...]
\include "new-variables.ly"
variables-after =  [... <scheme-zauberei> ...]
variables-found =  [... <scheme-zauberei> ...]

Die Variable variables-found würde danach folgende (scheme-) Liste enthalten:

'( "a" "bbbb" "ccccccccc" "ee" )

Diese Liste von Namen ist, was ich suche – ich brauche weder die Inhalte von variables-before oder variables-after (die hab ich hier nur aus didaktischen Gründen eingeführt) noch mehr Infos über die gefundenen Variablen (auch nicht deren Typ).

Tja. Wer kann helfen? : - )

Gruß, danke und jahreszeitliche Grüße!
--ingmar

[Manuela]

Ich weiß nicht, ob dir das weiterhilft, ich habe mir das vor Urzeiten mal in meinem Wiki notiert

Code Auswählen Erweitern

#(define current-module-bindings (ly:module->alist (current-module)))
%% alle Variablen, die ab hier bis zum Aufruf des Programms definiert werden, werden ausgegeben

A = 1
BB = "zwei"
CCC = { c d e f g }
DDDD = "auskommentiert"
#(let ((bindings
        (assoc-remove!
         (lset-difference
          equal?
          (ly:module->alist (current-module))
          current-module-bindings)
         'current-module-bindings)))
   (pretty-print
    (sort
     (map car bindings) symbol<?)))
Allerdings werden die Variablen in das Log geschrieben.

[ingmar]

Ich weiß nicht, ob dir das weiterhilft, ich habe mir das vor Urzeiten mal in meinem Wiki notiert

Ah! "vor Urzeiten" – das kommt auf jeden Fall hin.. – Ich schau es mir in den nächsten Tagen mal genauer an.

Allerdings werden die Variablen in das Log geschrieben.

Ich erinnere mich, dass das damals auch so war – hat mich nicht so richtig gestört.

Danke!
--ingmar

(EDIT: Ich erinnere mich, dass sie damals *auch* ins Logfile geschrieben wurden, nicht, dass das *nur* so gewesen wäre..)

[ingmar]

Nochmal danke für die Antwort.

Zweiter Blick auf den Code: Ich verstehe nur Bahnhof. Ich muss doch irgendwie irgendwo
 (1) die zur Ausführungszeit bestehenden Variablen festhalten,
 (2) mein neues, zusätzliches File einlesen, und
 (3) von neuem die bestehenden Variablen feststellen und nur diejenigen in einer Liste sammeln, die im neuen File hinzugekommen sind.

Keinen dieser drei Schritte kann ich in deinen Notizen von damals isolieren. Lass ich das Ganze mal probeweise laufen, kriege ich einen Syntax->Error ("unexpected end of input"). Leider sind meine (nie besonders hochentwickelten) scheme-Kenntnisse in den vergangenen Jahren noch viel rostiger geworden; ich kann damit in dieser Form leider gar nix anfangen.

Ich weiß nicht, ob dir das weiterhilft [...]

Offen gestanden: Nein. Trotzdem vielen Dank für deine Zeit! : - )

--ingmar

[Manuela]

Bei kompiliert der Code problemlos, hast du wirklich alles kopiert?

Bei den gewünschten Funktionen kann ich dir leider auch nicht weiterhelfen, da meine Scheme-Kenntnisse mehr als bescheiden sind und ich schon länger nichts mehr in dieser Richtung gemacht habe.

[ingmar]

Bei kompiliert der Code problemlos, hast du wirklich alles kopiert?

Du merkst aber auch alles!  : - (

Ich hatte natürlich die ersten beiden Zeilen weggelassen, getreu der alten Programmiererregel: "In einer unbekannten Sprache ist alles, was mit einem komischen Dingsbums anfängt, ein Kommentar."

[ingmar]

Habs jetzt noch einmal versucht und festgestellt, dass es bei mir genau dann kompiliert und ein Ergebnis liefert, wenn ich die Zeile "CCC = <musikalischer Ausdruck>" auskommentiere.

O-Ton (ohne diese Zeile):
  [...]
  Analysieren...
  (A BB)

  Kompilation erfolgreich beendet
  Erfolgreich abgeschlossen in 0.6".

Mit besagter Zeile erhalte ich:
  [...]
  Fehler: syntax-error, unexpected end of input

  #let (bindings
  (A BB)
  schwerer Fehler: gescheiterte Dateien [...]
  Wurde mit dem Return-Code 1 beendet.

Meine LilyPond-Version ist 2.20.0.
Hm!

--ingmar

[Manuela]

Hm, da muss ich passen. Ich kann nur mit Lilypond 2.25.xx dienen.

Lt. Dokumentation sollte die Funkton ly:module->alist auch in der Version 2.20 bereits bekannt sein.

Kopierst du mal deinen exakten Code hierher?

Update: ich habe mal getestet, auch die Variablen aus \include-Dateien werden aufgelistet. Wenn man besser scheme könnte, könnte man anstelle des "pretty-print" die let-Anweisung in ein scheme-Programm einbauen und die Liste nach Wunsch aufbereiten.

car bindings enthält die Variablennamen, cdr bindings den Inhalt.

[harm6]

Hallo ingmar

wenn ich den exakten code, ohne irgendwelche Veränderungen:

Code Auswählen Erweitern

#(define current-module-bindings (ly:module->alist (current-module)))
%% alle Variablen, die ab hier bis zum Aufruf des Programms definiert werden, werden ausgegeben

A = 1
BB = "zwei"
CCC = { c d e f g }
DDDD = "auskommentiert"

#(let ((bindings
        (assoc-remove!
         (lset-difference
          equal?
          (ly:module->alist (current-module))
          current-module-bindings)
         'current-module-bindings)))
   (pretty-print
    (sort
     (map car bindings) symbol<?)))
durchlaufen lasse, so funktioniert alles. Mit allen getesteten Versionen, d.h. von 2.20.0 bis 2.25.23.
Auch wenn ich statt oder zusätzlich ein file inkludiere:

Code Auswählen Erweitern

#(define current-module-bindings (ly:module->alist (current-module)))
%% alle Variablen, die ab hier bis zum Aufruf des Programms definiert werden, werden ausgegeben

\include "file.ly"

#(let ((bindings
        (assoc-remove!
         (lset-difference
          equal?
          (ly:module->alist (current-module))
          current-module-bindings)
         'current-module-bindings)))
   (pretty-print
    (sort
     (map car bindings) symbol<?)))

Bei mir geht es nur dann krachen, wenn das inkludierte file selbst einen Fehler hat, der auch die direkte Kompilierung von file.ly zum scheitern bringt.

Gruß,
  Harm

[ingmar]

wenn ich den exakten code, ohne irgendwelche Veränderungen [...] durchlaufen lasse, so funktioniert alles. Mit allen getesteten Versionen, d.h. von 2.20.0 bis 2.25.23.[...]

Tja, da muss ich ja irgendeinen blöden Fehler gemacht haben. Sorry, wenn ich euch damit aufhalte.

Seit Manuelas Hinweis bis jetzt bin ich leider nicht dazu gekommen, mir das näher anzusehen. Ich denke, nach dem Wochenende hab ich Luft – ich werde mich melden.

Herzlichen Dank nochmnal für euren Einsatz, und alle guten Wünsche für das nächste Vierteljahrhundert! ; - )

--ingmar

[ingmar]

Tja, da muss ich ja irgendeinen blöden Fehler gemacht haben.

Ja, so war es auch. Lassen wir das... : - (

Wenn man besser scheme könnte, könnte man anstelle des "pretty-print" die let-Anweisung in ein scheme-Programm einbauen und die Liste nach Wunsch aufbereiten.

Ja, so gehts auch bei mir weiter, und das ist natürlich gleich das nächste Problem, wo ich ins Straucheln komme: Ich will mit der erzeugten Liste natürlich auch etwas anstellen!

Also:
1. Ich lasse jetzt im Code erstmal das pretty-print und das Sortieren weg; die brauch ich nicht:

Code Auswählen Erweitern

#(let ((bindings
        (assoc-remove!
         (lset-difference
          equal?
          (ly:module->alist (current-module))
          current-module-bindings)
         'current-module-bindings)))

     (map car bindings))
(Ich stelle mir vor, dass \bindings nun Strings enthält, nicht Symbole; andernfalls müsste man hier noch dafür sorgen.)

2. Etwas später in meinem LilyPond-Code würde ich nun gerne über die Elemente von \bindings iterieren. Ich brauche also eine Funktion, der ich \bindings übergeben kann, und die dann für jeden der enthaltenen Strings wieder zu LilyPond zurückkehrt, das mit diesem String irgendwas anstellt. Um es hier (hier im Forum) einfach und nachvollziehbar zu halten, könnten LilyPond heute erstmal einfach den String in einem \markup ausgeben, vielleicht die Farbe zufällig wählen oder irgendsowas.

Nach meinem Verständnis brauche ich hier also entweder for-each oder map und meinen LilyPond-Code, diesen aber in guile definiert, mit einem String als Argument. Das kann nun eigentlich keine Raketenwissenschaft sein, aber ich tu mich doch schwer damit.

Vielleicht kann auch hier jemand von euch weiterhelfen...? : - )

Gruß, danke,
--ingmar