Das Notes Forum

Lotus Notes / Domino Sonstiges => Java und .NET mit Notes/Domino => Thema gestartet von: flaite am 30.08.05 - 00:30:19



Titel: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 00:30:19
Hallo,

hat jemand dafür vielleicht irgendwelche verwertbaren Ansätze, Artikel, ähnlich geartete openSource Projekte oder Literatur?
Damit ich das direkt ein bischen schlauer anfange.
Oder gibt es sowas schon?
Da ich das relativ häufig machen muß, hab ich mir überlegt, dass eventuell zumindest teilweise zu automatisieren.
Naiv würde ich sagen, dass ich den Formelsprache rekursiv in immer kleinere Tokens zerlege und daraus mir dann LotusSkriptcode zusammenschreibe.
Ziemlich rekursiv und dann State Maschine und Command Pattern (das kann jetzt total danebenliegen, fiehl nur eben so ein).
Muß ja nicht direkt jeder Formelsprachen-Befehl umgewandelt werden. 
Aber schon allein die DB-Lookups wären eine echte Arbeitserleichterung.
Falls jemand Lust hat. In C# oder in Java.
Wenn Interesse, dann yes or no. Keine "Ich weiss nicht ob ich das kann"-Meldungen. Dann lache ich immer so hämisch. Das macht Falten im Gesicht...

Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 16:01:48
Evaluate  ;D ?

Im Ernst: Mit Evaluate müssten wenigstens die Lookups funktionieren.
Aber: Was ist denn das Ziel? Der User gibt @Formulas ein und Du wandelst diese dann um? Dann wären meine nächste Frage "wozu" und mein Statement zu den Usern: "Das müssen ziemlich fortgeschrittene User sein"
Oder geht es um eine Möglichkeit @Formulas in Deinen Skripten zu verwenden (Library?)

Mit Evaluate habe ich mal gearbeitet um einen Excel Import/Export Agenten zu schreiben (benutze Excel Zeile X mit Formel Y und berechne daraus Feld Z). Das hat bei wenigen Formeln gut und bei den meisten gar nicht funktioniert.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 16:04:53
OK, ich glaube ich beginne zu verstehen. Du willst KOMPLEXE Formulas in Skripten ausführen.

Dazu wäre mein Ansatz erst mal die Funktionen wenigstens zu wrappen.
Dann benötigt man einen Parser, der die Funktionen tranchiert. So erhält man einen Tokenarray, der dann an die Subfunktionen übergeben würde....

Habe leider gar keine Ahnung von Compilerbau - beim ersten Punkt wäre ich aber definitiv dabei.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 16:40:00
Doch so ungefähr. Mit den Tokens und Tranchieren sehe ich genauso.
Dann müssen die Tokens eben gruppiert, umsortiert und in LotusScript konvertiert werden.
Ich möchte Formelsprachencode reinkopieren und unten kommt Skriptcode raus.
Wenn ich an bestehenden Notes-Datenbanken arbeite, kommt es des öfteren vor, dass ich Formelsprachen-Code durch Skriptcode ersetzen zu müssen. Ich glaub Glombi hat sich einmal ähnlich ausgedrückt.
Ich hab nix gegen Formelsprache. Es ist einfach nur so, dass es Sinn macht, um eine Anwendung zu "konsolidieren", d.h. halbherzig implementierte Features rausschmeissen oder User-fähig zu machen. Es kommt dann oft vor, dass ich Skriptcode brauche. Z.B. ein Fall wo ein Feld des öfteren die 32-K (oder whatever) Grenze überschreitet. Dieses Feld wird leider von ca. 9 verschiedenen Skripten in Formelsprache oder LotusScript gefüllt (nicht übertrieben). Ich möchte das Feld ab einer bestimmten Größe auf 2 oder mehr Felder aufteilen (Adressen, Adressen_1, etc.). Dafür muss ich aber den Prozess managen und dafür möchte ich erstmal allen Code, der dieses Feld füllt oder verändert in Skript umwandeln.
Ein anderer Fall für diesen Formelsprache-zu-Skcript-Prozess ist RichText-Handling. Das wurde früher oft mit Formelsprache gemacht. Aber seid Domino6 gibt es da offenbar stabil funktionierende Klassen. Dort wäre ich mit Skript auch flexibler.

Ziel ist es so ein (ein bischen anonymisiertes) Skript einzugeben:
Code:
_A := @DbLookup("Notes":"NOCACHE";"":"";"($aaa)";"AToc";"ATitle");
_Application:=@If(@IsError(_A); @Failure("Fehler Meldung !"); _A);
_B := @DbLookup("Notes":"NOCACHE";"":"";"($AVIEW)";"ADOC";"Admin");
_Server := @Name([Abbreviate];@Subset(@DbName;1));
_DB := @ReplaceSubstring( _B;"@CurrentServer";_Server);
_DbView := "($Server)";
_DbKey := _Application + "@CurrentServer";
_Res:= @DbLookup("": "NoCache"; "":_DB; _DbView; _DbKey; 2);
_Server1 := @Subset(@DbName;1);
_Fields := @ReplaceSubstring( _Res;"@CurrentServer";_Server1);

_SerienbrDB := @Left(@Right(_Fields;"||aDB#"); "||");

_DataFormulare := @DbLookup("": "NoCache"; "": _DB; "(aView)"; "A DB" ; "DataBerichte");

@If(@IsError(_DataFormulare) | _DataFormulare = "";@Do(
@Prompt([OK];"Fehler";"a meldung.");
@Return("")
);
"");
_EleFormular := @Sum(@DbLookup("": "NoCache"; "": _DB; "(aView)"; "AnDB" ; 2));
@If(_EleFormular > 1; @Do(
@Prompt([OK];"Fehler";"kind of meldung.");
@Return(""));
"");

_SerienFormulare := @Explode(@Left(@Right(_DataFormulare;"||BerichteFormulare#"); "||"); "$");

_a1 := @Left(@Right(_DataFormulare;"||Name1#"); "||");
_a2 := @Left(@Right(_DataFormulare;"||Name2#"); "||");

_SerienFormulare3 := @Explode(@Left(@Right(_DataFormulare;"||BerichteFormulare3#"); "||"); "$");

_Maske_1 := _Maske_1;
_Maske_2 := _Maske_2;

_Aktionen := _SerienFormulare3;
_antwort := @If( @Elements( _Aktionen ) = 1; _Aktionen; @Prompt([OKCANCELLIST] : [NoSort]  ; "Ausführen von" ; "Bitte wählen sie ..." ; @Subset(_Aktionen ;1) ; _Aktionen ) ) ;
@If(_antwort = _a1;
     @Do(
             @Set("_Maske_1";@Left(@Right(_DataFormulare;"||Maske1#"); "||"));
             @PostedCommand([FileOpenDatabase]; "" : _SomeDB ; "(Mainnavigator)" ; "" ; "" ; "");
             @PostedCommand([Compose];  "" : _SomeDB ; _Maske_1)
                );
_antwort = _a2;
     @Do(
             @Set("_Maske_2";@Left(@Right(_DataFormulare;"||Maske2#"); "||"));
             @PostedCommand([FileOpenDatabase]; "" : _SomeDB ; "(Mainnavigator)" ; "" ; "" ; "");
             @PostedCommand([Compose];  "" : _SomeDB ; _Maske_2)
                );
"")
Und daraus LotusScript Code erzeugen.
Oder zumindest Teile davon übersetzen. Der Rest bleibt in Formelsprache stehen. Da ich das sowieso übertragen muß. Wäre zumindest eine Arbeitserleichterung.

Ich find das eine interessante Aufgabe.
Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 17:01:10
Die Tokens einsammeln und daraus einen Tree aus Command Objekts bauen. (Composite-Pattern + Command Pattern). 
http://www.dofactory.com/Patterns/Patterns.aspx


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 17:02:03
OK. Solche Skripte sind die Hölle. Wobei ich mich immer frage: Wer schreibt so etwas?

Wie aber geht man da vor? Keine Ahnung ???

Die Schwierigkeit beginnt ja beim Auslesen der Token...@x(parameter1(@Y(p2;p3;@Z(p4))))
Ein wenig Orientierung geben ja die Klammern - vielleicht wäre dies ein allererster Ansatz zur Zerlegung.

Irgendwan habe ich mal BNF lernen müssen...das kommt mir gerade hoch, wenn ich an syntaktische Token denke.

Wie ist der Syntax von Formelsprache?
Entweder eine Variablen/Feldzuweisung - oder ein Select - oder ein Semikolon - oder eine @Funktion. Korrekt?

Dann müsste man den Syntax der einzelnen Elemente identifizieren.
Auf jeden Fall würder man vermutlich sehr sehr viel über @Formulas lernen. Wozu das auch immer gut sein sollte ;)


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 17:04:25
Genau, ein Tree zum Sammeln der atomischen Tokens wäre richtig.
Das macht die Sache auch vom Verfahren her einfacher:
Der gesamte Baum wird bei Root, also der Gesamtformel beginnend, schrittweise aufgeteilt - bis die Knoten nicht mehr differenzierbar sind.
Dann wird von den Knoten aus das Script erzeugt - also genau der entgegengesetzte Vorgang gestartet.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 17:09:03
Formelsprachenkenntnisse hab ich genügend.
Das Ende vom nächsten Token hängt vom Kontext ab.
Kann Klammer sein oder ein Semikolon.
Manches muß umgruppiert werden (im Tree). Die Parents im Tree rufen jeweils die Kinder auf. Das muss irgendwie gehen.

Für sowas wie @Explode gibt es kein direktes Äquivalent in Skript. Aber ich hab für sowas SkriptLibraries, die das abbilden.
Ich sag nicht, dass das einfach ist. Aber ich halte es irgendwie für schon machbar.

Axel   


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: eknori am 30.08.05 - 17:11:06
Zitat
Für sowas wie @Explode gibt es kein direktes Äquivalent in Skript

Kommt auf die Version an; in ND6 SPLIT


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 17:15:05
Mit den Klammern als Kennzeichen meinte ich: Eine Funktion mit Parametern beginnt stets mit einer öffnenenden Klammer und endet mit einer schliessenden. Dazwischen müssen alle Klammern die geöffnet werden auch geschlossen werden. Sobald also [Anzahl öffnender Klammern]-[Anzahl schliessender Klammern]=0 ist die Funktion beendet - und der Inhalt zwischen ( und ) kann weiter aufgelöst werden.

