Lotus Notes / Domino Sonstiges > Java und .NET mit Notes/Domino

Formelsprache TO LotusScript Code-generierer schreiben

<< < (15/20) > >>

flaite:

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

--- Ende Zitat ---
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;"~~"))

Navigation

[0] Themen-Index

[#] Nächste Seite

[*] Vorherige Sete