;------------------------------------------------------------------------ ; Titel : EigerStudio & EigerScript Release History ; File : EigerStudio_ReleaseNotes.txt ;------------------------------------------------------------------------ ; ; Ausgabe : 6. Januar 2010 ; ; ;------------------------------------------------------------------------ ; (c) 2005-2010 Weitnauer Messtechnik, Eich 1, CH-8752 Näfels ; www.weitnauer-messtechnik.ch ;------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------------------- V0.67, 100106 - Neue SYSTEM-Konstante $COMPILEDATE_ISO eingeführt: Compile-Datum im internationalen ISO-Format (Format YYYY-MM-DD) - Bestehende SYSTEM-Konstante $COMPILEDATE gibt das Compile-Datum neu im lokalen CH-Format aus: DD.MM.YYYY (statt wie früher im internationalen ISO-Format) - LiveParser arbeitet nicht mehr auf Inhalte von Strings ('...') oder ASCII-Konstanten (".") - LiveParser-Management geändert: 1. Aktion verzögert, 2. Wartelisten-Mechanismus neu eingeführt (Dadurch wirkt der LiveParser weniger "nervös", ist aber gleichzeitig im Blockmodus langsamer) - Aufruf-Mechanismus des Kontextmenüs im Editor geändert. (Dadurch hoffe ich, dass die Stabilität des Editors verbessert ist.) Tipp: die rechte Maustaste ändert die Selektion NICHT. Wenn also gescrollt wurde und mit der rechten Maustaste das Kontextmenü aufgerufen wird, bezieht sich die Funktion noch auf die aktuelle Selektion. Deshalb: Vor der Funktion "Goto Definition" immer erst die linke Maustaste drücken! - Fehler in der komplexen FOR-Schleife behoben: FOR i:= a TO b STEP c - Während Build-Prozess sind manuelle Datei-Wechsel neu blockiert. (Früher war ein Crash möglich, da während dem Build-Prozess das aktive Projekt geändert wurde) - Build-Prozess: Stabilität erhöht (Fehlerbehandlung im File-IO eingebaut) ----------------------------------------------------------------------------------------------------------- V0.66, 091123 - SYSTEM-Konstanten $COMPILEDATE und $COMPILETIME werden bei jedem Refresh und bei jedem neuen Start des Compilers nachgeführt. - Mit [CTRL] + [SPACE] wird die erste Methode im EigerTip-Methodenfeld übernommen: Fehler behoben (bei leerem Methodentip-Feld konnte ein unbehandelter Ausnahmefehler ausgelöst werden.) - Suchen & Ersetzen (Find & Replace) begrenzt Funktion nun korrekt auf selektierten Block, wenn die Betriebsart auf "Selection only" gesetzt ist. - GotoDefinition-Funktion: Tabulator wird nun neu als WhiteSpace erkannt. Die Funktion arbeitet nun auch ohne automatisches Tab-Ersetzen korrekt (Extras->Options->"Replace TAB by a block of [SPACE]) - Skalieren des Editorbereichs (ZOOM) per [CTRL]+MouseWheel wird nun vom LiveParser korrekt unterstützt. (Die maximale Anzahl Zeilen ist aber auf 500 begrenzt!) - Bild-Verzerrung in About-Box sollte nun nicht mehr auftreten. (Bitte in verschiedenen Umgebungen testen!) - Beschreibungen im FuncLib dürfen nun auch Umlaute und ASCII-Sonderzeichen enthalten. - Stack-Funktionsänderung: Statt PopV_I (Pop Variable Integer) wird nun PopV_LI (Pop Variable Logic Integer) eingesetzt. Dadurch wird nur das untere Halb-Long-Wort in die Variable geschrieben. Bemerkung: Die Push-Funktionen unterstützen bei Konstanten signed/unsigned. ----------------------------------------------------------------------------------------------------------- V0.65, 091029 - Default-Wert der Compiler-Option EVAL_STACK/EVAL_STANDARD ist neu definierbar (Extras->Options) in Gruppe "Compiler Options" der Wert "Mathematic evaluation: by default on stack" Dieser Wert ist neu standardmässig gesetzt, d.h. math. Ausdrücke werden auf dem Stack abgewickelt. Schaltet man die Option ab, funktioniert der Compiler wie früher: er optimiert die Aufrufe, indem er bei kurzen Ausdrücken die speziellen Methoden nutzt. Stack-Evaluation bedeutet, dass des Compilat im Normalfall länger wird; selbst zuweisungen werden über den Stack abgehandelt. (Das hat den Vorteil, dass Konversionsroutinen automatisch aufgerufen werden.) - Unterstützung der OBJECT ... ENDOBJECT - Kapselung. Diese beiden neuen Keywords werden vom Grafikeditor benötigt. So kann er die grafischen Objekte erkennen. Der Sourcecode innerhalb dieser Schlüsselworte wird durch den Grafikeditor bei Anpassungen überschrieben. - Problem der GotoDefinition-Funktion bei gewissen Installationen (evtl. Crash von EigerStudio) im Kontextmenü des Editors entschärft. Bedienungshinweis: Das Kontextmenü wird per rechtem Mausklick aufgerufen und wirkt auf die AKTUELLE Auswahl. Wenn die Länge der aktuellen Auswahl Null beträgt (KEIN hervorgehobener Text, sondern nur blinkender Cursor), wird der Cursor durch den rechten Mausklick auf die aktuelle Position verschoben - sonst NICHT! Es wird deshalb empfohlen, die gewünschte Textstelle erst mit der linken Maustaste anzuklicken oder zu markieren und erst anschliessend die rechte Maustaste zu drücken. - GotoDefinition/MoveBack-Funktionen restaurieren neu auch die vertikale Scrollposition. So wird die Ansicht so wiederhergestellt, wie sie beim jeweiligen Absprungszeitpunkt war. ----------------------------------------------------------------------------------------------------------- V0.64, 091023 - Fehler in Funktionsbeschreibung *.LIB-File behoben. - Problem Copy-Paste bei ungültigem Inhalt behoben. (Einige Programme zerstören Teile des Copy-Puffers "Zwischenablage". Ein anschliessendes Einfügen in EigerStudio konnte zu einem Crash führen.) ----------------------------------------------------------------------------------------------------------- V0.63, 091022 - Global Constants, Register und Variablen (EigerTip-Listboxes): Refresh-Funktion und Doppelklick korrigiert. - Mit [CTRL] + [SPACE] wird die erste Methode im EigerTip-Methodenfeld übernommen (Analog einem Doppelklick auf den ersten Eintrag im EigerTip-Methodenfeld) - Neue Funktionsweise der Übernahme der EigerTip-Methode gemäss Wunsch: 1. Einfügen des Methodennamens und 2. Anschliessend werden die Parameterklammern gesetzt und der Cursor dazwischen platziert - Filesystem-Zugriffsfehler sind besser abgefangen. Speziell Probleme bei ReadOnly-Medien sind so behoben. - "Intellisense"-Funktion bei Variablenbezeichner innerhalb Deklaration abgeschaltet - Problem Projekt-TreeView bei FileSwap und anschliessendem Abbruch des Swaps behoben - NEU: Funktionsbeschreibung in FUNCLIB ermöglicht. Diese Beschreibung wird auch in EigerTip nachgeführt. Anleitung: in *.LIB-File Einträge wie folgt: Beispiel 1: Sichtbare Methode mit Beschreibung der Parameter Beschreibung der Methode selbst (nach ;) MOVE_INTEGER(VarInt:Ziel,VarInt:Quelle) ;Diese Methode kopiert einen Wert von zu Beispiel 2: Versteckte Methode (wird nicht in EigerTip geführt, ist aber kompilierbar) Die Zeile muss einfach mit einem Stern markiert werden *MOVE_INTEGER_IO(VarInt:Quelle,VarInt:Ziel) Beispiel 3: Auskommentierte Methode (weder in EigerTip sichtbar noch kompilierbar) Die Zeile muss mit einem ; an ERSTER STELLE beginnen ;MOVE_INTEGER_OLD() ----------------------------------------------------------------------------------------------------------- V0.62, 090929 - Stabilität der Funktionen "Goto Definition" und "Move Back" im Editor-Kontextmenü verbessert - Stabilität und Zeitverhalten UNDO/REDO-Manager optimiert - ARRAY-Definition der numerischen Datentypen eingeführt: Deklaration DATENTYP [Size in Anzahl Elementen] name Beispiel: INTEGER [20] intTest = 1 erzeugt einen Speicherblock mit 20 * 2 Bytes = 40 Bytes und initialisiert das erste Element zu 1. Die folgenden Elemente können zur Zeit nicht initialisiert werden. (ACHTUNG: Diese neue Option ist zu Versuchszwecken eingeführt worden) ----------------------------------------------------------------------------------------------------------- V0.61, 090527 - Editor-Kontextmenü (rechte Maustaste im Editorfenster) mit GotoDefinition-Funktion (Sprung zum Definitionspunkt von Subroutinen, Variablen und Konstanten) und mehrstufiger MoveBack-Funktion (Rücksprung zur ursprünglichen Position). Gesucht wird im aktuellen File und anschliessend in der Projektdefinitionsdatei, wohin der Editor bei Erfolg auch wechselt. Benutzt wird dabei der QuickSwap-Mechanismus, wobei der Benutzer bei ungespeicherter Datei um Bestätigung gebeten wird. (Das dynamische Nachführen der TreeView ist recht aufwändig. Diese neue Funktion dürfte eine bessere Alternative darstellen.) - GotoDefinition und MoveBack: neue Funktionen im Hauptmenü (Paralleldefinitionen zu den entsprechenen Kontextmenüfunktionen) - Extra->Options-Menü um neue Parameter ergänzt. - Problem mit Länderschemata behoben: Länderschema hat Kompilation beeinflusst und Fehler bei der Evaluation von Fliesskommazahlen verursacht. (ACHTUNG: beim Testen hat sich gezeigt, dass Kompilierfehler NEU auftreten können, weil gewisse numerische Schreibweisen nun anders interpretiert werden.) - AutoTabulator: Fehler in wählbarer Indent-Breite behoben (Indent/Unindent und einige Editorfunktionen waren betroffen) - FileOpen (speziell das Nachladen der Projektdefinitionsdatei) schneller durch optimierte Suchfunktionen - Search/Replace-Funktionen schneller durch optimierten Suchalgorithmus - Verhalten LiveParser durch neue Zeitsteuerung optimiert - Problem Copy/Paste mit fehlendem CRLF am Zeilenende behoben. - Ausgabe des Compiler Output als Logdatei im Unterverzeichnis \log. Steuerbar durch "Save compiler output in a logfile" im Options-Menü. - Build-Funktion optimiert, Compiler-Log-Verbosity wird automatisch vermindert bei Build - Build/Batch-Compiler: Abbruch möglich durch Klicken in Editorbereich. Kompilation wird unterbrochen und ein Bestätigungsdialog eingeblendet. - Während Build/Batch-Compiler: Compiler Output wird aufgefrischt - CFC-Laufwerk als alternatives/zusätzliches Ziellaufwerk für Binärdateien (Ausführbare Datei wird automatisch in Projektverzeichnis abgespeichert. Im Options-Menü wird der Laufwerksbuchstabe "DriveLetter", unter dem die CompactFlashCard eingeblendet wird, angegeben) - Zielverzeichnis für Binärdateien im Options-Menü spezifizierbar (Default: \bin) - Scroll-Seiteneffekte verhindert. (Beim vertikalen Scrollen konnte beim Ziehen des Scrollbuttons gelegentlich ein Seiteneffekt beobachtet werden: das Bild sprang zwischen Fileanfang und aktueller Position hin- und her) Die Massnahme war der Einbau einer neuen Funktion für die ScrollSpy-Funktion. - Zusätzliche Plausibilitätsprüfungen beim Fileöffnen und Nachführen der EigerTip-Listen verhindern Abstürze bei Manipulationen im Arbeitsdirectory. - Build-Prozess wird nicht mehr durch Kompilationsfehler unterbrochen. Erst am Schluss erscheint ein Informationsdialog mit Angabe von Fehlern, Warnungen oder Erfolgsmeldung. - Inkonsistenzproblem mit Funktion Math.POWER und Stack-Befehl eFA_POW_S durch Sonderbehandlung umgangen. (In Zukunft werden die 3-Operatoren-Befehle nicht mehr durch den Compiler synthetisiert, sondern grundsätzlich über die Stackmaschine abgewickelt.) ----------------------------------------------------------------------------------------------------------- V0.60, 090326 - Fehler bei ungepaarten Klammern in Stringkonstanten behoben (Kamen ungepaarte Klammern INNERHALB eines Strings vor, meldete die MathExpression-Parser-Plausibilitätsprüfung einen Fehler und der String war leer.) - Das Verhalten des Methodentipps wurde grundlegend geändert. Beim Anspringen einer Zeile wird neu eine eventuell vorhandene Methode gesucht und der Methodentipp angezeigt. (Diese Änderung könnte eine geringfügige Latenz bewirken.) ----------------------------------------------------------------------------------------------------------- V0.59, 090325 - Editor-Shortcut für Replace neu ^H statt ^R - Neue Menü-Funktion: Insert Date&Time (fügt das aktuelle Datum und die Zeit an der Cursorposition ein) - "Compile EigerScript A": Die alte Codeerzeugung wurde nun endgültig und vollständig entfernt - Neu: automatische Backup-Dateien in Unterverzeichnis \ backups (pro Datei 10 Backups), SubDir wird automatisch erzeugt - Neu: Die ausführbaren Dateien (EVI) werden im Unterverzeichnis \bin erstellt, SubDir wird automatisch erzeugt - Neu: Map&List-Dateien werden im Unterverzeichnis \debug erzeugt, SubDir wird automatisch erzeugt - TreeView ist neu immer vollständig aufgeblendet - TreeView-Fenster breiter (Scrollbar deckt in TG12 die Namen ab) - OpenFile-Präprozessor: Fehler beim Lesen der Textdateien (ANSI-Zeichen wurden falsch gelesen) - OpenFile-Präprozessor: bei abgeschalteter Tab-Replace-Option werden die Tabulatoren nicht mehr ersetzt - Menü Edit->Paste (Shortcut ^V und NEU ergänzt Shortcut Shift-Ins) übernimmt RTF-Formatinformationen nicht mehr - Falsche oder irreführende Compiler-Output-Meldungen bei Variablendeklaration entfernt - Compiler-Output-Meldungen sanft renoviert - Compiler: Initialisierungsfehler bei Datentypverletzung führen neu zu Fehler statt nur zu Warnung - Compiler/LiveParser: Fehler in Schlüsselworterkennung behoben (FOR XTOX:=1 TO 10) Insgesamt wurden wieder einige Neuerungen geschaffen. Die für den Benutzer augenfälligste Änderung ist sicherlich das Ablegen von erstellten Dateien in Unterverzeichnissen. Sehr wichtig war auch das Problem mit der ASCII-ANSI-Textumwandlung. ----------------------------------------------------------------------------------------------------------- V0.57, 090306 Erweiterungen: - Text-Preprocessor: Korrigiert falsche Zeilenvorschübe. Ersetzt (wahlweise) TAB durch SPACE-Folgen einstellbarer Länge (in Option) - Indent/Unindent-Funktion (um TAB-Breite); alternativ mit ctrl+I/ctrl+U - 0D0D0A-Kombination als Zeilenvorschub erzeugte überlange Zeilen. (Behoben durch Preprocessor) Behobene Fehler: - Fehler in EPR-Versionsverwaltung (fälschliche "Constant redefined"-Fehlermeldung) - 0xFE wurde fälschlich als SCI-Format erkannt. Dies wurde durch Einbau einer neuen intelligenten Variablentyp-Erkennung behoben. - 0D0D0A-Kombination als Zeilenvorschub erzeugte überlange Zeilen. (Behoben durch Preprocessor) ----------------------------------------------------------------------------------------------------------- V0.56, 090113 Folgende Änderungen und Erweiterungen wurden vorgenommen: - Console-Compiler EigerScript.exe. Ab sofort gehört dieser zum Lieferumfang. Er benutzt dieselbe Basis wie EigerStudio. - STRING-Definition. Länge unterstützt neu UINT statt INT (also max. Länge eines Strings von 65535) - Linker-Error "Label not found" führt im Editor zum Springen auf den nicht aufgelösten Aufruf (fileübergreifend EVS und EPR) - Optimierung des Zeitverhaltens der IDE-Automatismen. (schnelleres Ansprechen und effizientere Ausführung) Behobene Fehler: - Globale IF-Struktur führte zu fehlerhaftem Code (Kollisionen mit lokalen IF-Strukturen) - Flimmer-Effekte des Editors sind nun endlich behoben. (optimierte Refresh-Steuerung) - Live-Parser arbeitete nicht korrekt bei -getrennten Bezeichnern - Build-Fehler trotz korrektem Source-Code bei Build-Start in geöffneter EPR-Datei - Crash bei Deklaration einer Font-Variablen mit ungültigem oder fehlendem Filenamen - Linker-Problem: MAP/LIST-Files nicht zuverlässig geschlossen - Crash bei fehlendem Prozedurnamen ----------------------------------------------------------------------------------------------------------- V0.55, 080808 - Stackmaschine arbeitet nun intern generell in LONG bei Ganzzahlen - Erzeugung der Stackkette korrigiert (Unterscheidung sigend/unsigend für INTEGER) - Überlaufbehandlung korrigiert - Fehlermeldungen bei Überlaufbehandlung korrigiert - Find/Replace-Dialog überarbeitet. (Wiederaufnahme des Suchvorgangs nach Ende. Anzeige, wieviele Vorkommen im File, Replace nach Eingabe in Replace nun auch nach Find-Aufruf möglich. ACHTUNG: Unmöglich ist es, nach einem Versetzen des Cursors im Editor die neue Position zu übergeben. Die Startposition kann nur beim Öffnen des Dialogs übergeben werden.) ----------------------------------------------------------------------------------------------------------- V0.54, 080729 - Absturz bei leerem Quellfile behoben ("Fall 2") - Explizites Testen von Keywords verhindert Compilerprobleme ("Fall 4") - Fehler in Färbung: Label-Abspaltung bei Doppelpunkt in Gänsefüsschen behoben ("Fall 1") - Fehler in Färbung: Identifier-Erkennung verbessert - AutoVariablen werden in allen Datentypen NEU wiederverwendet - Immediate PUSH in allen Integer-Datentypen korrekt - Find, Find/Replace-Dialoge komplett neu (Option "Projektweit" zur Zeit aber nicht möglich) Wichtige Informationen: COMPILER-SCHALTER Es gibt zur Zeit vier Compiler-Direktiven: COMPILER EVAL_STACK: Ab dieser Stelle werden Stackoperationen priorisiert. So werden sogar Zuweisungen über den Stack abgewickelt. COMPILER EVAL_STANDARD: Stackoperationen werden optimiert. Für Zuweisungen und Zwei-Operanden-Anweisungen werden die speziellen Methoden eingesetzt. COMPILER VARBASE_ZERO: Der Variablenblock beginnt bei Null. (Nur für Versuche! Der erzeugte Code ist nicht lauffähig. Variableninitialisationen sind so nicht möglich) COMPILER VARBASE_STANDARD: Der Variablenblock beginnt normal hinter dem Code-Block. STACK-Datentyp: Der Datentyp, in dem der Stack rechnet, wird durch die Zielvariable vordefiniert. Dadurch werden nach Push-Befehlen je nach Datentyp TypeCast-Methoden aufgerufen Neukompilation Eine Neukompilation eines EVS löst ein Löschen der LOKALEN Listen aus, während die Neukompilation des EPR auch die GLOBALEN Listen löscht. Damit sind die Konstanten, Variablen, SUB, LIB-Defnitionen und die Tokens gemeint. STACK-Opcodes (Die folgendenen Opcodes können durch den Stack-Befehlsgenerator erzeugt werden.) Token Bemerkung eFA_PushI_I Push immediate integer (*) eFA_PushR_I Push Register integer (*) eFA_PushV_I Push Variable integer (*) eFA_PushV_L Push Variable Long eFA_CVT_S_I Convert Single to Integer (direkt auf dem Stack) eFA_CVT_D_I Convert Double to Integer (direkt auf dem Stack) eFA_PopR_I Pop Register integer (*) eFA_PopV_I Pop Variable integer (*) eFA_PopV_L Pop Variable Long eFA_ADD_I Stack Addition integer (*) eFA_SUB_I Stack Subtraktion integer (*) eFA_MUL_I Stack Multiplikation integer (*) eFA_DIV_I Stack Division integer (*) eFA_ABS_I Betragsfunktion für ganze Zahlen eFA_PushV_S Push Variable Single eFA_CVT_I_S Convert Integer to Single (direkt auf dem Stack) eFA_CVT_D_S Convert Double to Single (direkt auf dem Stack) eFA_PopV_S Pop Variable Single eFA_ADD_S Stack Addition Single eFA_SUB_S Stack Subtraktion Single eFA_MUL_S Stack Multiplikation Single eFA_DIV_S Stack Division Single eFA_SIN_S Sinus (Single) eFA_COS_S Cosinus (Single) eFA_TAN_S Tangens (Single) eFA_ARCSIN_S Arcus-Sinus (Single) eFA_ARCCOS_S Arcus-Cosinus (Single) eFA_ARCTAN_S Arcus-Tangens (Single) eFA_PI_S Pi (Single, direkt auf den Stack; Tipp: Realisation mit 4*Arctan(1)) eFA_PWR_S Allgemeine Potenzfunktion a^b eFA_SQR_S Quadratfunktion a^2 eFA_SQRT_S Quadratwurzel eFA_EXP_S Exponentialfunktion (natürlich) e^x eFA_LOG_S Logarithmus zur Basis 10 eFA_LN_S Natürlicher Logarithmus eFA_ABS_S Betragsfunktion eFA_PushV_D Push Variable Double eFA_CVT_I_D Convert Integer to Double (direkt auf dem Stack) eFA_CVT_S_D Convert Single to Double (direkt auf dem Stack) eFA_PopV_D Pop Variable Double eFA_ADD_D Stack Addition Double eFA_DUB_D Stack Subtraktion Double eFA_MUL_D Stack Multiplikation Double eFA_DIV_D Stack Division Double eFA_SIN_D Sinus (Double) eFA_COS_D Cosinus (Double) eFA_TAN_D Tangens (Double) eFA_ARCSIN_D Arcus-Sinus (Double) eFA_ARCCOS_D Arcus-Cosinus (Double) eFA_ARCTAN_D Arcus-Tangens (Double) eFA_PI_D Pi (Double, direkt auf den Stack; Tipp: Realisation mit 4*Arctan(1)) eFA_PWR_D Allgemeine Potenzfunktion a^b (Double) eFA_DQR_D Quadratfunktion a^2 (Double) eFA_DQRT_D Quadratwurzel (Double) eFA_EXP_D Exponentialfunktion (natürlich) e^x (Double) eFA_LOG_D Logarithmus zur Basis 10 (Double) eFA_LN_D Natürlicher Logarithmus (Double) eFA_ABS_D Betragsfunktion (Double) ----------------------------------------------------------------------------------------------------------- V0.53, 080704 - Stabilität LiveParser verbessert - Stabilität ScrollBar-Manager verbessert (auch Plausibilität der Daten in den INF-Files) - Flimmer- und Flackereffekte durch zwei Massnahmen verbessert (Optimierung Refresh und Verwendung von Doppelpufferung {nur ab Win XP!}) - LiveParser-Verarbeitung der ersten Zeile sichergestellt - neue Option "Ignore Case" für Variablen, Register und Konstanten. (in "Options" erklärt.) Für Dich und alle PowerUser: neue Option "Ignore Case" abschalten und "Auto Case standardisation" einschalten) Dies löst das Problem des AutoCase für Register, Variablen und Konstanten. - Fehlerhaftes Einfärben von Bezeichnern im Kommentar behoben - Horizontales Scrollen wird nun ebenfalls unterstützt und im INF-File abgelegt - Horizontales Springen im Editor beim LiveParsing behoben - Effizienz Blockmodus des LiveParsers um etwa 20% erhöht. (Synchronisation mit UNDO-Management und anderen Prozessen) Bemerkung: Beim LiveParsing grosser Files ist oft eine leichte vertikale Verschiebung zu bemerken. Dies kann nicht verhindert werden! Dieser Effekt hängt damit zusammen, dass der Scrollbar nur eine UINT16-Zahl ist und damit die Position ungenügend fein auflöst. ----------------------------------------------------------------------------------------------------------- V0.52, 080613 - Editor komplett überarbeitet: --- UNDO/REDO optimiert, Scrollpositionen werden restauriert --- optimierter UNDO/REDO-Einsatz (drastische Reduktion der Wartezeit zwischen Tastendrücken) --- Liveparse-Einsatz optimiert, Blockmodus eingeführt, störender Springeffekt des Fensters behoben --- rascheres Laden der Files --- Session-Info (für jedes File wird die aktuelle Position und die Scrollposition gespeichert und wiederhergestellt) --- OpenFile Statusmeldungen - TreeView-Generator verbessert: Filenamen werden korrekt wiedergegeben, ALLE INC-Dateien werden angezeigt - LiveParser-Leistung gesteigert - Compiler: Fehler in Variablenverwaltung behoben (keine "dummy-Variablen" mehr notwendig) - Compiler: Fehler in Codeblockverwaltung behoben (unter Umständen keine Fehlermeldung, wenn ausserhalb gültigem Codeblock Anweisungen enthalten waren) WICHTIGE GEBRAUCHSANWEISUNG - Unbedingt nach Änderungen am EPR die Projektdatei kompilieren. - Änderungen am EPR erfordern ebenfalls ein Neukompilieren der View 1, selbst wenn dort keine Änderungen vorgenommen wurden! (In der View 1 sind der globale Code und die globalen Datenstrukturen enthalten) ----------------------------------------------------------------------------------------------------------- V0.51, 080514 - LiveParser Performance stark verbessert (stellenweise neu programmiert und optimiert) - Intellisensefunktion neu programmiert, Performance stark verbessert - LiveParser umfasst nun Markierung von Konstanten, Variablen und Registern - Syntaxleiste: Syntaxhinweis bleibt stehen, bis Zeile verlassen wird - LIST-File-Generator neu erstellt (Fehlfunktion bei unterschiedlicher MainLoop-Position ----------------------------------------------------------------------------------------------------------- V0.50, 080123 - Fehler behoben: Variablenbasisadresse von Views ohne Variablendeklaration war undefiniert - Fehler behoben: Exponentenschreibweise von Fliesskommazahlen ----------------------------------------------------------------------------------------------------------- V0.49, 080122 - Auffrischung des Methods-Balkens neu auch bei eindeutiger Übereinstimmung (Änderung der Anzeigeregel: vorher wurde NUR dann angezeigt, wenn keine weitere Entsprechung in der Liste mehr vorkam) - Stringzuweisung str:='Test' funktioniert nun auch OHNE Leerschlag (Problem war: Fehler in der Erkennung von offenen Strings) - Push_I_L: Immediate-Long übergibt vier-Byte-Zahl statt drei-Byte-Zahl (falsche Längenübergabe in der AddCompiledCommand-Funktion) - Stringzuweisung auch EVAL_STACK korrekt (EVAL_STACK wirkt bei STRING-Variablen nicht) ----------------------------------------------------------------------------------------------------------- V0.48, 080104 - Fehler behoben: Adressberechnung der Variablenstruktur ----------------------------------------------------------------------------------------------------------- V0.47, 071224 Die vier folgenden neuen Keywords sind neu eingeführt worden. COMPILER EVAL_STACK COMPILER EVAL_STANDARD COMPILER VARBASE_ZERO COMPILER VARBASE_STANDARD "EVAL_STACK": forciert die Stack-Evaluation (verhindert MOVE und Zwei-Operatoren-Funktionen) "VARBASE_ZERO": setzt die Variablenbase auf Null. Dies ist sehr mit Vorsicht zu geniessen. Ich habe auch keine Chance, einen Variablenblock zu schreiben. Somit gibt es keine Initialisierungsmöglichkeit. (Im Kollisionsfall würde nämlich der Code durch die Variablen überschrieben.) "..STANDARD" sind jeweils die Normaleinstellungen. Bei "VARBASE" ist natürlich nur der Linker betroffen, so hat das Umschalten keinen Einfluss auf die Codeerzeugung. Bei EVAL ist dies jedoch sehr sinnvoll, kann man doch einfach zwischen den Betriebsarten umschalten ----------------------------------------------------------------------------------------------------------- V0.46, 081210 - Fehler Compiler (Scannerfehler bei numerischem Ausdruck mit Kommentar in Zeile) - Strenge Identifier-Prüfung - INLINESINGLES (ergibt eine Kette von je 4-Byte-Single-Repräsentationen, können durchaus komplexe Ausdrücke sein; getrennt durch Kommata) - INLINEDOUBLES (ergibt eine Kette von je 8-Byte-Double-Repräsentationen, können durchaus komplexe Ausdrücke sein; getrennt durch Kommata) - Verbesserte Fehlererkennung beim Evaluieren von Fliesskommaausdrücken: INLINESINGLES(1.3*4,12,3,1e34) INLINEDOUBLES(1.3*4,12,3,1e224) (Beide Zeilen werden übersetzt. Schreibt man oben aber 1e224, dann bleibt der Compiler wegen Überlauf stehen) ----------------------------------------------------------------------------------------------------------- V0.45, 071120 - "Speichern" Und "Speichern unter" unterstützt nun auch *.epr-Dateien (ref. Christoph) - INLINELONGS(1,2,3): Angabe einer Liste von LONG-Zahlen (ergibt eine Folge der 4-Byte-Zahlenwerte im Code) - INLINEVARIABLES(a,b,c): Angabe einer Liste von Variablen (ergibt eine Folge der entsprechenden Variablenadressen im Code) - Erkennung der unüblichen Schreibweise "0xFFFFH" (führte zu einem Absturz des Compilers!) - Mapping der positiven Ganzahlenmenge zu negativen Werten (65535 wird zu -1 bei INTEGER), Compilierproblem bei BIKI608.EVS - Erhöhung der maximal angezeigten Methoden in der EigerTip-List von 36 auf 128 (diese Anzahl ist begrenzt) - Globale Systemkonstanten in EigerTip anzeigen (Filter SYSTEM) ----------------------------------------------------------------------------------------------------------- V0.44, 071105 - Kompilation der Stackmaschine überarbeitet, da die Zuweisung der IMMEDIATE-Konstanten nun geändert hat. Der Compiler entscheidet nun, ob er BYTE, INTEGER oder LONG immediate an den Stack übergeben kann. Dies führt zu einem optimal kurzen Code. Die Werte werden als 1, 2 oder 3-Byte-Wort übergeben, direkt und ohne weitere Anhängsel. WICHTIG: Die Zielvariable entscheidet über den Berechnungsdatentyp! Somit wird mit LONG-Operationen gearbeitet, wenn eine BYTE/INTEGER/LONG-Variable verwendet wird. Bei SINGLE wird in SINGLE gearbeitet und bei DOUBLE in DOUBLE. ----------------------------------------------------------------------------------------------------------- V0.43, 071016 - globale Schleifenlabels von lokalen trennen (neue Labelverwaltung für Globalstrukturen) - Verbesserte Erkennung der Scientific-Schreibweise von Konstanten - Ausblenden von Leerzeichen und TAB in EvaluateMath ----------------------------------------------------------------------------------------------------------- V0.42, 070712 - Stackmaschine und einige kleinere Änderungen. - Kollisionserkennung bei Globalviews dürfte nun korrekt funktionieren. - Stringlänge wird nun besser überwacht. Bei Nichtdefinition wird defaultmässig ein String 256 erzeugt. - About-Box verbessert ----------------------------------------------------------------------------------------------------------- V0.41, 070531 - Fehler bei CONST-Evaluation behoben - Verbesserte Fehlermeldungen bei rekursivem Compiling im Log ("Compiler Output"). Bei einem Fehler in einem INCLUDE war die Fehlermeldung oft verschluckt worden. Nun wird die Fehlerstelle korrekt angesprungen und vor allem ist der Compiler-Log vollständig. - Header aller Variablen geändert: alle Zahlen haben eine Headerlänge Null, also KEINEN Header mehr. STRINGS haben nun 24 Bytes Header. Entgegen Deinem Wunsch habe ich die Fehleranalyse nochmals studiert. Gemäss meinen Notizen wurde eine Speicherstelle an der Stelle geändert. Ausnahme: FONT besitzt nach wie vor 8 Bytes Header. - Das Verhalten des TreeView wurde stark überarbeitet. Das Zu- und Aufklappen ist nun intuitiver. Die aktive Datei und ihr Knoten werden farblich hervorgehoben. Das Kontextmenü im TreeView ist ebenfalls überarbeitet und erweitert worden. - möglicher Crash bei einer FLOAT-Initialisierung wurde behoben. - Bessere Rückmeldung bei FullBuild (Zeile "Compiler Output" zeigt Verlauf während des Build) ----------------------------------------------------------------------------------------------------------- V0.40, 070509 Einführung des Projektbegriffs. Jedes Verzeichnis gilt als Projektverzeichnis, das eine Projektdefinitionsdatei "PROJ.EPR" und die Views "PROJ_000.EVS", die INClude-Files, die h-Files und das LIBrary-File enthält. Die Navigation geschieht nun innerhalb des Projektbaums: einfach Auswählen und das File wird geladen. Die vielleicht nervige Nachfrage, ob das alte File gespeichert werden soll, lässt sich im Setup abschalten. Der Editor und der LiveParser wurden in vielerlei verbessert und auch optimiert. Für alte Projekte lässt sich vielleicht keine Verbesserung erkennen; sobald aber ein Projekt in das neue Layout umgeschrieben worden ist, ist die Verbesserung aber augenfällig. Zusätzlich ist das Menü Project - vor allem die Funktion "Build Project" hinzugekommen. Beispiel für eine Projektdefinitionsdatei: - alle IMPORT, FUNCLIB und globalen INCLUDEs gehören in die EPR - Wichtig ist die Definition von GLOBALBASE: dies ist die Startadresse des globalen Blocks - Die anderen Keywords GLOBVARBASE, LOCVARBASE sollen NICHT definiert werden (Diese dienen zum Auseinanderreissen von Variablenblocks und Code) - Das Keyword VIEWBASE muss, falls es überhaupt definiert werden soll, zu Null initialisiert werden. - Die Keywords unterstützen vollständige Stack-Arithmetik und Konstanten - Alle Variablen, die im EPR definiert werden, sind automatisch in allen Views des Projekts sichtbar; sie werden nicht verändert. - Alle SUB, die im EPR definiert werden, sind aus allen Views normal aufrufbar. - Die Keywords BEGINVIEW, ENDVIEW und EIGERVÌEW sind im EPR nicht definiert und dürfen nicht verwendet werden. EIGERPROJECT 'GLOB' ; Projektbezeichnung: erster Teil des EVI-Filenamens IMPORT 'DEF_eVM_OpCodes_0$45.h' ; Tokens IMPORT 'DEF_eVM_Registers_0$45.h' ; Register FUNCLIB 'DEF_eVM_Functions_0$45.lib' ; Funktionsbibliothek INCLUDEFILE 'DEF_eiger_Colors.INC' ; Farbdefinitionen 12.03.2006 INCLUDEFILE 'DEF_eiger_Types_0$45.INC' ; Eiger Definitionen GLOBALBASE 10000 ;GLOBVARBASE 0 ;LOCVARBASE 0 VIEWBASE 0 STRING AuchEinString = 'Dies ist ein Füllstring' STRING MeinGlobalString = 'Dies ist ein globaler String ...' INTEGER MeinGlobalInt = 1 CONST KompilierDatum = $COMPILEDATE SUB SetzeString Str.Clear(MeinGlobalString) IF MeinGlobalInt > 0 THEN MeinGlobalString := $COMPILEDATE ELSE MeinGlobalString := $COMPILETIME ENDIF ENDSUB SUB LöscheString IF MeinGlobalInt > 0 THEN MeinGlobalString := '##########' ELSE MeinGlobalString := '**********' ENDIF ENDSUB SUB InkrementInteger MeinGlobalInt := MeinGlobalInt + 1 ENDSUB SUB DekrementInteger MeinGlobalInt := MeinGlobalInt - 1 ENDSUB Anleitung zum Umschreiben alter Projekte: (dies geschieht am besten mit einem Editor - nicht im ES, da der Liveparser die Arbeit langsam macht) 1. Erstellen einer EPR-Datei aus einer View 2. Die Kopfeinträge EIGERPROJECT IMPORT FUNCLIB INCLUDEFILE GLOBALBASE müssen eingetragen werden. 3. Die Kopfeinträge - vor allem alle IMPORT, FUNCLIB in den Views entfernen. Das Öffnen eines Projektes geschieht entweder automatisch durch Öffnen einer beliebigen View oder aber durch Öffnen der EPR-Datei. (Im Filedialog ist dazu ein neuer Eintrag hinzugekommen. Das beigelegte Beispiel: GLOB ist eine Primitiv-Demo, wie mit globalen Variablen und Subs gearbeitet werden kann. Dabei werden in der AuswahlView globale Variablen verändert, die in den verschiedenen Views ausgegeben werden. Nochmals: Das neue EigerStudio arbeitet in vielen Belangen auf neue Weise als der alte EigerCompiler; auch das Gesicht hat sich ein wenig geändert. Der Evolutionsschritt ist recht gross - noch grösser als bei der Einführung der Variablen. ----------------------------------------------------------------------------------------------------------- V0.39, 071001 (Spezialversion) - Strings sind - wenn nicht initialisiert - 256 lang - die Variablen verwenden die neuen Headers - String: die Leerschlag-Optimierung wurde ersetzt durch eine neue Version - NIL: dies müsste funktionieren. ACHTUNG: NIL ist ein Label und keine Konstante. Sie darf damit NICHT einer Variablen zugewiesen werden. Nützlich sind die Systemkonstanten: $COMPILETIME : gibt die aktuelle Uhrzeit des Compilerlaufs zurück (18:35:05) $COMPILEDATE : gibt das aktuelle Datum des Compilerlaufs zurück (20.09.2007) $SYSVERSION : gibt die Version des Compilers zurück (V 0.39) $SYSRELEASE : gibt den Releasestring des Compilers zurück (2007-10-01) ----------------------------------------------------------------------------------------------------------- V0.38, 070220 - Fehler "0x0000" behoben - Laufweitenfehler nach Compilefehler behoben - verbesserte Erkennung von Zuweisungsfehlern - erweiterte Statusmeldungen - "Compilerdirektiven" : $COMPILETIME : gibt die aktuelle Uhrzeit des Compilerlaufs zurück (18:35:05) $COMPILEDATE : gibt das aktuelle Datum des Compilerlaufs zurück (20.02.2007) $SYSVERSION : gibt die Version des Compilers zurück (V 0.38) $SYSRELEASE : gibt den Releasestring des Compilers zurück (2007-02-20) Diese Direktiven arbeiten wie Konstanten; nach einem Compiliervorgang wird sogar der Tooltip nachgeführt. Sie sind Stringkonstanten und können nicht in numerische Werte gewandelt werden. ----------------------------------------------------------------------------------------------------------- V0.37, 070215 - Fehler Stringverabeitung behoben. - Compilerfehler bei "leerer" Zuweisung behoben ----------------------------------------------------------------------------------------------------------- V0.36, 061212 - Fehler in Batchcompiler behoben ----------------------------------------------------------------------------------------------------------- V0.35, 061212 - String-Escape-Handler neu: einzelstehende "\" werden direkt übernommen, falls kein gültiger Escape-Code folgt. - Zuweisung einer negativen Zahl zu einer allgemeinen Variablen ist nun möglich (Zuweisung zu einem Register war bereits möglich) - Überprüfung der Filenamenkonsistenz: wie bei Modula2 muss nun der Filenamen mit den EIGERPROJECT/EIGERVIEW-Parametern übereinstimmen. - Konstantenauswertung in Zuweisung zu einer Variablen stabilisiert - Comment / Uncomment-Funktion funktioniert nun richtig (fehlerhafte Fehlerbehandlung hat falsche Zeilennummern erzeugt) - LOOP / ENDLOOP (Endlosschleife) mit EXITLOOP - WHILE / ENDWHILE mit EXITWHILE - REPEAT / UNTIL mit EXITREPEAT - FOR a TO b / NEXT mit EXITFOR - FOR i := a TO b / NEXT mit EXITFOR - FOR i := a TO b STEP c / NEXT mit EXITFOR (Zu den Schleifen bitte kurz die Dokumentation lesen...) Jedes Schleifenkonstrukt kann unabhängig von den anderen bis zu einer Tiefe von 256 geschachtelt werden (erst dann würde eine Fehlermeldung "too complex" auftreten). Jedes Schleifenkonstrukt kann unabhängig von seiner Stellung relativ zu anderen verlassen werden. Die Unterscheidung der EXIT-Schlüsselworte ermöglicht es sogar, Schleifen auf einer höheren Ebene zu verlassen (dies ist keiner anderen Sprache so flexibel gelöst). ----------------------------------------------------------------------------------------------------------- V0.34, 061108 - Problem mit der Sprungzielberechnung bei rekursiven Compilerläufen behoben! - LIST-File enthält nun ALLEN Code, inklusive INCLUDEs - Bei Compilerfehler werden nur Sourcecode-Files angesprungen - Fehlermeldungen bei rekursiven Files sind aussagekräftiger - Nach Korrektur eines INCLUDEs wird durch Restart des Compilers erst NUR das Top-File geöffnet. Nochmaligen Compilerstart führt dann den Compilevorgang aus. (Meldung erscheint) - Ungleich-Operator ergänzt: <> UND != bedeuten nun "ungleich" in IF-Anweisungen - Zuweisung eines Strings, der "="-Zeichen enthält, ist nun möglich - Stringzuweisung geprüft; funktioniert meiner Meinung nach korrekt - Strings dürfen nun Escape-Zeichen enthalten: 'Ersetzen von "\"-ESCAPE-Sequenzen 'Folgende ESCAPE-Sequenzen werden unterstützt: ' '\n Newline (LF) '\r Return (CR) '\t Tabulator (HT) '\\ Backslash '\CR Carriage Return (CR) '\LF Line Feed (LF) '\ESC ESCAPE (CHR(27)) '\TAB Tabulator (HT) '\0xhh HEXCODE hh als Zeichen ' ----------------------------------------------------------------------------------------------------------- V0.33, 061011 - CONFIG-File (Options werden automatisch abgespeichert) - VarInt und VarLong: neue Immediate-Adressierung: -32678...32767 -> &FExxxx / 32768...65536 -> &F9xxxx (darüber für VarLong: Konstante Variable) ----------------------------------------------------------------------------------------------------------- V0.32, 061005 - KeyHandler zur Direktübernahme aus dem Tooltip entfernt - ToolTip erscheint beim Klicken auf eine Konstante oder Variable und beim Tippen ab mindestens 3 Buchstaben langen Bezeichnern. - Zeilenzähler-Fehler in INCLUDEFILE behoben. Hier ein wichtiger Hinweis: Du kannst INCLUDEFILE beliebig tief schachteln. - In Kaskaden von INCLUDEFILE wird das fehlerverursachende File geöffnet und die fehlerhafte Zeile markiert. - Der Compiler lädt bei nochmaligem Compilieren wieder das ursprüngliche File, falls ein INCLUDEFILE-Fehler pendent war. - LIST-File-Generator, zusätzlich zum MAP-File. - MAP/LIST-File-Generation ist in "Options" abschaltbar. Default ist AUS. - IF-Anweisungen unterstützen LONG und INT. Variablen und Konstanten sind beliebig mischbar, müssen jedoch schliesslich vom gleichen Typ sein. Aufwändige Fehlerüberprüfung. - Strenge Parametersatz-Überprüfung in Funktionen. Gebrauch muss LIB-Fileeintrag exakt matchen. - kleinere Fehler behoben und Code-Optimierungen Der Aufbau des LIST-Files ist wie folgt: bis zum Doppelpunkt: die Zeilennummer im Sourcefile als Dezimalzahl (nützlich für den Editor im EigerScript) nach dem Doppelpunkt: die Adresse des ERSTEN folgende Bytes als 24bit-Hexzahl, gruppiert in eckigen Klammern nach einem folgenden Leerschlag: die Codebytes, gruppiert nach Grösse (1, 2, 3 oder 4 Bytes). ACHTUNG: Die Bytefolge ist IDENTISCH mit der im File, also BigEndian 542 : [000534H] [0333] [0000FC] 543 : [000539H] [2421] [5C3400] [0000FC] 544 : [000541H] [0E58] [0000FC] 545 : 546 : [000546H] [4923] [48] [53] [5F] [43] [61] [73] [65] [5F] [55] [70] [20] [00] [8700FC] 547 : [000557H] [4923] [20] [65] [49] [2E] [53] [74] [61] [63] [6B] [50] [6F] [69] [6E] [74] [65] [72] [00] [6900FC] Die letzte Zeile ist ein Debug.Print_IntegerHex-Befehl: Adresse, Opcode, String und schliesslich Adresse (in diesem Fall ein Register) ----------------------------------------------------------------------------------------------------------- V0.31, 060929 - MAP-File erweitert: Compilierzeit, Compilerversion, Codegrösse (Programm), Variablenbase, Codegrösse (Total), "schönere" Ausgabe - Labellängen-Überwachung ersetzt durch Überwachung des Überlaufs. Nun sind verschiedene Labellängen möglich - Immediate-Adressierung bei VarByte, VarInt und VarLong nachgereicht. FE bei VarByte, F9(pos)/F7(neg) bei Int/Long - Problem "leerer String" behoben - berechnete CONST-Deklarationsketten funktionieren nun sowohl als String als auch numerisch ----------------------------------------------------------------------------------------------------------- V0.30, Rel. 060912 - Release Notes - Compiler erzeugt ein MAP-File mit gleichem Namen und der Endung *.MAP. - Funktion GotoLine kann nun abgebrochen werden. - Label können beliebige Länge aufweisen. Allerdings dürfen die Längen des gleichen Labels nicht gemischt werden. - HINWEIS: Numerische Formate mit führendem "&" also (&H1A, &O12 oder &B1001) sind ab sofort verboten. (Math-Evaluation sonst nicht möglich) - Evaluation aller konstanten Ausdrücke in beliebigen Formaten. Die Ausdrücke werden grundsätzlich in Double-Arithmetik berechnet und je nach Typ/Anforderung gerundet eingesetzt. Als Operatoren zugelassen sind: ( ) + - * / ^ UND & als String-Concat-Operator. Als transzendente Funktionen werden unterstützt: pi() (Rückgabe von Pi, doppeltgenau) sin(x) (Sinus, Argument im Bogenmass) cos(x) (Cosinus, Argument im Bogenmass) tan(x) (Tangens, Argument im Bogenmass) arcsin(x) (Arcussinus, Rückgabe erfolgt im Bogenmass) arccos(x) (Arcuscosinus, Rückgabe erfolgt im Bogenmass) arctan(x) (Arcustangens, Rückgabe erfolgt im Bogenmass) sqrt(x) (Quadratwurzel, "Square root") exp(x) (Exponentialfunktion zur Basis e, der Eulerschen Zahl 2.71828183) log(x) (Logarithmus zur Basis 10) ln(x) (natürlicher Logarithums zur Basis e) abs(x) (Absolutwert) sgn(x) (Signum-Funktion) round(x) (auf ganze Zahl runden) - CONST: NEU können beliebige mathematische Ausdrücke oder String-Ausdrücke eingesetzt werden. Beispiel: CONST meinTest = 'Das Ergebnis heisst: " & sin(30/180*pi())+1 - STRING: NEU kann die Stringlänge auch als mathematischer Ausdruck eingesetzt werden. Beispiel: CONST meinTest[12*Untergrenze] = "Test" - VARIABLEN: Initialisierung auch als mathematischer Ausdruck möglich. Beispiele: CONST Radius = 3+5 INTEGER Umfang = 2*pi()*Radius - Var-Parameter: Übergabe des Variablennamens oder aber eines konstant zu evaluierenden Ausdrucks. - Var-Parameter: Konstante Angaben führen zur Allokation einer Variablen (wie bereits bei den VarString-Parametern). Dabei werden bereits vorhandene konstante Werte nach Möglichkeit wiederverwendet. Bei Fliesskommavariablen (SINGLE und DOUBLE) wird dabei die Präzision berücksichtigt! - Zuweisungen werden neu wie folgt umgesetzt (ACHTUNG! Diese Neuerung muss noch sauber getestet werden. Der Code wird meiner Meinung nach korrekt erzeugt): --- Register: normale "alte" Zuweisung mit Evaluation eines konstanten Ausdrucks --- Variablen Typ a:=b wird durch eine Math.MOVE_Type-Anweisung übersetzt --- Variablen Typ a:=b#c werden durch eine Math.[Operation]_Type-Anweisung übersetzt ... komplexe Ausdrücke sind vorbereitet, aber noch nicht umgesetzt. Die Adressierungsart "STACK" werde ich nicht benötigen. Dazu wünsche ich Befehle (für alle Variablentypen) wie: Stack.Push_Integer(variable) Stack.Pop_Integer(variable) und Rechnungsbefehle nach folgendem Muster: Stack.ADD_Integer() Die komplexen Ausdrücke werden vorkompiliert, genau wie auch die einfachen Ausdrücke vorkompiliert werden. - EigerTip Methodenzeile oberhalb des Editorbereichs ergänzt - Die Unterscheidung Register und Variable ist nun streng durchgesetzt. (Im Normalfall ist dies nicht zu bemerken, da die Adressierungsart "REGISTER" verwendet wird) Somit ist nun die klare Deklaration mit ";$+REGISTER" im Headerfile Pflicht. - VarByte und VarInt werden neu auch immediate adressiert. ----------------------------------------------------------------------------------------------------------- V0.29, 060807 - NEU: Wandlung einer numerischen Angabe in den ursprünglich angegebenen String. - NEU: bessere Information für Variableninhalt und Konstante in EigerTip - NEU: ToolTip arbeitet erst aber einer Wortlänge von drei Buchstaben und beschränkt auch die maximale Wortlänge. Dadurch ist die Funktion wesentlich weniger "nervös". Noch eine kleine Erklärung zu den Konstanten: Konstanten sind eigentlich nur Platzhalter für Textstellen im Sourcecode direkt - eigentlich wie kleine INCLUDEs. Beispiele: CONST eins = 1 CONST zwei = '2' CONST drei = 011B Der Compiler merkt nun, dass "eins" direkt numerisch interpretierbar ist. Sobald im Sourcecode "eins" verwendet wird, setzt der Compiler die Zahl 1 ein, falls "eins" numerisch gebraucht wird. Wird "eins" aber an Stelle eines Strings verwendet, setzt der Compiler die Ziffer "1" dafür ein. In diesem Falle existiert der String noch nicht; er wird also als versteckte Variable deklariert und mit "1" initialisiert. "eins" wird als numerische Konstante markiert. "zwei" ist unmittelbar als String interpretierbar (wegen den Hochkommas) und wird somit als nicht numerisch geführt. Falls aber "zwei" als Parameter an Stelle eines "VarInt" eingesetzt wird, versucht der Compiler eine numerische Wandlung des Strings. (ACHTUNG: NUR VarInt; alle anderen Variablen können keine Konstanten wandeln ) "drei" wird direkt numerisch in 3 umgewandelt. Die Stringrepräsentation wird NEU als '011B' eingesetzt (früher auch 3). Die lokalen (überladenen) Konstanten in SUB werden NICHT im EigerTip nachgeführt. ----------------------------------------------------------------------------------------------------------- V0.28, Rel. 060804 - Font Default auf Courier 9pt - Font Auswahl-Dialog steht jetzt auf aktuellem Font Alle drei Eiger-Tip-Blöcke erfüllen neu folgende Punkte: - sortierbar, Selektion geht nicht verloren - Selektion per Einfachklick - Übernahme in EVS-File an aktueller Position per Doppelklick ----------------------------------------------------------------------------------------------------------- V0.27 Rel. 060727 - ENDVIEW und ENDSUB alternativ zu EndView und EndSub - ELSE ist fakultativ. (Fehler bei zusätzlichem ELSIF führte dazu, dass eine Ansprungmarke nicht gesetzt wurde) - Zuweisung zu einer Stringvariablen klappt nun korrekt. Der Fehler entstand infolge Typinkompatibilität bei Variablen. (Im Beispiel existierte eine andere Variable, die mit dem Wert "navy" initialisiert war - allerdings vom Typ INTEGER. Daraus resultierte der falsche Pointerwert) - STRING-Initialisation: Fehler wegen Stringexktraktion aus der stufenweise vorverarbeitenden Kommandozeile. ----------------------------------------------------------------------------------------------------------- V0.26, 060707 -NEU: EigerTip-Suite Das Feld unterteilt sich in drei Fenster. Aus allen dreien kann per einfachem Mausklick der aktuelle Eintrag übernommen werden: 1. das oberste Fenster (rötlich) ist das Methoden-Tipp-Fenster und wird dynamisch nachgeführt. 2. das mittlere (bläulich) ist das Konstanten-Fenster und enthält die GLOBAL definierten Konstanten. (Die LOKALEN Konstanten werden nie beachtet - zu störungsanfällig und zu unklar, weil abhängig von Cursor-Position). Mit der Combobox kann das File ausgewählt werden, wo die Konstanten tatsächlich DEFINIERT sind. Das Ganze funktioniert also über die per INCLUDEFILE eingebundenen Files. 3. das untere (grünlich) enthält die Variablen oder Register (umschaltbar). Umschalten mit dem Knopf "Regs" oder "Vars" (der ändert sein Gesicht). Was ist ein REGISTER? Als Register werden Token angesehen, die NACH einer ;$+REGISTER -Direktive im Headerfile stehen. Dies gilt bis ans Ende des Headerfiles ODER bis zum Auftreten der abschaltenden ;$-REGISTER -Direktive. Beispiel: (Auszug aus Header-File) EI_Int_0 EQU 0 ;Beschreibung ;$+REGISTER EI_Int_1 EQU 1;Beschreibung EI_Int_2 EQU 2;Beschreibung ;$-REGISTER EI_Int_4 EQU 3;Beschreibung Als Register erkannt werden ausschliesslich EI_Int_1 und EI_Int2 - die anderen sind "nur" gewöhnliche Tokens. ----------------------------------------------------------------------------------------------------------- V0.25, Rel. 060629 Der Editor ist wesentlich schneller. Die Arbeitsgeschwindigkeit wird erst ab Files mit deutlich mehr als 2000 Zeilen merklich langsamer. Trotz dieser Änderung sind ToolTip für die Variablen (erst nach einem Compilerlauf !!!), EigerTip (neu am rechten Fensterrand) und vor allem UNDO/REDO immer noch in der selben Weise funktionstüchtig. UNDO/REDO hat nun eine Puffergrösse von 128/64 Aktionen !!! EigerTip lässt sich online sortiert oder unsortiert darstellen. Dazu steht eine Checkbox gerade unterhalb des EigerTip-Bereichs zur Verfügung. Durch Klick auf einen EigerTip-Eintrag wird dieser übernommen und der Cursor sofort nach dem neuen Eintrag positioniert. Man kann somit einfach weiterschreiben. ----------------------------------------------------------------------------------------------------------- V0.24, 060622 - Datentyp LONG (statt LONGINT) als 32 Byte-Integer - Numerische Analyse bei 32 Byte hatte ein Problem: dies habe ich gelöst. Du kannst nun Zahlen im vollen Bereich in allen Formaten wandeln - Die Konstante "NIL" funktionierte bei LONG nicht. Dies wird nun speziell abgefangen. - Die Eigertyp-Funktion arbeitet nun auf eine neue, mir am besten erscheinende Art: das Blinkverhalten sollte sich nun drastisch gebessert haben. Ausserdem bewegt sich das Fenster nicht mehr weiter, sondern bleibt am Ort des ersten Auftauchens "kleben". ----------------------------------------------------------------------------------------------------------- V0.23, 060620 - Der Editor unterstützt nun einen RTF-Modus: RTF kann gespeichert werden und RTF kann auch geöffnet werden. Der Liveparser ist im RTF-Modus notwendigerweise ausgeschaltet. - Comment/Uncomment-Funktionen sind optimiert; diese laufen nun rund dreimal schneller - " " ist nun auch als Parameter anstelle einer i-Konstante erlaubt. - SINGLE (statt REAL) und DOUBLE-Datentypen - NIL: Berechnungsfehler in allen drei Varianten behoben - EigerTip (Intellisense) für Funktionen (*.LIB-Datei!); eine weitere grosse Neuerung! - Stringlängenangabe mit eckigen Klammern statt runden - ToolTip im Editor: zeigt Informationen zu Variablen (allerdings erst nach einem Compilerlauf!); als Ergänzung zum EigerTip Speziell: sobald genau EIN Eintrag zu sehen ist, kann mit der TAB-Taste der Eintrag übernommen werden! - LIB-Datei: Einträge mit führendem Stern (*) werden NICHT in EigerTip angezeigt. Kommentar kann mit einleitendem Strichpunkt eingesetzt werden. Beschreibungen zu den Parametern lassen sich nach einem Doppelpunkt NACH dem Parametertyp angeben. Beispiel: HotKeyInstall(i:Tastencode,procName:Aufzurufende Funktion) ;Hier ist die Beschreibung Achtung: Bitte in den Beschreibungen keine Satzzeichen verwenden (; und , sind bereits verboten) ----------------------------------------------------------------------------------------------------------- V0.22, 060606 - komplett neue Sprungzielberechnung. ----------------------------------------------------------------------------------------------------------- V0.21, 060602 ----------------------------------------------------------------------------------------------------------- V0.20, 060601 Die Syntax sieht aus wie besprochen: IF [VarInt] [Operator] [VarInt] THEN ... ... ... ELSIF [VarInt] [Operator] [VarInt] THEN ... ... ... ELSE ... ... ... ENDIF - Die IF-Strukturen sind BELIEBIG schachtelbar - bis zu einer maximalen Tiefe von 256! Auch ELSIF sind in einer BELIEBIGEN Anzahl möglich. - Die Syntax-Prüfung ist wieder stark angewachsen Untenstehendes Beispiel wird problemlos kompiliert! Alle üblichen Operatoren (==, !=, >=, <=, <, >) werden dabei unterstützt. (Dabei sind dies erst 5 der 256 unterstützten Ebenen!) IF xx == yy THEN IF xx == yy THEN ELSIF zz==yy THEN IF xx == yy THEN ELSIF zz==yy THEN IF xx == yy THEN ELSIF zz==yy THEN ELSIF ww==zz THEN IF xx == yy THEN ELSIF zz==yy THEN ELSIF ww==zz THEN ELSE ENDIF ELSE ENDIF ELSIF ww==zz THEN ELSE ENDIF ELSIF ww==zz THEN ELSE ENDIF ELSIF zz==yy THEN ELSIF ww==zz THEN ELSE ENDIF Neu: IF 27>26 THEN Debug.Mark('') ELSE Debug.Mark('') ENDIF Statt: ; ; IFINT_GT_THEN (Test_ELSE_10,27,26) ; Debug.Mark('') ; JumpRelative(Test_ENDIF_10) ;Test_ELSE_10: ; Debug.Mark('') ;Test_ENDIF_10: - Eiger, Finished: hatte einen Fehler; darum wurde das nicht immer korrekt umgesetzt (Deshalb die LOOP: Jump(LOOP)-Zeile) - Längenangaben in den Variablen korrigiert; die war um ein Byte zu gross. ----------------------------------------------------------------------------------------------------------- V0.19, 060524 - FONT-Funktion (neues Keyword) Variablendefinition: FONT MyZeichen = 'Fontdatei.EFF' Benutzung: Label.SetFont(MyZeichen) - wählbarer Font in "Options" für den Editor. ----------------------------------------------------------------------------------------------------------- V0.18, 060508 ----------------------------------------------------------------------------------------------------------- V0.17, 060502 ----------------------------------------------------------------------------------------------------------- V0.16, 060502 - Eine relative Sprungzielangabe bezieht sich immer auf den Adresszeiger des aktuellen Opcodes (Werden mehrere Sprungzielangaben gefordert, bleibt die Berechnungsbasis konstant) Somit müsste folgende (rein akademische) Zeile Hierher: JumpRelativeMultiple(Hierher, Hierher, Hierher) wie folgt übersetzt werden: AAAB 0000 0000 0000 (Annahme: Opcode von JumpRelativeMultiple wäre AAAB) Zur Compilierzeit, letzter Pass, ist die Information, ob nun ein Opcode oder ein Datum eingesetzt wird, vollständig verloren. Dann werden nur die einzelnen Kompilatseinheiten in der richtigen Reihenfolge aneinandergereiht. Das muss auch dann richtig funktionieren, wenn INLINE- und INCLUDE-Anweisungen mittendrin stehen und auch dann, wenn relative Sprünge über Prozedurgrenzen hinweg ausgeführt werden sollen. Der Trick besteht nun darin, Block- und Zeilennummerninformation jedem einzelnen Byte mit zu hinterlegen. Sobald sich nun eine (oder beide) der beiden Nummern ändert, weiss der Compiler, dass ein neuer Opcode kommen MUSS, dessen Adresse als Basisadresse beim Übersetzen mitläuft. Ein relativer Sprung auf einen Label ist nun einfach durch ein Flag markiert: von der Sprungweite wird in diesem Fall die Basisadresse subtrahiert. ----------------------------------------------------------------------------------------------------------- V0.15, 060420 ----------------------------------------------------------------------------------------------------------- V0.14, 060419 Einführung von relativen Sprüngen: Als Basis gilt das erste Byte nach dem aktuellen 16bit-Opcode (also Adresse(Opcode) + 2) - Neue Parameter: * labelRelative: Angabe eines 24bit-Sprungziels mit relativer Sprungweite (FDxxxx) * labelAbsolute: Angabe eines 24bit-Sprungziels mit absoluter Sprungzielangabe (yyxxxx) (Unterschied zu "label": label gibt eine absolute 16bit-Sprungzieladresse an) * procRelative: Angabe einer 24bit-Funktionsadresse mit relativer Sprungweite (FDxxxx) * procAbsolute: Angabe eines 24bit-Funktionsadresse mit absoluter Sprungzielangabe (yyxxxx) (Unterschied zu "procName": procName gibt eine absolute 16bit-Sprungzieladresse an) - Erweiterung Parameter VarInt: * 1. Normal: Versuch, den Pointer gemäss Variablendeklaration einsetzen (yyxxxx) * 2. Registeradressierung: Versuch, das Token zu finden: (FCxxxx) * 3. Konstantenangabe lokal: Versuch, in numerische integer-Repräsentation zu wandeln (FExxxx) * 4. Konstantenangebe global: Versuch, in numerische integer-Repräsentation zu wandeln (FExxxx) * 5. konstanter Wert: Versuch, in numerische integer-Repräsentation zu wandeln (FExxxx) (VarInt ist nun sehr komplex geworden: der Programmcode zur Analyse des Parameters VarInt umfasst nun etwa 130 Zeilen; darin ist die Interpretation eines Ausdrucks noch gar nicht enthalten!) - Problem "leerer Tab" oder "leeres Leerzeichen" zwischen Funktionen gelöst (Compilerfehler) - einige Fehlermeldungen verbessert - Programmrückmeldungen (Messageboxes) verbessert ----------------------------------------------------------------------------------------------------------- V0.13, 060409 - negative Zahlen funktionieren nun auch in Zuweisungen. - Find-Übernahme funktioniert wie vorgesehen. - Undo-Problem ist tatsächlich problematisch! Einerseits bleibt der Knopf gedrückt , andererseits scheint das Liveparsing mit dem manuellen Gebrauch in Konkurrenz zu treten. ----------------------------------------------------------------------------------------------------------- V0.12, 060405 - File-Filter angepasst. - Eine nützliche Funktion im Menü Compiler: ShowVariables. Damit kann nach einem Compilerlauf die Variablenliste inspiziert werden. - Parametertypen für die Lib-Datei heissen: VarStr, VarInt, VarByte, VarLong, VarReal - CONST-Deklaration: automatische Stringrepräsentation bei numerischem Wert ergänzt. - Funktion "RemoveSpaces" zur Leerstellenentfernung wirkt nun nur ausserhalb Strings in Hochkomma. (dabei sind beliebig geschachtelte Hochkomma erlaubt) Der Fehler mit den geschluckten Spaces ist nun behoben. - Schlüsselwort "register" alternativ zu "nameVariable" in Parameterlisten ergänzt. - Das zentrale Thema dieses Releases ist die Variablenverwaltung mit 24bit-Pointer und Header gemäss Dokumentation. * STRING: - Deklaration - Speicherverwaltung - 4Byte-Pointer (Huge-Memory) - Initialisation wahlweise (direkt oder per CONST) - Initialisation auch numerisch (automatische Repräsentationswandlung) - Stringlänge bei Bedarf vordefinierbar (Länge exkl. Terminator) Gebrauch: STRING (Länge) Name = 'Initialisation' * INTEGER: - Deklaration auch von Arrays (mit Komma getrennt) - Speicherverwaltung - 4Byte-Pointer (Huge-Memory) - Initialisation wahlweise (direkt oder per CONST), modulo 65536 - Array vorbereitet (Byteanzahl = Länge * 2) Gebrauch: INTEGER Name = 123 * BYTE: - Deklaration auch von Arrays (mit Komma getrennt) - Speicherverwaltung - 4Byte-Pointer (Huge-Memory) - Initialisation wahlweise (direkt oder per CONST), modulo 256 - Array vorbereitet (Byteanzahl = Länge) Gebrauch: BYTE Name = 123 * LONGINT: - Deklaration auch von Arrays (mit Komma getrennt) - Speicherverwaltung - 4Byte-Pointer (Huge-Memory) - Initialisation wahlweise (direkt oder per CONST) - Array vorbereitet (Byteanzahl = Länge * 4) Gebrauch: LONGINT Name = 123234 * REAL - Deklaration (im Format IEEE 754-1985 "single") - Speicherverwaltung - 4Byte-Pointer (Huge-Memory) - Initialisation wahlweise (direkt oder per CONST) - Array vorbereitet (Byteanzahl = Länge * 4) Gebrauch: REAL Name = 123.345e-6 * Neue Funktionsparametertypen (entsprechend der Deklarationen): - VarStr: 24bit-Pointer auf Stringvariable - VarInt: 24bit-Pointer auf Integervariable - VarByte: 24bit-Pointer auf Bytevariable - VarLong: 24bit-Pointer auf Longint-Variable - VarReal: 24bit-Pointer auf Real-Variable * Strenge Typenprüfung für Variablen der Typen INTEGER, BYTE, LONGINT, REAL und STRING * Compiler legt initialisierte Variablentabelle anschliessend an EVI-Code an. * REGISTER - Deklaration von Integer-Registern im Registerbereich (Zugriff 16bit wie Token) - ermöglicht Nutzung der normalen Funktionen mit selbstdeklarierten Variablen * POINTER-ARITHMETIK - Pointer sind 24bit breit (statt 32bit wie bis anhin) - auch Zugriff auf Register (Parametertyp register oder obsolet nameVariable) neu 24bit. - neue GENERELLE Definitionsart für Integer-Zahlen. * Neue Möglichkeit zur Angabe von numerischen Konstanten: "A" wird als 65 übersetzt. Dabei wird ein Einchar-String innerhalb von " als Ausnahme vorausgesetzt. ACHTUNG! " " wird als NICHT numerisch interpretiert und erzeugt eine Fehlermeldung. Es ist NICHT möglich, einen Leerschlag in eine numerische Repräsentation zu wandeln. - Einschränkung von Filetypen bei Editor und Compiler - Neue Menüfunktion (und Button): Batch Compiler ----------------------------------------------------------------------------------------------------------- V0.11, (kein Release) ----------------------------------------------------------------------------------------------------------- V0.10, 060313 - Fehler in Zahlenumwandlung behoben V0.9, 060302 - zwei neue Befehle wurden hinzugefügt: INLINETOKENS() und INLINELABELS(). Beispiele: ........ CONST MaxInt = 0FFFFH CONST CRLF = 0A0DH BEGINVIEW INLINEWORDS(CRLF) INLINECHARS('TOKENS') INLINETOKENS(EI_Int_5, EI_Width) INLINECHARS('LABELS') INLINELABELS(ShowCalc1, ShowCalc2) INLINECHARS('END') ........... Alle INLINE-Befehle sind robust gegenüber Leerzeichen. Somit dürfen Leerzeichen vor und nach den Kommas eingesetzt werden. INLINETOKENS: setzt die Tokenwerte in den Bytecode ein. INLINELABELS: setzt im dritten Compilerpass die Sprungzieladressen ein. Dieser Befehl ist naturgemäss sehr gefährlich. Es stehen keinerlei Hilfen zur Verfügung (ausser der Prüfung auf Vorhandensein des Labels) ============================================== - Weiter wurde ergänzt: Parametertypen i und b: beide übersetzen wie folgt: 1. lokale Konstantendeklaration falls nicht: 2. globale Konstantendeklaration falls nicht 3. numerische Repräsentation (Wandelbares Zahlenformat) falls nicht 4. Tokenwert falls nicht 5. Fehlermeldung und Abbruch "Token nicht gefunden" ----------------------------------------------------------------------------------------------------------- V0.8, 060302 - LiveParser wird nun korrekt angestossen (Flagfehler behoben) - INLINEWORDS eingebaut - Die drei INLINE-Keywords arbeiten nun auch mit Konstanten. INLINEWORDS und INLINEBYTES arbeiten recht symmetrisch. Der Code: CONST Test = 15 INLINEWORDS(1,-1,Test,00FAH) wird so übersetzt: 0100 FFFF 0F00 FA00 Bei INLINEBYTES/WORDS wird der gültige Zahlenraum begrenzt: von -128 bis 256 resp. -32768 bis 65535, wobei die negativen Zahlen einfach oben hineingefaltet werden. Gibt man einen zu grossen Wert ein, wird der Zahlenraum erst mit einer MOD-Anweisung begrenzt. - Bei INLINECHARS gilt ab sofort Apostroph-Zwang: INLINECHARS('MeinString') - Auch INLINECHARS unterstützt Konstanten (diese werden aber ohne Apostroph eingegeben): - CONST TestString = 'Hallo Welt' - INLINECHARS(TestString) wird gleich übersetzt wie INLINECHARS('Hallo Welt') Tipp: Stringabschluss mit CRLF kann folgendermassen realisiert werden: CONST CRLF = 0A0DH 'wegen dem Little Endian! INLINECHARS('Mein String auf einer Zeile') INLINEWORDS(CRLF) ----------------------------------------------------------------------------------------------------------- V0.7, 060301 ----------------------------------------------------------------------------------------------------------- V0.6, 060221 - Keyword INCLUDEFILE: Angabe eines einzubindenden Sourcecodefiles. Gebrauch wie bei IMPORT. Beispiel: INCLUDEFILE 'MeineDatei.INC' (entgegen meiner Angabe von letzter Woche wird die Datei also als String angegeben - aus Symmetriegründen zu IMPORT). Spezialität: Mit INCLUDEFILE können beliebig geschachtelt Sourcecodeteile eingebunden werden. Es ist sichergestellt, dass die Zeilenzählung immer korrekt funktioniert; selbst in hierarchisch tief geschachtelten Dateien. Falls ein Kompilierfehler auftritt, wird die Zeile im FEHLERHAFTEN File angegeben. Zur Zeit muss der Benutzer noch nachvollziehen, in welchem File er aktuell steckt. - Keyword CONST: Mit CONST wird eine Konstante definiert, die sowohl numerisch als auch ein String sein kann. Die Unterscheidung geschieht automatisch. Im numerischen Fall werden wie gewohnt alle möglichen Formate unterstützt. Es ist auch möglich, bereits vorhandene Tokens als Konstanten zu verwenden. In diesem Falle werden sie numerisch eingesetzt. Die Konstanten können sowohl in Zuweisungen als auch als Funktionsparameter verwendet werden. Im zweiten Fall wird korrekt nach string, integer (16bit) und byte (8bit) unterschieden und der Wertbereich überprüft. Spezialität: CONST kann überall stehen. Falls es im Filerumpf oder in der Mainloop steht, wird daraus eine GLOBALE Konstante und ist somit überall im gleichen File (und somit auch in den nachfolgenden INCLUDEFILES) bekannt. Falls CONST aber in einer Subroutine steht, gilt die Konstante ausschliesslich in der aktuellen Subroutine. Eine globale Konstante gleichen Namens kann lokal in einer Subroutine redefiniert werden (temporär überschrieben). Eine Redefinition auf gleicher Ebene ist jedoch nicht möglich und führt zu einem Compilerfehler. Alles in allem ein recht mächtiges Tool. - Liveparser: neu eine schaltbare Version "Enhanced LiveParsing" eingeführt; diese ist defaultmässig immer eingeschaltet. Diese interpretiert die aktuelle Codezeile laufend. Die Keywords werden sogar casesensitiv geparst. - Stabilität des Editors: Die war durch den LiveParser beeinträchtigt, was nun verbessert wurde. ----------------------------------------------------------------------------------------------------------- V0.5, 060209 - Doppelpunkt-Zuweisungen, auch korrekt im Parser - Compiler lädt header und funclib grundsätzlich neu - Parser lädt funclib automatisch bei Refresh, somit werden auch Funktionen eingefärbt - negative Zahlen funktionieren auch: -32000 bis 32000 oder aber 0 bis 65000, wobei negative Zahlen den gleichen Zahlenbereich von 33000 bis 65000 belegen - Prüfung auf Bereichsüberschreitung von Zahlen - Button-Leiste neu - LoadIntegerMulti wird bei Labels unterbrochen Behobene Fehler: - Absturz des LiveParsers bei Löschen in einer Zeile ----------------------------------------------------------------------------------------------------------- V0.4, 060208 ----------------------------------------------------------------------------------------------------------- V0.3, 060203 - Shortcuts nach Normen angepasst - fileDirty-Flag bei File->Close ergänzt - "Sprungverhalten" im Editor verbessert. ----------------------------------------------------------------------------------------------------------- V0.2, 060202 - neue Farben - Find/Replace mit schaltbarem Case Sensitive - Comment/Uncomment - Editor Font wird neu bei jedem Liveparsing gesetzt - kein Liveparsing nach Compilierung (es gibt ja den Option->Editor Refresh) - Loadinteger(Multi) funktioniert - GetADC funktioniert: GetADC(i,variable) - ShortCut-Keys eingebaut - einstufiges Undo/Redo - INLINE-Funktionen gemäss Doku ----------------------------------------------------------------------------------------------------------- V0.1, 060201 - NIL funktioniert nun als gültiges Sprungziel/Funktionsname und wird als FFFF übersetzt. - GetADC, TimerInstall, JumpIntegerEqual_Imm und PrintCardinal erzeugen gültigen Code. - Editorfunktion integriert ----------------------------------------------------------------------------------------------------------- V0.0, Dezember 2005 (kein Release) - erste Implementation der Sprache EigerScript - EigerScript-Compiler ersetzt EigerInterpreter ----------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------- (END OF FILE)