Weiterhin bekannt ist, dass zwei Funktionen/Zuweisungen/Anweisungen/... immer mit Semikolon getrennt werden. Für weiteres muss dann tatsächlich der Kontext bemüht werden - was bei Dingern wie Picklist - mit sehr vielen Parametern  - zumindest aufwändig sein kann.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 17:24:19
Attraktiv finde ich:
- ich kann es direkt sinnvoll einsetzen
- ich kann nach dem "Scharping-Prinzip" vorgehen: laaannngsam. Dh. muss nicht alles direkt fertig sein, damit es einen Nutzen stiftet. Wenn der Teile des Formelsprachencodes stehen lässt und z.B. erstmal nur die DBLookups konvertiert ist es besser als vorher.

Ich glaub ich fang am WE an. Oder vorher. Ist aber schwierig vorher anzufangen. Sobald ich was habe, poste ich.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 17:24:35
Genau: Formeln lassen sich wie folgt aufteilen: In einen Array aus Trees.

Ist keine Klammer mehr zu schliessen ergibt ein Semikolon einen neuen Tree.

Im ersten Schritt müsste also nach dieser Regel ein Array von Root-Knoten erzeugt werden, die dann separat aufzudröseln sind.

Problematisch ist auch der Kontext einer Formula - je nach Ort des Auftretens ist da ein anderer ScriptCode zu erzeugen.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 17:27:21
Ich brauche ich bruache für den ganzen Tree EINEN Einstiegspunkt. Ist aber egal. Dieser eine Einstiegspunkt hat dann eben eine List aus dem was du meinst.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 17:48:59
Also ein Array hat - gegenüber einem 'normalen' Tree den Vorteil, dass er sortiert ist - was bei der Reihenfolge der Auswertung ja nicht ganz unwichtig ist.
Ausserdem - und viel wichtiger - entspricht das meiner Meinung nach eher dem, was eine Formel darstellt: Eine Reihe von Trees - letztendlich durch Semikolon getrennt (wenn keine Klammer zu schliessen ist).

Einen solchen Array mit Einstiegsknoten erhält man - z.B. so: (entnommen einem Button, der ein Feld namens Formula zerlegt).

   Dim formula As String
   Dim openBrackets As Integer
   Dim closedBrackets As Integer
   Dim stringPointer As Integer
   Dim TreeArr() As String
   Redim TreeArr(0)
   Dim cursor As String
   Dim token As String
   
   Dim uwo As New NotesUIWorkspace
   Dim udo As NotesUIDocument
   Set udo=uwo.currentdocument
   
   formula=udo.FieldGetText("formula")
   
   For stringPointer=1 To Len(formula)
      cursor=Mid(formula,stringPointer,1)
      If Not (cursor=Chr(10) Or cursor=Chr(13)) Then 'ignore
         If cursor=";" Then
            If openBrackets=closedBrackets Then
            'Token complete
               Redim Preserve TreeArr(Ubound(TreeArr)+1)
               treeArr(Ubound(TreeArr)-1)=token
               token=""
            Else 'still open brackets
               token=token+cursor
            End If
         Elseif cursor="(" Then
            openBrackets=openBrackets+1
            token=token+cursor
         Elseif cursor=")" Then
            closedBrackets=closedBrackets+1
            token=token+cursor
         Else
            token=token+cursor
         End If
      End If
   Next

Nur als Beispiel - ziemlich ungetestet und ungeschönt.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 17:51:46
Diese Trees müssen nun weiterverarbeitet werden - hierbei beginnt dann wohl die Arbeit...


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 18:14:08
Sehe ich nicht so. Das sind spezielle Commands mit einem gemeinsamen Command Interface.

Code:
Class CommandDBLookupSingle implements CommandLotusScriptGenerator {
 
// die alle mit set und get
StringBuffer tempDoc;
StringBuffer dbVariable;
StringBuffer vwVariable;
StringBuffer docKeyVariable;
StringBuffer fieldVariable;
StringBuffer resValue;

// in Interface definiert
public StringBuffer execute() {
   StringBuffer retVal = new StringBuffer(60);
    retVal = tempDoc.append("=").append(dbVariable).append(".getDocumentByKey(").append(docKeyVariable).append()).append("\n")
.append(resValue).append("=").append(tempDoc).append("getItemValue(").append(fieldVariable).append(")").append("(0)");
}
}
Ziemlich naiv. Aber so die Richtung. Für jeden Formelsprachenbefehl muss man natürlich mehrere Command-Objekte erstellen.

Axel
 


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 18:35:06
Was meinst Du mit 'Sehe ich nicht so'?

Dass es viel Arbeit ist?


Und: Planst Du die Umsetzung in Java (was ist mit Frontend Befehlen) oder in Script?

UND: Vermutlich sitzt/sass bei IBM jemand, der genau sowas für die Eclipse Plattform geschrieben hat...aber an den Code werden wir in diesem Leben vermutlich nicht mehr rankommen...


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 18:40:30
Wieso ich fang an das in Java zu schreiben. Wenn man komplett jeden @Befehl unterstützen soll ist es komplex, aber so kann ich erstmal anfangen.
Falls sich das als tragfähig erweist, kann das dann auf eine openSource Plattform getan werden und andere können - wenn sie wollen - die Lücken füllen. Glaub nicht, dass IMG daran kommerzielles Interesse hat. Mehr will ich nicht. Für mich ist das auch erstmal keine Arbeit sondern Training.
So etwas fehlt mir eben.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 18:43:40
Dafür eine praktisch umgesetzte architektonische Basis zu schaffen ist ja auch keine stumpfsinnige Sklaventätigkeit, sondern eigentlich ganz interessant.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: eknori am 30.08.05 - 18:45:43
sehr interessantes Thema; leider raucht mir schon der Schädel, wenn ich _retVal:=@if(@Command([CN];@UserName)="Hein Bloed";1;2) tokenized in Script umsetzen muesste.
Und an verschachtelte @IF möchte ich erst gar nicht denken ...

Die Umsetzung ist sicherlich möglich, da es sich "nur" um String Operationen handelt ( das kann Notes ja bekanntlich ). Ob der Aufwand aber in Relation zum zu erzielenden Erfolg steht wage ich zu bezweifeln.

@Gandhi: wie behandelt denn dein Code mein Beispiel ? Als Ergebnis erhalte ich @if(@Command([CN];@UserName)="Hein Bloed";1;2) zurück; und jetzt ?



Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 18:48:49
Ob der Aufwand aber in Relation zum zu erzielenden Erfolg steht wage ich zu bezweifeln.

Dir fehlt einfach der Glauben an die Kraft und Reinheit der GOF Design Patterns, Ulrich.

(http://www.corazones.org/maria/z_coraz_trasp_mv.jpg)


 ;D


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: koehlerbv am 30.08.05 - 18:56:17
Als Ergebnis erhalte ich @if(@Command([CN];@UserName)="Hein Bloed";1;2) zurück; und jetzt ?

Und das Ergebnis müsste ja eigentlich lauten: "Syntax error !"  ;D

Ich halte das Thema auch für hochinteressant - aber eher theoretischer Natur. Das Vorgehen bei @functions und mit LS ist ja teilweise ein völlig anderes, und ein pures Umsetzen von @functions nach LS erscheint mir zweifelhaft. @functions habe ihre Welt (und lassen sich teilweise durch LS überhaupt nicht ersetzen), und LS hat eben einen ganz anderen Hintergrund. Ein derart automatisch umgesetzter Code waäre auf jeden Fall alles andere als optimal.

Weiterhin: Warum soll neben @functions (source code) und LS (target code) noch eine weitere Sprache (und System) (Java) zum Tragen kommen ?

Bernhard


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 19:03:30
@Bernhard: Syntaxüberprüfung ist definitiv gar nicht drin ;)
@Eknori: Genau das soll es auch ;)

Wie gesagt: Jede einzelne Anweisung wird erst mal in einen neuen Tree umgewandelt - der im ersten Schritt eben Deine gesamte Formel ist, da sie aus nur einer verschachtelten Anweisung besteht.

