Formelsprache TO LotusScript Code-generierer schreiben

[flaite]

gerade an der Stelle, wo Du jetzt offensichtlich bist, vergiss bitte auch derartige Konstrukte nicht:
- @Do
- @ For
- @While
- @Return (vor allem, wenn dessen Folge ein Formelabbruch ist)
Was machst Du mit FrontEnd-Elementen (@Prompt, @Commands usw.) ?

Das sind Spezialfälle von oben b) FormelToken (hier eine Menge konkrete Klassen)
Es geht mir ja nun erst einmal darum den FormelCode in eine Art Baum zu konvertieren. Das geht auch mit den obigen Befehlen.
Gleiches gilt für @Prompt. @Commands sehe ich - wie oben angemerkt - als eigenen Subtyp von Token mit mehreren konkreten Unterklassen. Pro Command eins. Die kann man auch im Baum darstellen und mit LotusScript Code darstellen.

Sobald das mit dem Baum einigermassen läuft, kann ich ein Diagramm posten, der die Idee vielleicht ein bischen deutlicher ist.

Code

Könntest Du in irgendeiner Form die Diskussion auch programmierspachenunabhängig publizieren ? 

Die Diskussion ist in einem ziemlich hohen Grade programmiersprachenunabhängig. Ich verwende nur ziemlich viel GoF Pattern-Sprache, weil ich das eben in mein Denken über Programmierprobleme integriert habe. Dies schlägt sich natürlich auch im Code wieder (von wegen Mitarbeit). Thomas, vermutlich Jens und vielleicht der eine oder andere Student können es vielleicht so nachvollziehen. Auf der anderen Seite bietet es mir die Möglichkeit, meine Ideen kurz auszudrücken und das ist was ich will. Mit langatmigen Erklärungen ohne aus meiner Sicht effiziente GoF Pattern Fachbegriffe würde der Text sehr lang und mißverständlich werden. Und zwar einfach, weil das eine komplexe Aufgabe ist.

GoF sind keine spezifischen Java Ideen, sondern sie sind programmiersprachenunabhängig mit Delphi und C++-Beispielen entwickelt worden finden auch in anderen Programmiersprachen starkes Interesse.
Google-Links:
http://www.google.de/search?hl=de&q=C%23+Gof&btnG=Google-Suche&meta=
http://farm.tucows.com/blog/Languages/Python/_archives/2005/3/28/485818.html

Ich erwarte zum momentanen Zeitpunkt keine großartige Mitarbeit. Sobald ich das äußere Framework fetgezurrt habe, kann es klarer werden. Ich verwende Java, da es mir effizient für diese Aufgabe erscheint. Ich bin tagsüber auch in Notes4 basierten Projekten involviert. Ich hoffe, dass das Framework einen so festen Rahmen vorgibt, dass auch Leute ohne großartige Java-Kenntnisse einen Beitrag leisten könnnen, falls sie Interesse haben. Nur ist das jetzt eben das grundlegende Framework und das find ich selbst relativ heavy.   

Wenn das Framework fertig ist, kann ich das aus der Rückschau auch einfacher ohne GoF-Sprache erklären. Nur aus der Vorschau - wenn man selbst noch eine Menge Unklarheiten hat - ist es schwierig.

Gruß Axel

[Untitled]

Ich habe mich auch schon mit compilern befasst und glaube deswegen meinen stuss auch noch dazugeben zu müssen:

Willst du eigentlich alles auseinandernehmen und danach in LS wieder zusammenfügen oder wie? Also meine konkrete Frage: Reichen einfach "text-ersetzer" nicht aus?

Die Frage ist natürlich, hat LS eine grundlegend andere Struktur als die Formelsprache? Aber ich denke doch, zB eine einfache If hat lediglich folgende zeichen zu ersetzen:

Bei verschachtelungen (zB @funktion in @if) müsste dies natürlich rekursiv geschehen...

Oder hab ich da was vergessen?

[eknori]