Bsp.:
_Field feld:=feld;  ==> erster Tree
_retVal:=@if(@Command([CN];@UserName)="Hein Bloed";1;2)  ==> zweiter Tree
_b:=@if(cond1;@if(cond2;@if(cond3;.....==>dritter Tree

jeder Tree muss dann baummässig soweit aufgesplittet werden, bis nichts mehr geht - und die Blätter/Endknoten dann in Script übersetzt und zusammengebaut werden.
Die Sache mit dem Array von Trees hat meiner Meinung nach den grossen Vorteil, dass die Reihenfolge nicht verloren geht.

Um das Ergebnis zu erhalten, dass Du gerne hättest, Ulrich, vergeht sicher noch ein wenig Zeit.

Insgesamt ist es aber aufgrund des relativ klaren Syntax (Tokentrennung) vermutlich relativ einfach Formulas so zu zerlegen (ganz im Gegensatz zu LotusScript - wo so eine schöne Trennung mittels klar definierter Zeichen und simplen Regeln fehlt)

Das Hauptproblem sehe ich in der (Deppenarbeit) alle Formeln umzusetzen - und in der Kontextabhängigkeit von Formeln. FormelAgents umzusetzten ist sicher gar kein Problem, was aber macht man z.B. mit Wertformeln.
Ich will mich daher auf Agenten beschränken - und hier kann man das ruhig auch in Java machen - wobei man sich damit - zunächst (bis zur Eclipse Plattform) einiges verstellt.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 30.08.05 - 19:14:56
Aber das gibt tatsächlich Probleme ohne Ende...

Angenommen:

Am Ende eines Baumes steht: 1:2:3:4
Also ein Integer Array.
Das muss man erst identifizieren bevor man es weiterverarbeiten kann.

Und selbst bei einer Beschränkung auf Agenten gibt es ja solche, die auf alle Dokumente der DB wirken, solche, die auf eine Auswahl wirken und solche, die auf keine speziellen Dokumente wirken. Also 3 verschiedene Scripte je nach Agenteneinstellung...


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: eknori am 30.08.05 - 19:32:09
Zitat
Syntaxüberprüfung ist definitiv gar nicht drin

Doch, wo .ohl, siehe !!HELP!! Projekt  :D

und bitte nicht mit Heiligenbildchen kontern ... ;D


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 22:21:48
und bitte nicht mit Heiligenbildchen kontern ... ;D
Das ist kein Heiligenbildchen. Auf dem schönen Bild ist eindeutig die Jungfrau Maria zu sehen.

Aber jetzt mal im ernst. Ich schaue mir das einfach mal an wie weit ich komme. Der Rest ist eh Spekulation. Bisher sind aus meiner Sicht noch keine besonders gewichtigen Gegenargumente gekommen. Ausser, dass es sehr viel ist. Aber das habe ich ja auch schon gesagt.
Und ich habe auch gesagt, dass es mir schon ausreichen würde, wenn eine Teilmenge der Formeln übersetzbar wäre. Ich will aber ein System schaffen, dass komplexitätsmässig gut skalliert. Dh. dass es am Ende genauso einfach ist, eine zusätzliche Formel einzubinden wie am Anfang. Oder noch einfacher, weil das Framework besser ist. Aber erst am Wochenende, weil ich in meinem Tagesjob
- momentan auch eine sehr interessante Aufgabe habe: Allgemeines Generierungsverfahren einer XML Datei aus verschiedenen Notesanwendungen für XML-Beschreibungsdateien (unterschiedliche und änderbare Typen) und
- wir Anfang September ein Punktrelease haben und da sind noch issues auf der Liste.

Möglicherweise ist die Grundarchitektur relativ einfach und die explodierende Anzahl an in die Gesamtarchitektur problemlos einplugg-baren Klassen ist dann Fleißarbeit. Ich weiss es einfach noch nicht. Prognosen sind schwierig, vor allem wenn sie sich auf die Zukunft beziehen.
Naja. Ich werds mal anfangen.

@Gandi: Ich würd keine Arrays nehmen, sondern List, bzw. als konkrete Klasse wohl java.util.ArrayList. Das Identifizieren ist kein Problem. Ich will die semantische Bedeutung quasi schon beim parsen klären (vereinfacht ausgedrückt). Aber das ist alles Spekulation.

Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 30.08.05 - 23:39:49
@Bernhard: einen Sinn hat das schon und ich hab das weiter oben gesagt: Ich arbeite öfters mit älteren Formelsprache-Code. Und da wurde Formelsprache in Kontexten verwendet, in denen wir heute Skript verwenden. Und das macht die Anwendungen schwer wartbar. Ich hab schon einige male per Hand bestehenden Formelsprachecode in LotusScript umgewandelt. Andreas G. (zu schwieriger Nachname) hat glaub ich auch mal erwähnt, dass er das gemacht hat. Oft ist der Kontext, in dem in bestehenden Anwendungen Formelsprache verwendet wird historisch gewachsen. Und dafür kann das hilfreich sein.
Es soll in keinem Fall eine Art Tool werden, mit dem Leute die "Formelsprache nicht können" Lotusscript generieren. Sondern es hat einen ganz klaren Fokus auf "Refaktorierung von Legacy Code".
Anwender brauchen Java nicht zu können. Ich kann da verschiedene Interfaces für bauen. Eine GUI, eine Webseite, Files, ein Webservice. Egal.
Anwender müssen natürlich Java können, um Arten von Formeln konvertieren zu können, die noch nicht unterstützt werden. Es gibt ja viele Formeln. Und da es explizit als Framework-Code gedacht ist, soll es relativ einfach sein Erweiterungen zu schreiben. D.h. es gibt einen gewissen Rahmen, auf denen die Klassen aufsetzen können.

Es gibt bestimmte prä-XHTML-parsing openSource Frameworks in Java, mit denen HTML Files geparsed und aus den einzelnen Tags ein Objektbaum generiert wird. Da könnte ich vermutlich einiges abkupfern.

Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: koehlerbv am 30.08.05 - 23:55:28
@Bernhard: Syntaxüberprüfung ist definitiv gar nicht drin ;)

Das war schon klar, Gandhi. Der von Dir gepostete Code war sehr gut lesbar  ;D Das war eher ein Joke auf Ulrichs Beispiel - und eigentlich nicht (ganz) ernst gemeint, da eine Validierung wohl dann die absolute Kür sein müsste (der zu übertragende Code sollte ja wenigstens schon mal lauffähig gewesen sein).

Bernhard


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: koehlerbv am 31.08.05 - 00:13:05
Völlig ohne Frage, Axel. Ich habe es logischerweise auch mit Situationen zu tun, in denen "hysterisch gewachsener" Code mit @functions sinnvollerweise (weil @functions dort wegen fehlender Möglichkeiten / durchaus auch schlechter Wartbarkeit) durch LS ersetzt werden müssen.

Bisher bedeutete das nach meiner Erfahrung immer Situationen, in denen das ganze Herangehen auszutauschen war. Und an vielen Stellen sind @functions prinzipiell nicht austauschbar, weil technisch bedingt einfach nicht ersetzbar.

Weiterhin - und was ich schon einmal geschrieben habe: Wenn man @functions austauscht gegen LS, dann verfolgt man damit sinnvollerweise auch ein ganz anderes Konzept der Programmierung. Ich kann mir einfach nicht vorstellen, dass eine sture "Sprachkonvertierung" hier wirklichen Zugewinn generierert.

Als eine Art "Recompiler / Umsetzer" mit starkem Parser ist das Thema natürlich hochinteressant. Ich bezweifele nur den praktischen Nutzen. Ansonsten  würde ich mich da liebend gerne beteiligen (mein erstes "Projekt" war Mitte der 80er ein 6510 Assembler, der logischerweise erstmal in Maschinencode zu erstellen war, bis er selber "mithelfen" konnte, sich selber verbessern zu helfen).

Bernhard


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 31.08.05 - 06:55:52
... denke aber, dass auch wenn man nur Teile des Formelsprache-Code automatisch in LotusScript umwandelt, dann hat man eine Basis, mit der die Umstellung auf LotusScript einfacher ist. Das soll ja keine LotusScript Programmiermaschine ohne menschliche Interaktion sein. Man kann den generierten Code ja weiterverarbeiten.

Aber das sind eh alles erstmal ungelegt Eier.
Ich suche erst einmal nach openSource Projekten mit einer ähnlichen Aufgabe.
Bisher gefunden:
http://sourceforge.net/projects/htmlparser
FALLS JEMAND EINEN WEITEREN VORSCHLAG HAT, bitte posten.

Ich versuche dann Design-Prototypen zu erstellen. Sobald ich etwas habe, poste ich.

Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 31.08.05 - 10:32:43
Projekte dieser Art müsste es zuhauf geben - wenn man ein wenig weiter abstrahiert - denn es ist ja im Grunde nichts anderes als ein Compiler/Interpreter, der eine Sprache (Formulalanguage) in einen :)'Bytecode':) (Lotus Script) umwandelt ;D

Eigentlich ganz lustig aus psychologischer Sicht: Axel will aus Formula was Java-ähnliches machen (Bitte, bitte nicht ernst nehmen!). Über die Motivation will ich gar keine Vermutungen anstellen.

Zum Compiler/Parserbau müsste es doch eigentlich tonnenweise Literatur geben? Vielleicht hilft das weiter: http://de.wikipedia.org/wiki/Compilerbau


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 31.08.05 - 11:46:34
Ich glaub, dass es etwas anderes ist einen Kompiler für eine Programmiersprache zu schreiben, als eine Skriptsprache in die andere zu transformieren. Ausserdem habe ich nicht nach vielen Treffern sondern nach nahen Treffern gefragt.
Ohne jede gut/schlecht Wertung.
Bei Gandi scheint das manchmal nach dem alten kubanischen Sprichwort zu laufen:
El cubano comprende el mundo hablando.
Der Kubaner versteht die Welt, indem er redet.
Wobei ich mich da irgendwie auch nicht beschweren kann.  :-:


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 31.08.05 - 12:28:51
Zitat
Der Compilerbau (auch: Übersetzerbau) ist eine Disziplin der Informatik. Sie beschäftigt sich mit dem Entwurf und der Programmierung von Compilern, die einen Quellcode (ein meist in einer höheren Programmiersprache verfasstes Programm, also einen Quelltext) in einen Zielcode (meist eine weniger ausdrucksstarke Sprache, vorrangig Maschinensprache) umsetzen.
Ich finde, das passt sehr gut.

Und: wie soll ich wissen, was ich denke, bevor ich höre, was ich sage 8)

Have a nice day ;D


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 31.08.05 - 15:22:45
Bisheriges Zwischenergebnis der kollektiven Recherche:
- 1 openSource Projekt, an dem Joshua Kerevsky, mindestens 3 weitere Senior Java Entwickler und mehrere ungenannte Java Entwickler nach strengen Qualitätskriterien ca. 5 Mannjahre dran gearbeitet haben.
- 1 Wikipedia Eintrag bestehend aus ca 40 brillianten Worten von einem Typen aus dem Internet.



Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 31.08.05 - 16:24:54
Nun, wärst Du meinem Link gefunden, so hättest Du gefunden:

FLEX:http://www.gnu.org/software/flex/ Erzeugt ein Programm zur Trennung von Tokens - Voraussetzung: Lexik bekannt. Macht die halbe Arbeit. Ist vermutlich nicht in Java vorliegend.

Bison:http://www.gnu.org/software/bison/bison.html Erzeugt Parser (in C) nach Vorgabe der Grammatik.

Coco/R:http://www.ssw.uni-linz.ac.at/Research/Projects/Coco/ ist ein Compilergenerator - und fasst soz. die Funktion der beiden og. Tools zusammen. Dieser ist offensichtlich sogar unter Java verfügbar.

JavaCC:https://javacc.dev.java.net/ Vereint ebenso Parser und Scanner - ist in Java verfügbar - und wie alle o.g. mehr oder weniger Open Source.

Das alles stand in meinem geposteten Link - ich hoffe es wird nützlich sein.
Die Programme gehen sogar noch einen Abstraktionsschritt weiter: Sie erzeugen Programme, die Programme compilieren können (und auch wenn es Dir nicht gefällt: genau das hast Du vor - genauer: Du willst einen Transpiler)

Transpiler (wieder aus dieser Seite Wikipedia, wo sich Typen aus dem Internet in brillianten Worten verewigen):
Zitat
Transpiler (auch Transcompiler) übersetzen Quellcode einer Programmiersprache in den Quellcode einer anderen Programmiersprache. Zum Beispiel ist bei den .NET-Programmiersprachen von Microsoft eine Übersetzung von C# nach VB.NET relativ einfach, da beide Sprachen auf demselben Grundgerüst aufbauen (.NET-Framework).





Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 31.08.05 - 21:13:20
JavaCC ist sicherlich interessant. Glaub aber, dass es sicher zu komplex wäre, für das was ich vorhabe.
Wir brauchen ja keine komplexe Grammatik definieren. Formelsprache ist eigentlich einfach.
Ich parse NotesFormelCode.
Das nächste Token-Ende nach @ ist (.
Das nächste Tokenende nach ( ist ; , ),  bzw. @ oder [

Ich bin da auch kein Experte drin, aber ich versuch erstmal ein bischen weniger akademisch da dranzugehen. Vielleicht scheitert das.

thx Axel






Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: animate am 31.08.05 - 21:52:41
ich finde das ist ein sehr schönes Beispiel, um Test-Driven Development anzuwenden.

Einfach anfangen und langsam größer werden.

Siehe Bowling Kata von Uncle Bob (http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata) und Agile Software Development (http://www.amazon.de/exec/obidos/ASIN/0135974445/qid=1125517920/sr=8-1/ref=sr_8_xs_ap_i1_xgl/302-6031540-9890455) Kapitel 6

 :D


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: eknori am 31.08.05 - 21:55:58
Zitat
Das nächste Tokenende nach ( ist ;

und was ist bei strukturierten @IF ? Ohne eine Grammatik gehst du da auf die Bretter ...

TokenEnde kann immer nur ein ")" sein. Erst dann kannst du anfangen alles zwischen dem ( und dem ) aufzudröseln

Ach ja, das letzte Element in einer Formel muß nicht zwingend das ; sein.

"nicht akademisch" an die Sache heranzugehen halte ich für durchaus brauchbar; am Ende wirst du aber wieder bei den akademischen Lösungsansätzen enden  ...

Das Projekt ist interessant; allerdings kippt es bei der Kosten /Nutzen Rechnung eindeutig hin zu den Kosten.

Da bin ich eindeutig schneller, mir alle Formeln einmal anzuschauen, mir auf einen Blatt Papier zu notieren, was die so alles machen, mir ein Bier zu trinken und zu überlegen, wie ich die festgestellten Gemeinsamkeiten in eine LS Script Lib übertrage bevor ich mir Gedanken über ein Transpiler Building mache. Wie gesagt, ICH würde diesen Weg beschreiten; DEIN Weg ist ein anderer.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: koehlerbv am 31.08.05 - 22:25:45
TokenEnde kann immer nur ein ")" sein.

Nö. FIELD xyz := "Hier steht keine Klammer am Ende."

Nur so als Beispiel.

Ansonsten : Volle Zustimmung, Ulrich. Ich hatte das ja auch schon so ähnlich geschrieben: Aufwand / Nutzen steht für mich (! - persönliche Meinung !) in keinerlei Verhältnis. Parser / Converter oder wie auch immer zu schreiben, mache ich äusserst gerne (da kann man so richtig Grips 'reinstecken), aber - wenn erforderlich - stelle ich nicht so sonderlich wesensverwandte Programmiermethoden wie @functions und LS lieber manuell um.

Bernhard


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 31.08.05 - 22:51:07
(http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata) und Agile Software Development (http://www.amazon.de/exec/obidos/ASIN/0135974445/qid=1125517920/sr=8-1/ref=sr_8_xs_ap_i1_xgl/302-6031540-9890455) Kapitel 6
I second that a lot.  8)
Und so ist das auch richtig. Andere Leute finden vielleicht test driven development Unsinn oder theoretisch. Und dann sehen sie es vielleicht irgendwo. Und dann: Oh. Das ist aber sehr professionell. Man kann aber auch einfach irgendwann damit anfangen. Und dann ist es gar nicht so schwierig.

Wie definiert ihr den Begriff "Grammatik"?
Was ich skizziert habe, kann auch als eine Art Grammatik angesehen werden.
Eben eine agile Grammatik.

Ich find heute abend werden mal wieder ein paar sehr starke Aussagen getroffen bevor ich überhaupt angefangen habe.
Ich glaube: Die OOD gibt mir eine ausreichende Flexibilität, um ausreichend auf die variablen Fälle zu reagieren.
Ihr glaubt, das nicht.
Bevor ich nicht angefangen habe, wissen wir es einfach nicht.

Gruß Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Thomas Schulte am 31.08.05 - 23:15:12
Na wie wäre es dann wenn du tatsächlich einmal anfangen würdest?
Und die Ergebnisse hier auch präsentierst!
Deine Theorien hören sich ja immer gut an.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: koehlerbv am 31.08.05 - 23:20:51
Ich find heute abend werden mal wieder ein paar sehr starke Aussagen getroffen bevor ich überhaupt angefangen habe.
Ich glaube: Die OOD gibt mir eine ausreichende Flexibilität, um ausreichend auf die variablen Fälle zu reagieren.
Ihr glaubt, das nicht.
Bevor ich nicht angefangen habe, wissen wir es einfach nicht.

"Starke Aussagen" kamen hier bisher nur von Dir, Axel.
Und richtig: Bevor Du angefangen hast, wissen wir es nicht. Meine Erfahrungen (mit Dir) sagen mir aber, dass Du vielleicht anfängst, aber es nicht bis auf ein brauch-/ausbaubares Resultat bringen wirst.

Auf Grund entsprechender Erfahrungen würde ich mich in Dein Vorhaben auch dann einbringen, auch wenn ich es nach wie vor für nicht effizient halte. Aber das würde ich erst machen, wenn Du auf starke Aussagen starke Taten folgen lässt. Bisher sehe ich nur Schlagworte und heisse Luft.

Bernhard


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 31.08.05 - 23:51:44
Oha. Jetzt gehts wieder los.
Das mich Werturteile in jeder Form (Lob/Tadel) aus Internet-Foren nicht interessieren, dürfte ich inzwischen deutlich genug klar gemacht haben.  Ok. Es gelingt mir nicht immer emotional. Aber intellektuell auf jeden Fall. Ich mein jetzt damit nicht, dass ich mich intellektuell für überlegen halte oder so. Sondern ich relativiere einfach bestimmte Arten von Tadel oder Lob.
Wenn ich kein Sinn mehr in einer Arbeit sehe, breche ich sie ab.
Ich nehme sachliche Kritik durchaus zur Kenntnis, aber solche emotionale Kritik sicher nicht.
Und Bernhard: Ein solch autoritärer Tonfall, wie du ihn manchmal an den Tag legst, sehe ich nicht als Basis für eine Zusammenarbeit an. Wie bedeutsam du auch immer deinen Beitrag selbst einschätzt. Tue mir einen Gefallen und gewöhne dir bitte diese "immer nur" Sätze ab.
Ich bin hier nicht dafür, dass irgendjemand mich für gut, schlecht oder bescheurt hält sondern aus 2 gleichberechtigten Gründen:
- Weiterbildung (ich lerne hier eine Menge)
- Unterhaltung

Das hengstbissige Kollektiv möge sich zerstreuen.  ;D

@Thomas: Ich habe gesagt, dass ich am Wochenende anfange. Ich habe einen anstrengenden Job. (Was hier ja von den anwesenden Gurus auch immer gerne in Zweifel gezogen wird).
Axel




Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: koehlerbv am 01.09.05 - 00:38:52
Oha. Jetzt gehts wieder los.

Wieso ?

Und Bernhard: Ein solch autoritärer Tonfall, wie du ihn manchmal an den Tag legst, sehe ich nicht als Basis für eine Zusammenarbeit an.

Wo ?

Ich mache auch viele Dinge, die vielleicht nicht sofort (!) Nutzen bringen (und muss mich dann mit kaufmännischen "Grössen" herumschlagen, warum ich das getan habe). Man sollte auch viele Dinge tun, um zu lernen. Man sollte das dann aber auch zu Ende (oder zumindest weiter) bringen - vor allem, wenn man es öffentlich macht. Und Du bist hier schlicht der Weltmeister in
- Ankündigungen
- Paradigmenwechseln
- Wechselnden Identitäten im Sinne von An- und Abmeldungen

Bernhard

PS: Meine Meinung ist hier ausdrücklich meine private Aussage und stellt ebenso ausdrücklich nicht die Meinung des Moderatoren-Teams dar. Einen zweiten AtNotes-Account, bei dem sowieso jeder gleich schnallt, wer dahinter steckt, hielt ich dafür nicht erforderlich  ;D


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 01.09.05 - 07:16:10
Noch mal Leute: Ich verspüre überhaupt kein Bedürfnis mich hier irgendjemanden gegenüber zu beweisen. Ausser er zahlt mir Geld. Ich denke auch, dass sich im Laufe der Zeit einige Poster für meine Antworten bedankt haben.

Wenn ihr weiter über meine Person sprechen wollt, dann macht bitte einen neuen Thread auf.

Sätze wie ""Starke Aussagen" kamen hier bisher nur von Dir, Axel." empfinde ich als aggressiv. So jedenfalls meine Empfindungen. Ob dieser Satz nun wahr oder falsch ist, bitte in einem anderen Thread.

Ich hab natürlich eine manchmal große Klappe. Und gleichzeitig einen herausfordernden Day-Job. Letzteres passt natürlich überhaupt nicht zu meinem hiesigen Verhalten. Aber ich bin Katholik (light) und die glauben bekanntlich an Wunder.

Um den Zeitplan ein bischen transparent zu gestalten: Ich werde am Wochenende ein paar Dinge ausprobieren und die hier darlegen. Über Input freue ich mich natürlich auch, ausser es handelt sich um Diskussionen um mein verkommenes Wesen.  ;D
Dies ist zunächst auch erstmal als eine Bitte von den anwesenden Java Programmierern zu verstehen.

thx Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Thomas Schulte am 01.09.05 - 09:24:32
Ich bin garantiert nicht hengstbissig, Axel, nur habe ich im Projektbereich außer heiser Luft von dir bis jetzt noch nichts gesehen.
Sorry das ich das sage aber das ist einfach ein Fact.
Das du einen Stressjob hast glaub ich dir aufs Wort, das haben aber andere auch und die machen da nicht so ein Gedöns drum rum.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 01.09.05 - 12:07:25
Ich bin garantiert nicht hengstbissig, Axel, nur habe ich im Projektbereich außer heiser Luft von dir bis jetzt noch nichts gesehen.
Sorry das ich das sage aber das ist einfach ein Fact.
Da brauchst du dich nicht für entschuldigen, weil es mir ehrlichgesagt ziemlich egal ist.
In Zukunft werde ich in diesem Thread nur noch auf themenbezogene Postings reagieren.

Mein Job ist eigentlich nicht so stressig. Anstrengend ist Neugier und Job gleichzeitig. Ich bin lediglich darauf eingegangen, weil hier einige Herren mich als jemand bezeichnet haben, der keine praktische Arbeit hat. Und das ist einfach nicht wahr.
Ich würde mich insgesamt freuen, wenn ein bischen mehr auf Werturteile verzichtet würde. Ich nehms sowieso nicht so ernst.


Nicht themenbezogen sind:
- Diskussion über mich (immer gerne. Aber in einem anderen Thread).
- Allgemeine Diskussionen über Design Patterns, meine Arbeitsweise und ähnliches mehr. Könnt ihr natürlich in einem anderen Thread gerne machen.

Nach den ersten Designstudien mit Prototypen erhoffe ich mir sachdienlichen Input v.a. von Leuten mit einer gewissen Java-Erfahrung.   


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 02.09.05 - 00:30:44
Ok. Nach den zahlreichen Protesten, habe ich im Zug mal das wundervolle Rod Johnson Buch zur Seite gelegt (die klarste Darstellung über AOP-via-Interception, die ich je gelesen habe) und hab mal ein bischen angefangen rumzuprobieren.

Grundsätzlich:
-> wird der FormelspracheCode eingelesen und an eine Art Builder-Klasse weitergeleitet.
Diese BuilderKlasse orchestriert aus den einlaufenden Stream des Formelsprachen-Codes vermutlich über ein State-Pattern (vielleicht ein bischen übertrieben, Patternities) die Generierung der TokenKlassen. Aus den Tokens der Formelsprache mache ich ein gewaltiges Composite. Für jede Formel gibts eine oder mehrere ChildKlassen der Abstrakten Klasse NotesFormulaToken.
Erst wird der Formelsprachencode quasi in diesem NotesFormulaToken-Baum "aufgenommen". Gleichzeitig sollen die eine Methode execute haben zur "Wiedergabe" -> generieren von LotusScript Code.
Es wird sicher Probleme geben mit Kleinigkeiten. Vielleicht aber erweist sich dies aber als brauchbare Struktur. Dann müssen natürlich für jede Formel eine NotesFormulaToken Klasse geschrieben we. rdenWenn ich 30% habe und hier vielleicht noch jemand auch ein paar Klassen erstellt, hätte man schon mal eine Menge abgedeckt. Diese NotesFormulaToken Klassen zu schreiben sollte auch sehr einfach sein, wenn das einmal läuft. Dh Schema f. Falls es läuft können dann auch Leute, die ein egoistisches Eigeninteresse an dem System haben, ohne große Javakenntnisse zum Projekt beitragen.
 
Ich habe gute Gründe für dieses Projekt zumindest den IOCContainer von Spring zu verwenden. Damit ist das ein Spring-Projekt. Macht es einfacher.

Sollte ich die Basis haben, kann ich das als Eclipse Projekt verschicken (inklusive aller jars). Allerdings über Mail. Für hier könnte das u.U. zu groß werden.

Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 02.09.05 - 06:59:21
Falls jetzt jemand Agressionen bekommt, möge er sich einfach mal vorstellen, dass jemand der sich mit Patterns ein bischen auskennt (z.B. Thomal Völkl) durch diese paar Zeilen eine gewisse Vorstellung davon bekommt, wie ich mir das vorstelle und mich evtl. vor Fehlern warnen kann oder bessere Ideen hat.
Und dafür eignen sich Patterns eigentlich gut.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Mark³ am 02.09.05 - 08:46:15
bei der Thematik 'Formelsprache' fällt mir sofort Damien Katz ein. Vielleicht hat der eine gute Idee dazu?  O0


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 02.09.05 - 11:55:17
Sein blog ist nicht mehr. www.damienkatz.net
Weiss jemand, wo der ist ???
Am Ende hat er ja auch in den Kommentaren zu seiner tiefschürfenden Design-Patterns-global-Kritik nicht gerade sehr viel Zustimmung von Seiten seiner Leser erhalten. Ich teilte meine Verwunderung mit einigen langjährigen konstruktiven Vertretern besagter Community (Wild Bill, Jonovan, etc.)

Ich habe zur Zeit viel Spaß an der Entwicklung des Frameworks. Noch nie sind Zugfahrten so schnell vergangen wie heute und gestern. Ich sehe eine Chance, werde weiter berichten, habe aber bisher noch keinen Code, der irgendwie zur Klarheit beitragen könnte.

Axel 


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 03.09.05 - 08:48:28
Falls jemand sich für dieses Projekt interessiert:
Ich denke es ist einfacher den Source code zu verstehen als wenn ich hier darüber schreibe. Es werden Unit-Tests und Kommentare in nicht immer Oxford-konformen Englisch drin sein (erleichtert das Verständnis).
Wer sich also interessiert, der sende bitte eine Email an axel dot janssen BEI gmail Punkt com. Ich verschicke dann das Eclipse Projekt. Bei Bedarf auch anders, wüßte aber nicht warum.
Ich hoffe, dass ich am Ende dieses Wochenendes etwas einigermassen brauchbares habe.
Nochmal: Bin noch nicht 100 Prozent sicher, ob es so geht wie ich es mir vorstelle. Ich melde mich, über die Fortschritte. Sieht so aus als würde ich Java5 nehmen

Gruß Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 03.09.05 - 19:30:20
Ich habe nun in einer Art Vorverarbeitungsschritt Code, das einlaufende Formelsprachescript wie folgt verarbeitet:
- Es wird zerschnitten und in eine ArrayListe geschrieben (dynamischer Array). Die Regel ist, dass
bei ; getrennt wird, wenn dieses ; nicht
- innerhalb eines Stringliterals oder
- in einer Klammer steht.

Zusätzlich wird noch aller Whitespace ausserhalb von StringLiteralen entfernt und
alles ausserhalb von Stringliteralen toLowerCase gesetzt.

Um den Unit-Test zu zitieren:

Code:
AUS
input=_A := @DbLookup("Notes":"NOCACHE";"":"";"($aaa)";"AToc";"ATitle");
_Application := @If( @IsError(_A);@Failure("Fehler Meldung !");_A);

WIRD
res=[_a:=@dblookup("Notes":"NOCACHE";"":"";"($aaa)";"AToc";"ATitle");, _application:=@if(@iserror(_a);@failure("Fehler Meldung !");_a);]
Man beachte den Whitespace und das toLowerCase Zeugs.

Das kann natürlich nur ein vorbereitender, normalisierender Schritt sein.
Als nächstes geht es darum die einzelnen Formeln, Commands und Variablenzuweisungen sinnvoll in einen Objektbaum zu bringen, der das ganze verarbeitbar macht. Das ist der eigentlich schwierige Teil der Herausforderung und ich arbeite arbeitet daran. 

Im Namen von hilarious overengineering werde ich später noch das Filterzeugs hin zu Observer-Pattern refaktorieren. Ist aber erstmal nicht notwendig.

Melde das dann.

Verwendete Libraries: JDK1.4.1, junit


Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 04.09.05 - 07:46:38
Bisher haben sich 2 Interessenten gemeldet.
Einer der beiden meinte:
- Am Ende des Projektes endgültige Umsetzung sehen.
- Sehen wie ein erfahrener Entwickler an die Sache herangeht.

Weiss, dass das lieb gemeint war, halte mich nicht für blöd, habe wohl ein bischen Erfahrung, aber irgendwie halte ich mich auch nicht für Leonardo da Vinci. Es gibt massig openSource Projekte, in denen deutlich erfahrenere Softwareentwickler als ich arbeiten.

Und gerade jetzt läuft das Refactoring zum PreProcessing Formatierungsframework aus dem Ruder.  ::)

Und vielleicht ist auch der Prozess das eigentlich interessante (Weg) und nicht das Endergebnis (Ziel). Ich will hier keinen zu Mitarbeit verdonnern. Aber ich stelle es mir deutlich interessanter vor, wenn es eine Partizipation von Leuten gibt, ohne irgendwelchen Zwang auszuüben. Druck gibt es allenfalls auf mich, weil ich wäre openSores Captain, aber nur aus dem Grund, weil ich das eben initiiert habe.

Die Source Files per Email rumzuschicken, ist natürlich keine Basis für Partizipation. Deshalb überlege ich mir das Projekt auf Source Forge zu bringen. Da gibts ein Code Repository, in dem jeder ein- und auschecken könnte. Wenn ich der einzige Commiter bin, wäre mir das auch egal, aber es gibt zumindest eine Basis für Partizipation.

Wer will - und einer hat sich explizit dazu gemeldet - dem schicke ich natürlich den anfänglichen skizzierten aber lauffähigen code per Email.

Ich hab bisher noch kein Projekt auf Sourceforge durchgeführt, aber ich fände es eine interessante Erfahrung.  Ich mache das aber nur, sobald dieses Projekt den Machbarkeitstest bestanden hat und das ist noch nicht.

BEVOR JETZT DISKUSSIONEN AUFTAUCHEN: Ich werde wie angekündigt, das existierende am Sonntag abend an die Interessierten rausschicken.



Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 04.09.05 - 20:25:38
Bisher habe ich nichts, was für den Adressaten irgendwie nachvollziehbar wäre. Ich schicke es später. Ist auch kein Standardprojekt.  8)


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Mark³ am 05.09.05 - 10:32:02
Damien ist wieder online...Der vertreibt sich gerade die Zeit mit irgendwelchen C-Funktionen, vielleicht will er bei deinem Projekt mitmachen  ^-^


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 05.09.05 - 11:10:14
Wenn ich eine tragfähige 0.1 Version als Basis habe (und es möglich ist wie ich mir es vorstelle).
Ich arbeite ja normalerweise nicht so low-level, sondern bin Anwendungsentwickler auf Basis von Frameworks oder Produkten. Das ist einfach so ein Hobby Projekt, um mich mit Code-Generierung zu beschäftigen.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 08.09.05 - 10:22:29
Das könnte helfen.
http://www.antlr.org/
Immer noch nix verschickbares, z.Zt. keine Zeit.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 12.09.05 - 23:18:36
Ich denke, ich mach das erst einmal alleine, da ich denke, dass die Kommunikationskosten einfach zu hoch sind. Poste aber weitgehend kommentarlos das bisher funktionierende Parsing-Framework mit Unit Tests für die oben beschriebene Prä-Formatierung.  (s. angehängtes zip).
Es sind 2 parallele Source Folder in Eclipse (src und test). Die Packages fangen jeweils bei de an. Der Aussagekräftige Unit-Test ist StringProcessorTest. Daneben gibts Junit-Tests für die einzelnen Filter. Ausser JUnit existieren keine anderen 3rd party libraries. Nicht mal log4j.
 
In dem Parser-System werden einzelne Chars durch eine Kette konfigurierbarer Filter gejagt. Ein Context-Objekt spielt da auch noch eine Rolle.

Je nach verschiedenen Context muß unterschiedlich geparsed werden.
Innerhalb einer Klammer, Innerhalb eines String-Literals, etc.

Wies jetzt weiter gehen soll.
Ich teile das Formelsprachenscript wie oben beschrieben erst einmal grob vor in die Bereiche, die durch ein ; ausserhalb eines Stringliterals und ausserhalb von Klammern stehen.
Das ist fertig.

_a:=@dblookup("Notes":"NOCACHE";"":"";"($aaa)";"AToc";"ATitle"); _application:=@if(@iserror(_a);@failure("Fehler Meldung !");_a);

wird geteilt zu
1. _a:=@dblookup("Notes":"NOCACHE";"":"";"($aaa)";"AToc";"ATitle");
2. _application:=@if(@iserror(_a);@failure("Fehler Meldung !");_a);

Innerhalb dieser Teile können sehr viele Formeln ineinander geschachtelt sein. Wie bei 2. ansatzbare sichtbar. Das sieht nicht als großes Problem aus, wenn ich das in einen Composite Tree lade und mir die Nodes und Leafs durch die Elemente des Composites selbst generiere. Damit habe ich aber kaum angefangen.

Die Elemente des Composites sind alle vom Typ Token. Es gibt diese konkreten Klassen:
a) RootToken (genereller Container für alle Teile des FormelScripts)
b) FormelToken (hier eine Menge konkrete Klassen)
c) CommandToken (hier eine Menge konkrete Klassen)
d) StringLiteralToken
e) Liste (sowas wie Doppelpunkt)
f) Operatoren (v.a. + aber auch - möglich)
g) VariableInitialization
h) VariableName
i) Variable