@Axel: Guck mal hier ( http://www.openntf.org/Projects/codebin/codebin.nsf/CodeByDate/A95B7A4F5D65505386256E430040E783 )
Evtl. ganz interessant ...

[flaite]

@Untitled: Howdy Pardner. Cooler Name 

Ich habe mich auch schon mit compilern befasst

Ich überhaupt nicht. Funktionieren Compiler so, dass der Text in einen Baum konvertiert wird 
Dann hat der Schweizer Wirtschaftsflüchtling und Fersengeldgeber Marco alias Gandhi doch recht 

Also meine konkrete Frage: Reichen einfach "text-ersetzer" nicht aus?

Nein. Die Struktur ist wirklich zu unterschiedlich.
Vom rein ökonomischen Standpunkt aus halte ich dieses ganze Projekt auch von meiner Sicht aus für nicht break-even-point fähig. Aber ich beschäftige mich sonst in Java mit Spring, JBoss und so Zeug und das ist mal etwas für meine Verhältnisse wirklich low level und ich kenne mich in der "Domain" gut aus (Formelsprache und LotusScript). Daher kommt meine Energie für dieses Projekt.

@Ulrich: danke. Das ist wenigstens mal eine vollständige Liste. Ich hab aus verschiedenen Skriptlibs dafür eine Menge, aber eben verstreut, aus verschiedenen Epochen, etc.

Ich rechne damit, dass ich - trotz viel Arbeit im Tagesjob - noch vor dem Verkünden des Wahlergebnisses der Bundestagswahl den Baum stehen hab.
Mit einer Menge UnknownFormula-Class Objekten.

Gruß Axel

[eknori]

hier wäre noch eine Quelle von jemandem, der dir evtl. weiterhelfen kann ...

http://www.carlosag.net/Tools/CodeTranslator/Default.aspx

Fragen kostet ja nix.

[flaite]

Sehr interessante Seite. Ist aber ohne Source code? Und ich zieh erstmal meine Idee durch.
Das wichtigste ist erstmal die Go Partien ein bischen einzuschränken.
Die Komplexitäten sehe ich dann.
Ein großes Problem wird vermutlich sein, dass Formelsprache-Variablen ohne jegliche Typen-Information sind.

[Gandhi]

Fersengeldgeber Marco

Verstehe ich nciht

[flaite]

Verstehe ich nciht

War ein Joke.
Echte Männer leben nach der Devise: Besser eine schlechte Presse als gar keine Presse.

[Gandhi]

na dann brauche ich mich ja nicht sachlich damit auseinanderzusetzten. Nicht dass ich das hier am Ende noch als Kritik an fehlenden Beiträgen verstanden hätte.

BTW: unabhängig von den mir nicht verständlichen Codefragmenten/Patternphilosophieren...wie ist Dein Stand?

[flaite]

Nicht dass ich das hier am Ende noch als Kritik an fehlenden Beiträgen verstanden hätte.

Weit gefehlt. Ich hab hier irgendwo gesagt, dass ich zum jetzigen Zeitpunkt keine Beiträge von aussen erwarte.

Patternphilosophieren...

Hey Leute. Patterns sind abstrakte Tools, um ein effizientes Design zu erreichen. Das hat nix mit "Philosophieren" zu tun.
Der Code ist z.Zt. sowieso unter Dauerrefactoring. Der ist nicht sonderlich verständlich für Aussenstehende, obwohl die Struktur eigentlich ziemlich einfach ist und letzteres ist ermutigend.

wie ist Dein Stand?

Ganz gut, wobei ich deutlich langsamer vorankomme als ich gedacht habe.
Ich habe jetzt einen Parserservice für Character mit dynamisch auswechselbaren Filtern, der mit einem ParserContext Objekt interagiert. Das ParserContext Objekt hält den großen Überblick (auch State genannt).
Der Pränformatierungsschritt ist fertig.
Ich habe Verständnis für Formelsprache gewonnen und meine ubiquitous (oder wie das heisst) language für die Domain erweitert. Formelsprache-Code besteht aus Codesegmenten. Die Trenner sind alle ";", die nicht innerhalb von Strings oder in Klammern stehen.

Ich bereite nun in meiner knappen Zeit/Energie die für das Wochenend geplante Offensive auf die Baumgeschichte vor.

Um ein Ziel zu haben, werde ich den Formelsprachecode erstmal in xml umwandeln. Dies hilft mir dann hoffentlich, um mir besser überlegen zu können, wie ich daraus LotusScript generiere. Wichtig ist erstmal, dass es in einer Baumstruktur ist.
Wenn das xml fertig ist, sollte es auch für aussenstehende verständlicher werden, wie ich das ungefähr vorhabe (auch die, die nicht so viel Erfahrungen mit xml haben).

Gruß Axel

[flaite]

Ganz gut, wobei ich deutlich langsamer vorankomme als ich gedacht habe.

noch langsamer. Jetzt schmeiss ich nochmal vieles um. Ich nähere mich aber eindeutig der Geschichte.

[flaite]

So. Zumindest das Erstellen eines Objektgraphen von Formelsprachen-Elementen aus einem Formelsprachen-Skript nähert sich der Fertigstellung.
Wie gesagt, hoffe ich dann, dass ich aus diesem Objektgraphen LotusScript generieren kann.

Wenigstens hatte ich ja jetzt ein bischen Zeit.
Ich hoffe, nächstes Wochenende code + antScript + Erläuterung posten zu können, das zumindest diesen Teil abdeckt.

Ich finds eigentlich ganz interessant. Sehr rekursiv. Ziel ist es OO so einzusetzen, dass die Algorythmen einfach bleiben. Dies scheint nun endlich zu gelingen.

Gruß Axel

[flaite]

ziemlich wirklich kompliziert.
Jedenfalls kann er jetzt schon Formulacode in eine Art Baum laden.

root = TRoot.getInstance("A:=@DbLookup(\"Notes\":\"NOCACHE\";\"\":\"\";\"($aaa)\";\"AToc\";\"ATitle\");"
      + "_Application:= @If( @IsError(_A);@Failure(\"Fehler Meldung !\");_A);");

Ergibt so eine Objektstruktur:
Die Striche heissen immer istKindVon.

de.aja.formulatols.TRoot
--de.aja.formulatols.TVariable(name=a)
----de.aja.formulatols.TFdblookup
------[TUnknown: rawContent: "Notes":"NOCACHE"]
------[TUnknown: rawContent: "":""]
------[TUnknown: rawContent: "($aaa)"]
------[TUnknown: rawContent: "AToc"]
------[TUnknown: rawContent: "ATitle"]
--de.aja.formulatols.TVariable(name=_application)
----de.aja.formulatols.TFif
------de.aja.formulatols.TFiserror
--------[TUnknown: rawContent: _a]
------de.aja.formulatols.TFfailure
--------[TUnknown: rawContent: "Fehler Meldung !"]
------[TUnknown: rawContent: _a]

Beispiel:
Die Variable mit dem Namen _application hat ein Kind TFif
 TFif hat ein Kind TFisrror
  TFiserror hat ein Kind TUnknown (er kann noch keine Variablenreferenzen)
 TFif hat ein weiteres Kind TFfailure
   TFif hat ein Kind TUnknown (er kann noch keine String-Literale)
 TFif hat ein Kind TUnown (er kann noch keine Variablenreferenzen)

Alles ziemlich rekursiv, weshalb ich oft vor dem Debugger gerätselt habe.

Ich werde jedenfalls daran weiterarbeiten, obwohl ich es nicht einfach finde, daraus dann noch LotusScript code zu erzeugen. Zumindest versteht er jetzt die Struktur.
Ich teste das mit ein bischen Formelsprachecode den ich finde. Möglicherweise frag ich nochmal nach Formelsprachencode an.

Ich werde irgendwann in den nächsten Wochen den code mit Installationshilfen (vermutlich Ant) sowie Anweisungen wie-man-das-in-Eclpse-importiert (oder per Ant automatisiertes Skript dafür) posten. Man muß dafür nicht ant verstehen.

Gruß Axel

[flaite]

So. Die noch fehlenden Punkte (Erkennen von Literalen, Listen und Referenzen auf Variablen) sind jetzt implementiert:

Mit obigen Input, erhalte ich nun diesen Baum:
Man sieht, dass die Listen korrekt da sind, die Referenzen auf Variablen (die _a) sich auf die korrekte Variable referenzieren (tokenId) und Literale sind auch da.

de.aja.formulatols.TRoot
--de.aja.formulatols.TVariable(name=_a, tokenID=00000001)
----de.aja.formulatols.TFdblookup
------de.aja.formulatols.TList
--------[TLiteral: rawContent: Notes]
--------[TLiteral: rawContent: NOCACHE]
------de.aja.formulatols.TList
--------[TLiteral: rawContent: ]
--------[TLiteral: rawContent: ]
------[TLiteral: rawContent: ($aaa)]
------[TLiteral: rawContent: AToc]
------[TLiteral: rawContent: ATitle]
--de.aja.formulatols.TVariable(name=_application, tokenID=00000002)
----de.aja.formulatols.TFif
------de.aja.formulatols.TFiserror
--------[TVariableRef: idRef: 00000001]
------de.aja.formulatols.TFfailure
--------[TLiteral: rawContent: Fehler Meldung !]
------[TVariableRef: idRef: 00000001]


Wer will, kann mir jetzt ein bischen Formelsprachen Code schicken. Gerne auch echt komplexe Formelsprachen-Skripte, um die Robustheit zu testen.

Noch nicht implementiert sind die Operatoren + und - (ist aber jetzt nicht mehr so schwierig).
sowie Listenoperatoren wie *= (das ist vermutlich schwierig)

Den bisherigen Source Code poste ich in den nächsten Wochen (nicht gut dokumentiert und ein paar Ecken und Kanten).
Es ist quasi gar nicht auf Performance hin programmiert. Dauert jetzt mit ein paar unnötigen System.out.println und unglauuuublich vieler Log Statements 1.4 Sekunden für dieses kleine Skript. Auf der anderen Seite braucht man für diese Aufgabe keine überragende Performance.
Aber es hat z.B. jedes Element seinen eigenen Parser und Sachen werden je nach Schachtelungstiefe mehrfach geparsed. So bleibt aber der code irgendwie auch konsistent und angesichts der Komplexität der Aufgabe übersichtlich.

Axel

Gruß Axel

[Thomas Schulte]

Schaun wir mal was er da draus macht.
REM {fetch the base definition field that is drawn with the creation of the form};
REM {check if there are field in this form and if the definition for using readers and authors fields is set to YES};
REM {the ~~ separates the fieldnames. & is the prefix for a field and the rest is text};
_ReadersBaseExploded := @Explode(SetReaders;"~~");
@If(@Elements(_ReadersBaseExploded) = 0; @Return(""); "");
@If(@UpperCase(@DbLookup( "" : "NoCache" ; "":"" ; "($LUConfig)" ; "LOCKDOCUMENTSGENERAL" ; 2;[FailSilent] ))!= "YES";@Return("");"");
m := 1;
_StringConcat := "";
@DoWhile(
_StringLineConcat := "";
_StringLineConcat:=@If(
@Left (_ReadersBaseExploded[m];1)="&";
@Implode(@Name([Canonicalize];@GetField(@Middle(_ReadersBaseExploded[m];1;@Length(_ReadersBaseExploded[m]))));"~~");
_ReadersBaseExploded[m]);
_StringConcat := @If(_StringConcat ="";@If(_StringLineConcat= "";"";_StringLineConcat);@If(_StringLineConcat= "";_StringConcat;_StringConcat + "~~" +_StringLineConcat));
m := m + 1;
m <= @Elements(_ReadersBaseExploded)
);
@Unique(@Explode(_StringConcat;"~~"))

[Thomas Schulte]

Oder daraus:
REM {*** begin of head ***};Title_ := "Grußformel wählen";Message := "Mit welcher Grußformel am Schluß sollen Briefe und Faxe erstellt werden?";MessageNotFound1 := "Fehler: Ein Schlüsselwortdokument für die Gruppe ";MessageNotFound2 := " wurde in der Einstellungen-Datenbank nicht gefunden.";KeyGrp := "Address Letter Close&";FieldName := "LetterClose";FieldCont := LetterClose;Tasks := "Prompt" : "PromptErrors";Language_ := Language;REM {*** end of head ***};List := "";@If(!@IsDocBeingEdited; @Command([EditDocument]); "");REM {2. build name of setup-db};ThisPathFile := @Subset(@DbName; -1);LenPathPC := @Length(@LeftBack(ThisPathFile; "\\"));LenPathMAC := @Length(@LeftBack(ThisPathFile; ":"));LenPathUNIX := @Length(@LeftBack(ThisPathFile; "/"));LenPath := @If(LenPathPC > LenPathMAC; @Max(LenPathPC; LenPathUNIX); @Max(LenPathMAC; LenPathUNIX));Path := @If(LenPath = 0; ""; @Left(ThisPathFile; LenPath + 1));KeyDB_ := @Subset(@DbName; 1) : (Path + "ge_keys.nsf");REM {X language translation because of notes bug};LanguageTrans := "";@Set("LanguageTrans"; @DbLookup(""; KeyDb_; "(KeywordsNotUTD)"; "Language"; "KeyMerge"));@Success;@If(!@IsError(LanguageTrans); ""; @Set("LanguageTrans"; @DbLookup(""; KeyDb_; "(Keywords)"; "Language"; "KeyMerge")));@Success;@Set("Language_"; @Replace(Language_; @Word(LanguageTrans; "|"; 1); @Word(LanguageTrans; "|"; 2)));REM {6. get keywords with double lookup language dependent};View2 := @If(@Ends(KeyGrp; "*"); "(KeywordsCat)"; "(Keywords)");LookType := @If(@Ends(KeyGrp; "*"); "" : "NoCache"; "");@Set("List"; "");@Set("List"; @DbLookup(LookType; KeyDb_; "(KeywordsNotUTD)"; KeyGrp + SelectionCat + Language_; "KeyMerge"));@Success;@If(!@IsError(List); ""; @Set("List"; @DbLookup(LookType; KeyDb_; View2; KeyGrp + SelectionCat + Language_; "KeyMerge")));@Success;REM {7. get keywords with double lookup language independent};@If(!@IsError(List) | (Language_ = ""); ""; @Set("List"; @DbLookup(LookType; KeyDb_; "(KeywordsNotUTD)"; KeyGrp + SelectionCat; "KeyMerge")));@Success;@If(!@IsError(List) | (Language_ = ""); ""; @Set("List"; @DbLookup(LookType; KeyDb_; View2; KeyGrp + SelectionCat; "KeyMerge")));@Success;REM {8. test error};@If(!@IsError(List); ""; Tasks = "PromptErrors"; @Prompt([Ok]; Title_; MessageNotFound1 + @Trim(KeyGrp + " " + Language_) + MessageNotFound2) + @Return(""); @Return(""));REM {9. take default list or list};Delim := @Member("--DEFDELIMITER--"; List);@Set("List"; @If(Tasks = "DefaultList"; @If(Delim > 1; @Subset(List; Delim - 1); ""); Delim < @Elements(List); @Subset(List; Delim - @Elements(List)); ""));REM {11. ask for keywords};Choice := @If(!(Tasks = "Prompt") | (@Elements(List) <= 1); List; @Prompt(@If(Tasks = "MultiValue"; [OkCancelListMult]; [OkCancelList]); Title_; Message; FieldCont; List));@If(@IsNumber(Choice); @Return(""); "");@Set("List"; Choice);REM {15. set keywords to field};@If(Tasks = "Return"; @Return(List); @SetField(FieldName; List));

[flaite]

thx.

[eknori]

Nimm dies 

REM { --- this action button filters a view based on the user's input --- };

tmpVName := @Subset( @ViewTitle; -1 );
@If( tmpVName = "";
   @Return( @Prompt( [Ok]; "Warning"; "This only works when a database
is opened to a view.") );
   @Success );
tmpCol := 1;

REM { produce a list of categories from the current view };
tmpList := @Unique( @DbColumn( "":""; "":""; tmpVName; tmpCol ) );

REM { handle common errors -- reset filtering in an inappropriate view };
warningText := "This action only works in a categorized view where the category
is the first column." + @Char(10) +
  "This will not work in a flat view or in a view where the first column is not
the category";
@If( @IsText( tmpList[1] );
   @Success;
   @Do( @SetViewInfo( [SetViewFilter]; ""; ""; 1); @Return( @Prompt(
[Ok]; "Warning"; warningText ) ) ) );

REM { Let the user pick one category };
tmpChoice := @Prompt( [OkCancelCombo];
"Select a Category for Filter"; "This will filter the view to a single
category." + @Char(13) + "   (specify blank for all)";
""; "" : tmpList );

REM { reminder: expand the view or it may appear empty };
@Command( [ViewExpandAll] ) ;

REM { Set the filter (or clear the filter) };
tmpCName := "sPOAreaName";
@SetViewInfo( [SetViewFilter]; tmpChoice; tmpCName; 1 )

[flaite]

Ich lösch die Rems (hab ich vergessen).
Aufgrund der Nachfrage, muß ich jetzt erstmal eine kleine Fileimporter-Methode schreiben (ok. nicht schwierig). Sonst muß ich die ganzen " escapen und den String zusammenschrauben.

[flaite]

Ok. Leider passt der Spruch "Next batter, please" heute nicht so ganz hundertprozentig 

Aber ok:

Thomas erstes Skript ergab dieses Ergebnis:

EDIT: Neuer Code nachdem ich die fehlenden Formeln als Klassen hinzugefügt habe.

de.aja.formulatols.TRoot
--de.aja.formulatols.TVariable(name=_readersbaseexploded, tokenID=00000001)
----de.aja.formulatols.TFexplode
------[TUnknown: rawContent: setreaders]
------[TLiteral: rawContent: ~~]
--de.aja.formulatols.TFif
----de.aja.formulatols.TFelements
------[TVariableRef: idRef: 00000001]
----de.aja.formulatols.TFreturn
------[TLiteral: rawContent: ]
----[TLiteral: rawContent: ]
--de.aja.formulatols.TFif
----de.aja.formulatols.TFuppercase
------de.aja.formulatols.TFdblookup
--------de.aja.formulatols.TList
----------[TLiteral: rawContent: ]
----------[TLiteral: rawContent: NoCache]
--------de.aja.formulatols.TList
----------[TLiteral: rawContent: ]
----------[TLiteral: rawContent: ]
--------[TLiteral: rawContent: ($LUConfig)]
--------[TLiteral: rawContent: LOCKDOCUMENTSGENERAL]
--------[TUnknown: rawContent: 2]
--------[TUnknown: rawContent: [failsilent]]
----de.aja.formulatols.TFreturn
------[TLiteral: rawContent: ]
----[TLiteral: rawContent: ]
--de.aja.formulatols.TVariable(name=m, tokenID=00000002)
----[TUnknown: rawContent: 1]
--de.aja.formulatols.TVariable(name=_stringconcat, tokenID=00000003)
----[TLiteral: rawContent: ]
--de.aja.formulatols.TFdowhile
----de.aja.formulatols.TVariable(name=_stringlineconcat, tokenID=00000004)
------[TLiteral: rawContent: ]
----de.aja.formulatols.TVariable(name=_stringlineconcat, tokenID=00000005)
------de.aja.formulatols.TFif
--------de.aja.formulatols.TFleft
----------[TUnknown: rawContent: _readersbaseexploded[m]]
----------[TUnknown: rawContent: 1]
--------de.aja.formulatols.TFimplode
----------de.aja.formulatols.TFname
------------[TUnknown: rawContent: [canonicalize]]
------------de.aja.formulatols.TFgetfield
--------------de.aja.formulatols.TFmiddle
----------------[TUnknown: rawContent: _readersbaseexploded[m]]
----------------[TUnknown: rawContent: 1]
----------------de.aja.formulatols.TFlength
------------------[TUnknown: rawContent: _readersbaseexploded[m]]
----------[TLiteral: rawContent: ~~]
--------[TUnknown: rawContent: _readersbaseexploded[m]]
----de.aja.formulatols.TVariable(name=_stringconcat, tokenID=00000006)
------de.aja.formulatols.TFif
--------[TUnknown: rawContent: _stringconcat=""]
--------de.aja.formulatols.TFif
----------[TUnknown: rawContent: _stringlineconcat=""]
----------[TLiteral: rawContent: ]
----------[TVariableRef: idRef: 00000005]
--------de.aja.formulatols.TFif
----------[TUnknown: rawContent: _stringlineconcat=""]
----------[TVariableRef: idRef: 00000006]
----------[TUnknown: rawContent: _stringconcat+"~~"+_stringlineconcat]
----de.aja.formulatols.TVariable(name=m, tokenID=00000007)
------[TUnknown: rawContent: m+1]
----[TUnknown: rawContent: m<=@elements(_readersbaseexploded)]
--de.aja.formulatols.TFunique
----de.aja.formulatols.TFexplode
------[TVariableRef: idRef: 00000006]
------[TLiteral: rawContent: ~~]

Was mir noch aufgefallen ist:
TUnknown -> m+1,
und  TUnknown m<=@elements etc. sowie relativ weit oben = 0
sowas wie [failsilent]
Sowie die Arrays.

Das packt er noch nicht.