Der Ast von Punkt 2. des Composites sähe so aus:
2. _application:=@if(@iserror(_a);@failure("Fehler Meldung !");_a);
RootToken
-- VariableInitialization
--- VariableName (-> _application)
--- FormulaTokenIf (@If)
-----FormulaToken (@isError)
------- Variable (_a)
-----FormulaTokenFailure (@failure)
-------StringLiteralToken ("Fehler Meldung!")
----- Variable (_a)

Berichte weiter. Wenn jemand was damit anfangen kann, soll er sich melden.

Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: koehlerbv am 12.09.05 - 23:53:40
Hallo Axel,

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.) ?

Könntest Du in irgendeiner Form die Diskussion auch programmierspachenunabhängig publizieren ? Das würde ggf. die Bereitschaft zur Mitarbeit deutlich erhöhen. Jeder von uns, die in Frage kommen, steckt ja gerade in anderen Projekten mit anderen Umgebungen und Werkzeugen und mag / kann vielleicht nicht umschalten.

Good luck !

Bernhard


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 13.09.05 - 09:05:43
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


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Untitled am 13.09.05 - 16:51:22
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?


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: eknori am 13.09.05 - 17:46:22
@Axel: Guck mal hier ( http://www.openntf.org/Projects/codebin/codebin.nsf/CodeByDate/A95B7A4F5D65505386256E430040E783 )
Evtl. ganz interessant ...


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 13.09.05 - 18:44:29
@Untitled: Howdy Pardner. Cooler Name  O0

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  ;)
Zitat

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


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: eknori am 13.09.05 - 18:57:03
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.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 13.09.05 - 21:14:59
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.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 14.09.05 - 20:25:12
Zitat
Fersengeldgeber Marco
Verstehe ich nciht 8) :-:


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 14.09.05 - 21:31:36
Verstehe ich nciht 8) :-:
War ein Joke.
Echte Männer leben nach der Devise: Besser eine schlechte Presse als gar keine Presse.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 15.09.05 - 07:34:30
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?


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 15.09.05 - 10:53:22
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.
Zitat
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.
Zitat
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


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 18.09.05 - 09:27:39
Zitat
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.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 03.10.05 - 14:03:29
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


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 14.10.05 - 00:53:34
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


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 18.10.05 - 00:08:28
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


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Thomas Schulte am 18.10.05 - 14:07:19
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;"~~"))


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Thomas Schulte am 18.10.05 - 14:13:40
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));


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 18.10.05 - 14:23:23
thx.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: eknori am 18.10.05 - 17:51:38
Nimm dies  ;D

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 )


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 18.10.05 - 21:16:54
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.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 18.10.05 - 21:50:29
Ok. Leider passt der Spruch "Next batter, please" heute nicht so ganz hundertprozentig  ;D

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.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 18.10.05 - 22:58:04
Beim zweiten File von Thomas gibt es ein Problem um das Element @Subset. Es sollte nichts mit der ungewöhnlichen Formatierung zu tun haben. Muß ich mir mal genauer anschauen, wenn ich Zeit habe. Ist was schwerwiegenderes.
Ein StringIndexOutOfBounds in der Methode in TokenFactory.getToken ... interesting.  ::)


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 18.10.05 - 23:23:15
Das Problem ist, dass ich nicht bedacht habe, das manche Formeln (z.b. @Success keine Parameter haben). Scheint ein bischen was größeres zu sein.
Versuche jezt Ulrichs Code und füge bei @Success einen parameter an.



Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: koehlerbv am 18.10.05 - 23:44:38
Axel, schau Dir deswegen auch nochmal das Posting #59 in diesem Thread an. Es gibt weitere Fallstricke.
Ich finde Dein Projekt nach wie vor sehr interessant, wünschte mir aber, dieses würde mit "Bordmitteln" durchgeführt. Die @functions werden auf jeden Fall immer unterschätzt - mit Deinem Projekt trägst Du zu ihrer korrekteren Beachtung sicherlich sehr bei.

Weiterhin viel Erfolg.

Bernhard


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 19.10.05 - 00:05:38
wünschte mir aber, dieses würde mit "Bordmitteln" durchgeführt.

Theoretisch könnte ich die Klasse zu einem .jar File einpacken und das in einen Agenten einbinden. Eclipse geht aber schneller. Ok ich kompiliere ich mit Java5 (ohne Java5 Features wirklich zu nutzen, eben um es Notes kompatibel zu halten.

Ich finde es absolut lächerlich zu sagen: Java ist schwierig, Formelsprache ist einfach, LotusScript ist mittelschwierig.

Ich bin der Meinung, dass dieses Projekt mit Java einfacher ist (ist schon schwierig genug). Und diese ganzen Features von Java sind nicht zum Spaß da. Die helfen auch.

Gruß Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 19.10.05 - 00:06:27
Ulrichs Code:

de.aja.formulatols.TRoot
--[TUnknown: rawContent: jebrem{---thisactionbuttonfiltersaviewbasedontheuser'sinput---}]
--de.aja.formulatols.TVariable(name=tmpvname, tokenID=00000001)
----de.aja.formulatols.TFsubset
------de.aja.formulatols.TFviewtitle
--------[TUnknown: rawContent: xx]
------[TUnknown: rawContent: -1]
--de.aja.formulatols.TFif
----[TUnknown: rawContent: tmpvname=""]
----de.aja.formulatols.TFreturn
------de.aja.formulatols.TFprompt
--------[TUnknown: rawContent: [ok]]
--------[TLiteral: rawContent: Warning]
--------[TLiteral: rawContent: This only works when a databaseis opened to a view.]
----de.aja.formulatols.TFsuccess
------[TLiteral: rawContent: xx]
--de.aja.formulatols.TVariable(name=tmpcol, tokenID=00000002)
----[TUnknown: rawContent: 1]
--[TUnknown: rawContent: rem{producealistofcategoriesfromthecurrentview}]
--de.aja.formulatols.TVariable(name=tmplist, tokenID=00000003)
----de.aja.formulatols.TFunique
------de.aja.formulatols.TFdbcolumn
--------de.aja.formulatols.TList
----------[TLiteral: rawContent: ]
----------[TLiteral: rawContent: ]
--------de.aja.formulatols.TList
----------[TLiteral: rawContent: ]
----------[TLiteral: rawContent: ]
--------[TVariableRef: idRef: 00000001]
--------[TVariableRef: idRef: 00000002]
--[TUnknown: rawContent: rem{handlecommonerrors--resetfilteringinaninappropriateview}]
--de.aja.formulatols.TVariable(name=warningtext, tokenID=00000004)
----[TUnknown: rawContent: "This action only works in a categorized view where the categoryis the first column."+@char(10)+"This will not work in a flat view or in a view where the first column is notthe category"]
--de.aja.formulatols.TFif
----de.aja.formulatols.TFistext
------[TUnknown: rawContent: tmplist[1]]
----de.aja.formulatols.TFsuccess
------[TLiteral: rawContent: xx]
----de.aja.formulatols.TFdo
------de.aja.formulatols.TFsetviewinfo
--------[TUnknown: rawContent: [setviewfilter]]
--------[TLiteral: rawContent: ]
--------[TLiteral: rawContent: ]
--------[TUnknown: rawContent: 1]
------de.aja.formulatols.TFreturn
--------de.aja.formulatols.TFprompt
----------[TUnknown: rawContent: [ok]]
----------[TLiteral: rawContent: Warning]
----------[TVariableRef: idRef: 00000004]
--[TUnknown: rawContent: rem{lettheuserpickonecategory}]
--de.aja.formulatols.TVariable(name=tmpchoice, tokenID=00000005)
----de.aja.formulatols.TFprompt
------[TUnknown: rawContent: [okcancelcombo]]
------[TLiteral: rawContent: Select a Category for Filter]
------[TUnknown: rawContent: "This will filter the view to a singlecategory."+@char(13)+"   (specify blank for all)"]
------[TLiteral: rawContent: ]
------de.aja.formulatols.TList
--------[TLiteral: rawContent: ]
--------[TVariableRef: idRef: 00000003]
--de.aja.formulatols.TList
----[TUnknown: rawContent: rem{reminder]
----[TUnknown: rawContent: expandthevieworitmayappearempty}]
--de.aja.formulatols.TCviewexpandall
--[TUnknown: rawContent: rem{setthefilter(orclearthefilter)}]
--de.aja.formulatols.TVariable(name=tmpcname, tokenID=00000006)
----[TLiteral: rawContent: sPOAreaName]
--de.aja.formulatols.TFsetviewinfo
----[TUnknown: rawContent: [setviewfilter]]
----[TVariableRef: idRef: 00000005]
----[TVariableRef: idRef: 00000006]
----[TUnknown: rawContent: 1]


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 19.10.05 - 00:23:31
Thomas 2. Skript macht noch ein paar Probleme, die ich jetzt nicht mehr verstehe:

(für die beiden letzten Skripte habe ich @Formeln ohne () wie zb. @Success ersetzt durch z.B. @Success("xxx");

de.aja.formulatols.TRoot
--[TUnknown: rawContent: rem{***beginofhead***}]
--de.aja.formulatols.TVariable(name=title_, tokenID=00000001)
----[TLiteral: rawContent: Grußformel wählen]
--de.aja.formulatols.TVariable(name=message, tokenID=00000002)
----[TLiteral: rawContent: Mit welcher Grußformel am Schluß sollen Briefe und Faxe erstellt werden?]
--de.aja.formulatols.TVariable(name=messagenotfound1, tokenID=00000003)
----[TLiteral: rawContent: Fehler: Ein Schlüsselwortdokument für die Gruppe ]
--de.aja.formulatols.TVariable(name=messagenotfound2, tokenID=00000004)
----[TLiteral: rawContent:  wurde in der Einstellungen-Datenbank nicht gefunden.]
--de.aja.formulatols.TVariable(name=keygrp, tokenID=00000005)
----[TLiteral: rawContent: Address Letter Close&]
--de.aja.formulatols.TVariable(name=fieldname, tokenID=00000006)
----[TLiteral: rawContent: LetterClose]
--de.aja.formulatols.TVariable(name=fieldcont, tokenID=00000007)
----[TUnknown: rawContent: letterclose]
--de.aja.formulatols.TVariable(name=tasks, tokenID=00000008)
----de.aja.formulatols.TList
------[TLiteral: rawContent: Prompt]
------[TLiteral: rawContent: PromptErrors]
--de.aja.formulatols.TVariable(name=language_, tokenID=00000009)
----[TUnknown: rawContent: language]
--[TUnknown: rawContent: rem{***endofhead***}]
--de.aja.formulatols.TVariable(name=list, tokenID=00000010)
----[TLiteral: rawContent: ]
--de.aja.formulatols.TFif
----[TUnknown: rawContent: !@isdocbeingedited]
----de.aja.formulatols.TCeditdocument
----[TLiteral: rawContent: ]
--[TUnknown: rawContent: rem{2.buildnameofsetup-db}]
--de.aja.formulatols.TVariable(name=thispathfile, tokenID=00000011)
----de.aja.formulatols.TFsubset
------de.aja.formulatols.TFdbname
--------[TLiteral: rawContent: xx]
------[TUnknown: rawContent: -1]
--de.aja.formulatols.TVariable(name=lenpathpc, tokenID=00000012)
----de.aja.formulatols.TFlength
------de.aja.formulatols.TFleftback
--------[TVariableRef: idRef: 00000011]
--------[TLiteral: rawContent: \\]
--de.aja.formulatols.TVariable(name=lenpathmac, tokenID=00000013)
----de.aja.formulatols.TFlength
------de.aja.formulatols.TFleftback
--------[TVariableRef: idRef: 00000011]
--------[TLiteral: rawContent: :]
--de.aja.formulatols.TVariable(name=lenpathunix, tokenID=00000014)
----de.aja.formulatols.TFlength
------de.aja.formulatols.TFleftback
--------[TVariableRef: idRef: 00000011]
--------[TLiteral: rawContent: /]
--de.aja.formulatols.TVariable(name=lenpath, tokenID=00000015)
----de.aja.formulatols.TFif
------[TUnknown: rawContent: lenpathpc>lenpathmac]
------de.aja.formulatols.TFmax
--------[TVariableRef: idRef: 00000012]
--------[TVariableRef: idRef: 00000014]
------de.aja.formulatols.TFmax
--------[TVariableRef: idRef: 00000013]
--------[TVariableRef: idRef: 00000014]
--de.aja.formulatols.TVariable(name=path, tokenID=00000016)
----de.aja.formulatols.TFif
------[TUnknown: rawContent: lenpath=0]
------[TLiteral: rawContent: ]
------de.aja.formulatols.TFleft
--------[TVariableRef: idRef: 00000011]
--------[TUnknown: rawContent: lenpath+1]
--de.aja.formulatols.TVariable(name=keydb_, tokenID=00000017)
----de.aja.formulatols.TFsubset
------de.aja.formulatols.TFdbname
--------[TLiteral: rawContent: xx]
------[TLiteral: rawContent: 1]
--[TUnknown: rawContent: rem{xlanguagetranslationbecauseofnotesbug}]
--de.aja.formulatols.TVariable(name=languagetrans, tokenID=00000018)
----[TLiteral: rawContent: ]
--de.aja.formulatols.TFset
----[TLiteral: rawContent: LanguageTrans]
----de.aja.formulatols.TFdblookup
------[TLiteral: rawContent: ]
------[TVariableRef: idRef: 00000017]
------[TLiteral: rawContent: (KeywordsNotUTD)]
------[TLiteral: rawContent: Language]
------[TLiteral: rawContent: KeyMerge]
--de.aja.formulatols.TFsuccess
----[TLiteral: rawContent: xx]
--de.aja.formulatols.TFif
----[TUnknown: rawContent: !@iserror(languagetrans)]
----[TLiteral: rawContent: ]
----de.aja.formulatols.TFset
------[TLiteral: rawContent: LanguageTrans]
------de.aja.formulatols.TFdblookup
--------[TLiteral: rawContent: ]
--------[TVariableRef: idRef: 00000017]
--------[TLiteral: rawContent: (Keywords)]
--------[TLiteral: rawContent: Language]
--------[TLiteral: rawContent: KeyMerge]
--de.aja.formulatols.TFsuccess
----[TLiteral: rawContent: xx]
--de.aja.formulatols.TFset
----[TLiteral: rawContent: Language_]
----de.aja.formulatols.TFreplace
------[TVariableRef: idRef: 00000009]
------de.aja.formulatols.TFword
--------[TVariableRef: idRef: 00000018]
--------[TLiteral: rawContent: |]
--------[TUnknown: rawContent: 1]
------de.aja.formulatols.TFword
--------[TVariableRef: idRef: 00000018]
--------[TLiteral: rawContent: |]
--------[TUnknown: rawContent: 2]
--[TUnknown: rawContent: rem{6.getkeywordswithdoublelookuplanguagedependent}]
--de.aja.formulatols.TVariable(name=view2, tokenID=00000019)
----de.aja.formulatols.TFif
------de.aja.formulatols.TFends
--------[TVariableRef: idRef: 00000005]
--------[TLiteral: rawContent: *]
------[TLiteral: rawContent: (KeywordsCat)]
------[TLiteral: rawContent: (Keywords)]
--de.aja.formulatols.TVariable(name=looktype, tokenID=00000020)
----de.aja.formulatols.TFif
------de.aja.formulatols.TFends
--------[TVariableRef: idRef: 00000005]
--------[TLiteral: rawContent: *]
------de.aja.formulatols.TList
--------[TLiteral: rawContent: ]
--------[TLiteral: rawContent: NoCache]
------[TLiteral: rawContent: ]
--de.aja.formulatols.TFset
----[TLiteral: rawContent: List]
----[TLiteral: rawContent: ]
--de.aja.formulatols.TFset
----[TLiteral: rawContent: List]
----de.aja.formulatols.TFdblookup
------[TVariableRef: idRef: 00000020]
------[TVariableRef: idRef: 00000017]
------[TLiteral: rawContent: (KeywordsNotUTD)]
------[TUnknown: rawContent: keygrp+selectioncat+language_]
------[TLiteral: rawContent: KeyMerge]
--de.aja.formulatols.TFsuccess
----[TLiteral: rawContent: xx]
--de.aja.formulatols.TFif
----[TUnknown: rawContent: !@iserror(list)]
----[TLiteral: rawContent: ]
----de.aja.formulatols.TFset
------[TLiteral: rawContent: List]
------de.aja.formulatols.TFdblookup
--------[TVariableRef: idRef: 00000020]
--------[TVariableRef: idRef: 00000017]
--------[TVariableRef: idRef: 00000019]
--------[TUnknown: rawContent: keygrp+selectioncat+language_]
--------[TLiteral: rawContent: KeyMerge]
--de.aja.formulatols.TFsuccess
----[TLiteral: rawContent: xxx]
--[TUnknown: rawContent: rem{7.getkeywordswithdoublelookuplanguageindependent}]
--de.aja.formulatols.TFif
----[TUnknown: rawContent: !@iserror(list)|(language_="")]
----[TLiteral: rawContent: ]
----de.aja.formulatols.TFset
------[TLiteral: rawContent: List]
------de.aja.formulatols.TFdblookup
--------[TVariableRef: idRef: 00000020]
--------[TVariableRef: idRef: 00000017]
--------[TLiteral: rawContent: (KeywordsNotUTD)]
--------[TUnknown: rawContent: keygrp+selectioncat]
--------[TLiteral: rawContent: KeyMerge]
--de.aja.formulatols.TFsuccess
----[TLiteral: rawContent: xxx]
--de.aja.formulatols.TFif
----[TUnknown: rawContent: !@iserror(list)|(language_="")]
----[TLiteral: rawContent: ]
----de.aja.formulatols.TFset
------[TLiteral: rawContent: List]
------de.aja.formulatols.TFdblookup
--------[TVariableRef: idRef: 00000020]
--------[TVariableRef: idRef: 00000017]
--------[TVariableRef: idRef: 00000019]
--------[TUnknown: rawContent: keygrp+selectioncat]
--------[TLiteral: rawContent: KeyMerge]
--de.aja.formulatols.TFsuccess
----[TLiteral: rawContent: xx]
--[TUnknown: rawContent: rem{8.testerror}]
--de.aja.formulatols.TFif
----[TUnknown: rawContent: !@iserror(list)]
----[TLiteral: rawContent: ]
----[TUnknown: rawContent: tasks="PromptErrors"]

   at junit.framework.TestResult.runProtected(TestResult.java:124)
   at junit.framework.TestResult.run(TestResult.java:109)
   at junit.framework.TestCase.run(TestCase.java:118)
   at junit.framework.TestSuite.runTest(TestSuite.java:208)
   at junit.framework.TestSuite.run(TestSuite.java:203)
   at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:478)
   at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:344)
   at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)



Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 19.10.05 - 23:39:32
(mehr an den Moderator dieses Forums gerichtet)
Sind natürlich auch Design-Fehler drin.
Z.B. ist es nicht gut, dass jedes Token seinen eigenen Parser hat. Der Baum der Token muß irgendwie von aussen gebaut werden. Ich hatte erst die Idee, dass die Tokens die Aufgabe haben sich selber zu bauen, aber das erscheint mir als keine schlaue separation of concerns. Das sind allein schon eine Menge Objekte (Jeder Parser hat bis zu 5 Filter). Mehrere Parser ist nicht schlecht als Idee, aber besser ist wohl die "von aussen" den Baum bauen zu lassen und wenn der Baum gebaut ist, können sie garbage collected werden (geht natürlich auch so, aber das finde ich echt unsauber, wenn ich jedes Parser Objekt auf Null setze).

(an alle interessierte:)
Es stehen natürlich noch eine Menge Aufgaben vor diesem Projekt wie z.B. aus dieser Objektstruktur wirklich LotusScript code zu bauen.
Ich werde vermutlich am WE diese Alpha Version posten und dann in der nächsten Woche das ein bischen verfeinern und dokumentieren, dass vielleicht auch nicht so erfahrene Java Interessierte damit etwas anfangen können, falls es sie interessiert. Schliesslich hat Eclipse ja einen debugger und das ist ja nur source code.

Bernhard
Auf der einen Seite wird mir (z.T. zu Recht) Laberei vorgeworfen, auf der anderen Seite soll ich Sachen "programmiersprachenunabhängig" publizieren (Posting 59). Ich glaub du überschätzt mich da ein wenig.  ;D
Aber dieses Projekt hat in vielerlei Hinsicht ein kommerzielles Schwesterprojekt mit LotusScript. Nämlich die Grammatik-für-hierarchische-Konfigurationsdokumente um ein xml Dokument mit Notes4 zu erstellen. Ein paar Grundgedanken von dem Javaprojekt sind da rübergegangen.

Gruß Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Mark³ am 18.11.05 - 07:52:24
Code:
@Sort(list; [CUSTOMSORT]; @ToNumber(@Trim(@Rightback($A; " - "))) > @ToNumber(@Trim(@RightBack($B; " - "))))

Diese Formel sortiert die folgende Liste
Zitat
Billy Ray -- 10
Johnnie Lightning -- 37
Elvis Cantebury -- 9
Chief Wiggum -- 13
Angela King -- 6
Mary Ford -- 27

in dieser Reihenfolge:
Zitat
Angela King -- 6
Elvis Cantebury -- 9
Billy Ray -- 10
Chief Wiggum -- 13
Mary Ford -- 27
Johnnie Lightning -- 37

da wird bestimmt interessanter Skriptcode draus  ;D


Quelle: http://advisorupdate.info/Articles.nsf/nl/16642


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 18.11.05 - 11:55:05
Dieses Forschungsprojekt liegt momentan ein bischen auf Eis. Werd mich aber wieder dran begeben.
Sicher ist auf jeden Fall, dass R6 Formelsprachenfeatures erst einmal nicht unterstützt werden.  ;D
Insgesamt ist die Konvertierung von Programmiercode in eine Baumstruktur und diese Baumstruktur wieder zurück in eine andere Programmiersprache nicht uninteressant.
Ich merke dabei, dass ich viele Sachen nicht weiss.
Falls sich jemand beteiligen will, immer gerne.
Es ist eigentlich noch relativ durchschaubar.



Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 13.01.06 - 10:46:56
Gibt es was neues?


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 13.01.06 - 11:46:20
Zur Zeit auf Eis gelegt.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Gandhi am 13.01.06 - 18:12:16
Schade. Ich hatte mich schon so darauf gefreut endlich kein LotusScript mehr selbst schreiben zu müssen... ;D


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: Mark³ am 18.01.06 - 15:16:36
dieser Generierer wäre leicht umgewandelt (FormelspracheToJava) ein Teil einer Anwendung, die (halb-)automatisch eine Notes-Datenbank in eine Java-Anwendung mit SQL-Backend und RCP-FrontEnd transformiert.

Axel, sowas hat doch deine Firma auch im Angebot, oder? Son Ding, was aus DXL ne Javasache baut??

Die weiteren Teile wären jedenfalls ein LotusScriptToJava-Generierer und ein DXL to JFace-GUI Generierer.
Vielleicht sollten sich mal ein paar engagierte Entwickler ein Jahr Auszeit nehmen und son Ding zusammenzimmern. In einem Jahr kann man damit bestimmt ein StartUp drauf aufbauen...  ^-^


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 19.01.06 - 21:02:52
Auf Eis gelegt heisst ja nicht verworfen.
Ich bin ein Stück weit gekommen, mußte da aber feststellen, dass ich doch besser JavaCC und einen formaleren Ansatz wählen sollte. Formalerer Ansatz heisst eine Menge Theoriestudien. Da war der innere Schweinehund erst einmal zu stark.
Für meinen Geschmack muß es bei so Studienprojekten immer eine gesunde Mischung zwischen low level und high level geben. Das war einfach erstmal zu low level.


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: stitze am 25.01.06 - 15:29:20
Ich habe mich mal ein wenig mit dem Compilerbau auseinander gesetzt und bin der Meinung, du solltest auf jeden Fall ein paar Theorien dazu studieren, aber der Aufwand dazu ist nicht so groß. Es gibt genügend Seite im Internet, man bemühe google ;), die das Thema aufgreifen und leicht erkläre (z.B. die http://www.u-helmich.de/inf/comp/index.html (http://HP von Ulrich Helmich) obwohl es da neuere Methoden des Vorgehens gibt, aber generell zum einlesen nicht schlecht, vor allem nicht gleich zu kompliziert.

Der Thread hat mich auch wieder neugirig gemacht auf das Thema, ich werde in den nächsten zwei Wochen ein paar UML - Entwürfe machen, und meine Ideen und Vorschläge hier dann mal publizieren, evtl. bekomme ich eine Roadmap hin.

Bin mir aber nicht so sicher ob Java die beste Hochsprache ist, um dies zu realisieren, wäre eher für C++ oder evtl. .Net (aber dann unmanaged, hab mich noch nicht so mit Bäumen unter .Net und Java beschäftigt, werd ich heute abend mal tun)

Erstmal Danke für die Anregungen hier

Mfg

Sebastian


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 29.01.06 - 14:48:14

Bin mir aber nicht so sicher ob Java die beste Hochsprache ist, um dies zu realisieren, wäre eher für C++ oder evtl. .Net (aber dann unmanaged, hab mich noch nicht so mit Bäumen unter .Net und Java beschäftigt, werd ich heute abend mal tun)

Ich wüsste nicht warum Java eine schlechte "Hochsprache" dafür wäre oder warum das unbedingt in unmanaged .NET gemacht werden müßte. Schliesslich ist es nicht Hardware-nah.
Ansonsten habe ich ein großes Interesse an konkreten Ansätzen in egal welcher Programmiersprache.

Gruß Axel


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: stitze am 20.02.06 - 11:36:22
Also nochmal ein neuer versuch da ich die letzte Zeit in Paderborn und Hamburg war und weniger Zeit zur verfügung hatte, als mir lieb gewesen wäre, werde ich leider erst diese Woche anfangen können an konkreten Lösungsvorschlägen arbeiten zu können, bitte um Verzeihung, werde aber wie angekündigt, alle vorläufigen Ausarbeitungen zur Verfügung stellen.

Mfg

sebastian


Titel: Re: Formelsprache TO LotusScript Code-generierer schreiben
Beitrag von: flaite am 21.02.06 - 11:16:53
Sebastian,

ich denke, das vernünftigste wäre, ein sourceforge.net Projekt zu eröffnen.
Gibt zwar einen Prozess mit Genehmigung, um von denen Platz auf der ihren Servern zu bekommen. Das ist aber ziemlich einfach.
Ich hab zur Zeit auch wirklich eigentlich keine Zeit.
Hab schon ein anderes sourceforge-Projekt, in das ich zur Zeit im Halbschlaf gegen 22:00 Uhr committe.
Wir wären aber nicht die ersten, die auf sourceforge.net ein Projekt starten, ohne dafür Zeit zu haben.
Zumindest hätten wir dann cvs-zugänglichen Platz dafür.
Vielleicht finde ich am WE die Energie, um hier einen draft für die Begründung des Projekts an sourceforge zu schicken. Man kann das sicher auch als gemischtes c++/java Projekt deklarieren. Kann ja innerhalb des Projekts in unterschiedliche Module gepackt werden.

Gruß Axel