============================================================================= Udo's Debugger - UDebug Version 1.6 ============================================================================= Debugger und System-Monitor für Amiga-Rechner UDebug ist Copyright 1992 by Udo Externbrink Dieses Programm ist FREEWARE. Es kann von jedermann genutzt werden, solange dies nicht im kommerziellen oder gewerblichen Rahmen geschieht. Das Copyright und Urheberrecht bleibt jedoch allein dem Autor vorbehalten. Diesbezüglich gelten die deutschen Gesetze und Rechtsvorschriften. Das Programm darf frei verbreitet werden, solange es kostenlos (maximal 4 DM Selbstkosten) und vollständig geschieht (Mindestens Programm, Beispiel-Dateien und Dokumentation). Ich will, trotz vieler Stunden Arbeit, an dem Programm nicht verdienen, aber andere sollen es auch nicht. Programmierer, die mit diesem Programm zufrieden sind und es häufig benutzen, können mir, wenn sie Lust haben, ihre eigenen Programm-Entwicklungen oder eine Tafel Schokolade als Dank zuschicken (ein wenig Giftware). Die Benutzung des Programms geschieht auf eigenes Risiko. ============================================================================= Einleitung ============================================================================= Wenn man auf dem Amiga in Assembler programmiert, hat man schon mal das Problem eines Absturzes (TASK HELD) oder sogar ein GURU läßt schön grüßen. Dann beginnt das mühsame Tracen des Programms (Einzelschritt, Durchlauf langer System-Routinen, Debugger-Probleme bei exclusiver Kontrolle wichtiger System- Komponenten usw.). Und wenn man Pech hat, übersieht man den Programmfehler und muß die ganze Testerei wieder von vorne beginnen. Aus diesem Grund habe ich UDebug geschrieben und hiermit möchte ich das Programm auch anderen Programmierern zur Verfügung stellen. Zuerst aber herzlichen Dank an die UDebug-Beta-Tester, die sich nicht nur die Mühe des Testens, sondern auch viele konstruktive Vorschläge gemacht haben. Hier die Namen der Unerschrockenen: Kay-Uwe Drangmeister Peter Elzner Bernd Grunwald Jörg Wichert Holger Wiese Einige spezielle UDebug-Funktionen: ----------------------------------- - UDebug arbeitet, falls vorhanden, auch mit Source-Symbolen. Diese Symbole (im hunk_symbol) können die verschiedensten Assembler bei der Umwandlung erzeugen. Für die LVO-Offsets des Amiga-Betriebssystems wird eine Datei mitgeliefert. Der Benutzer kann die Offsets zusätzlich benutzter Libraries, Devices und Resources in diese Datei einfügen bzw. über eine seperate Datei nachladen. - Die einzelnen Trace-Schritte werden in einer variabel großen Trace-Tabelle im Speicher abgelegt. Wenn die Tabelle voll ist, werden die ersten Einträge wieder überschrieben. Die Größe dieser Tabelle kann der Benutzer selbst bestimmen (ca. 80K für 1000 Befehle). Dadurch können auch weiter zurück- liegende Befehle noch angesehen und kontrolliert werden. Da die Tabelle resetfest ist, gilt das auch nach einem Reset (z.B. nach einem Guru). Nach Reset und Neustart von UDebug kann man die letzten Befehle (Größe der Tabelle) des getesteten Programm inklusive eventuell vorhandener Source- Labels zurückverfolgen. - Quicktrace: Die einzelnen Trace-Schritte werden nur im Speicher abgelegt. Da keine Anzeige im Window erfolgt, ist diese Art des Traces verhältnis- mäßig schnell. Es sollten auch weniger Schwierigkeiten bei der Benutzung kritischer System-Komponenten auftreten. Ein laufender Quicktrace wird unterbrochen bei folgenden Faktoren: Programm-Ende, Breakpoints, Fehlerbedingung oder durch drücken der Break- Taste (Default ESC - siehe 'set brk'). - UDebug hat eine Stack-Verfolgung, d.h. es merkt sich beim Trace alle Befehle, die das Stack-Register (A7) verändern, und mit dem Befehl 'tk' bzw. im Stack-Window kann der Stack-Inhalt mit den zugehörigen Befehlen angezeigt werden. - Wenn sich das Trace-Programm in einer Unterroutine, in einer DBcc- oder Bcc- Schleife befindet, kann UDebug diese im Schnell-Durchlauf (Go-Modus) durch- laufen, d.h. UDebug stoppt erst wieder beim Verlassen der Unterroutine bzw. DBcc- oder Bcc-Schleife. - UDebug reagiert auch auf Exceptions und Guru's von anderen Tasks. Es er- scheint ein Requester mit Exeption- bzw. Guru-Nummer, Task- und PC-Adresse, Taskname, Register-Inhalte und Segment-Adressen (Programm-Teile) mit Länge. Nicht nur für Kickstart 1.2 und 1.3 : Guru's können in Task Held umgewan- delt werden. Wenn erwünscht, kann diese Funktion abgeschaltet werden. - Die Zeichenfolge aller UDebug-Befehle kann der Benutzer seinen Wünschen und Gewohnheiten anpassen (z.B. Disassembeln: Anstelle 'd' in 'u' oder 'dis' ändern). - Die Typen-Kennungen für Hexadezimal "$", Dezimal "!", Oktal "&", Binär "%" und Text "'" kann der Benutzer ebenfalls ändern. - Der Benutzer kann bestimmen, ob Zahlenwerte ohne Typen-Kennung als Hexa- dezimal-, Dezimal-, Oktal- oder als Binaer-Zahl interpretiert werden. Default = Hexadezimal - Eingebauter Assembler zum Ändern von Befehlen im Test-Programm. Zur Zeit nur für 68000 Befehle. Die 68010-68040 Befehle werden in einer der nach- folgenden Versionen eingebaut (Gilt auch für den Disassembler). - Eingebauter einfacher Calculator mit der Funktionen '+' '-' '*' '/' 'and' 'or' und 'eor' für hexadezimal, dezimal, oktal und binär. Die Zahlen- werte können auch gemischt angegeben werden. (Siehe Befehl 'n') - Command-History für die letzten 40 UDebug-Befehle. - Mit UDebug können wichtige Amiga-System-Strukturen mit ihren einzelnen Feldern angelistet werden. Zusätzlich kann der Benutzer bis zu 20 eigene oder nicht eingebaute Amiga-Strukturen selbst definieren und damit forma- tiert anlisten. - Frei definierbare F-Tasten-Belegung - An- und abschaltbare Zusatz-Windows mit Register-, Stack- und Memory- Anzeige - Ein Teil der Befehle sind auch über Pulldown-Menues aufrufbar - Beim Tracen wird bei indirekter Adressierung (z.B. move.l 33(a3,d5.l),d0) die absolute Adresse und bei Bcc und DBcc die Branch-Bedingung angezeigt. Bei Scc-Befehlen sieht man, ob die Bedingung erfüllt ist. - Bei UDebug können vor Trace-Beginn entsprechende Schalter gesetzt werden (T-Befehle), um schnell und effektiv eventuell vorhandene Programm-Fehler zu finden. Diese Schalter können für ein Programm auch in einem Script-File (bei UDebug: Config-File -> siehe C-Befehl) zusammengefaßt werden, so daß die langsame manuelle Eingabe vor jedem Test entfallen kann. - Nach den Befehlen d,ld,le,lf,li,lm,ln,lp,lr,ls,lt,lw,m,mi,t,te,tj,tr und tt wird nur durch drücken der Return-Taste der Befehl fortgeführt bzw. wiederholt. Nach Stops durch Breakpoints usw. kann mit drücken der Return-Taste der Trace im Einzelschritt fortgesetzt werden. Zu dem UDebug-Archiv gehören folgende Dateien: ---------------------------------------------- UDebug => Der Debugger UDebug.Dok => Diese Datei UDebug.Config => Muster einer Config-Datei UDebug.Offsets => Offsets der Amiga-Betriebssystem-Routinen UDebug.Script => Muster einer Config-Datei für Programm-Test UDebug.LuCmd => Muster Strukturen für den 'lu'-Befehl UDebug.Vorschlaege => Vorschläge für zukünftige UDebug-Funktionen UDebug.Befehle => Zusammenfassung der UDebug-Befehle ============================================================================= Kurz-Übersicht der UDebug-Befehle ============================================================================= Erklärungen: ------------ {../..} = Einer der angegebenen Parameter ist erforderlich [..] = Parameter muß nicht angegeben werden adr = Absolute Adr oder Symbolname oder Register d0-d7 a0-a7 Beispiele: $200000 = Absolute Adresse $200000 exit+44 = Adresse Label 'exit' plus 44 d4 = Inhalt Test-Register D4 a7-10 = Inhalt Test-Register A7 minus 10 300*3 = Absolute Adresse 900 0a0 = Absolute Adresse a0 (0a0 = kein Reg) adr1 adr2 = Bereich von Adr1 bis Adr2 Beispiele: d4 a5 = Bereich von Inhalt D4 bis Inhalt A5 0 2*20 = Bereich von Adresse 0 bis 40 upanf upend = Bereich von Label 'upanf' bis 'upend' byte = Ein Zeichen (Angabe als Text,Hex,Dez usw.) bytes = Zeichenfolge (Kombination von text,hex,dez usw.) Beispiel: 'Ha' $3031 !10 = 5 Bytes = $486130310a path = Amiga-Dos-Pfad symbol = Programm- oder LVO-Symbol: z.B. 'read' zeigt alle Symbole, die mit 'read' anfangen len = Längen-Angabe (in Hex, Dez, Bin oder Oct) num = Numerische Eingabe (in Hex, Dez, Bin oder Oct) name = Name einer Amiga-Dos-Datei (Kann Pfade enthalten: df1:x/y) cmd = Motorola-Assembler-Befehl (Altes Format: 4(a0,d2.w) Zwischen dem Befehl und eventuell folgenden Parametern muß mindestens eine Leerstelle sein. Die Eingabe kann bis zu 200 Zeichen beinhalten, die History speichert aus Platzgründen aber nur die ersten 60 Bytes. Ich hoffe, das dies ausreicht. Die Befehle: ------------ a adr [cmd] Assemble: Der eingegebene Befehl wird in Binär umgewand. c name Einlesen einer Config-Datei cd path Ändern aktuellen Pfad für UDebug (Entspr. Cli-Befehl Cd) chg alt neu Ändern Zeichenfolge der Befehle und Zeichen-Vorzeichen cli Eröffnen CLI-Fenster cls Lösche Inhalt des UDebug-Fensters d [adr1] [adr2] Disassemble Speicher del name Delete Datei dir [path] Listen Directory (Entspricht Cli-Befehl Dir) err Sonder-Befehl für UDebug-Fehler f adr1 adr2 bytes Finden Zeichenfolge im Speicher h6 Hilfe für letzten 'jsr lvo..(a6)'-Befehl hd symbol Hilfe für Device-Lvo-Aufrufe hl symbol Hilfe für Library-Lvo-Aufrufe hr symbol Hilfe für Resource-Lvo-Aufrufe lb Listen Exec-Library-List lbe Listen Exec-Library-Base lbg Listen Gfx-Library-Base lbi Listen Intuition-Library-Base ld Listen Exec-Device-List le Listen Exec-Resident-List lf Listen Fonts lh Hilfe List-Befehle li Listen Interrupts ll adr Listen Node-List lm Listen Exec-Memory-List lmf Listen Free-Memory ln [adr] Listen Node lp Listen Exec-Port-List lr Listen Exec-Resource-List ls Listen Exec-Semaphore-List lt Listen Exec-Task-List lu name Lesen User definierte Struktur-List-Befehle lw Listen Windows und Screens lz num Setzen Anzahl Zeilen bei List-Befehlen m [adr1] [adr2] Listen Memory in Hex und ASCII ma len [CHIP] Allocate Memory maa adr len Allocate Memory absolut mby [adr] Listet 1 Byte in Hex und Ascii mc adr1 adr2 dest Compare (Vergleichen) Memory mf {adr/ALL} Free Memory (Freigeben) mfl adr name Load File nach Memory mfs adr1 len name Save Memory nach File mi [adr1] [adr2] Listen Memory in ASCII mh Hilfe Trace-Befehle ml Listen Allocierten Memory mlo [adr] Listet 4 Bytes (Long) in Hex und Ascii mm adr bytes Modify (Verändern) Memory mo adr1 adr2 byte Occupy (Überlagern) Memory mt adr1 adr2 dest Transfer (Move) Memory mwo [adr] Listet 2 Bytes (Word) in Hex und Ascii n num [+-*/ num] Rechnen (Eingabe und Ergebnis in Hex,Dez,Oct,Bin) nl [num] Anzahl Zeilen beim Listen (default=$0A=10) p Verändern Task-Priotäten q UDebug beenden (Quit) r [reg=num] Listen und Verändern Register-Inhalte Test-Programm rof name Lesen Offset-Datei s Listen Test-Programm-Daten (Segment-Daten) set kz bytes Setzen UDebug-Config-Daten sl name Load Test-Programm (Segmente) su Löschen Test-Programm (Unload Segment) syk {0/1} Bei langen Symbolen Verkürzung vorne (1) oder hinten (0) sym [symbol] Listen Symbole des Test-Programms t [num] Trace Programm (Speicher-Trace und Display) ta adr [num] Trace Programm mit neuer PC-Adresse tb [adr] [num] [,cmd] Listen oder setzen Breakpoint tbc {adr/ALL} Löschen Breakpoint tbf Setzen Breakpoints bei Verlassen einer DBcc-Loop tbl Setzen Breakpoints bei Verlassen einer Bcc-Loop tbq Quick-Trace bis zum nächsten RTS tbr Trace nach Durchlauf des BSR/JSR-Unterprogramms fortsetz. tbs Trace nach Durchlauf des Unterprogramms fortsetzen tc [adr] [bd] [,lg/bytes] Listen, setzen und löschen Change-Breakpoints tci num Setzen neuen Intervall-Wert für Change-Breakpoints te [num] Trace Programm (mit JSR/BSR-Trace) tf [A=] [Rx=] adr Find Adresse in Trace-Tabelle tg [adr] Go: Starte Test-Programm (ohne Trace) th Hilfe Trace-Befehle ti Display Trace-Instruktionen tj [num] Trace Programm (ohne JSR/BSR-Trace) tk Listen Stack-Daten tko [{0/1}] Stack-Verfolgung Aus (0) / Ein (1) tl [{0/1}] Library-Trace (jsr ...(a6) Aus (0) / Ein (1) tn num Verändern Größe der Trace-Tabelle (num = Anz. Einträge) tq [num] Quick-Trace Programm (Speicher-Trace) tqa adr [num] Quick-Trace Programm mit neuer PC-Adresse tqe [num] Quick-Trace Programm (mit JSR/BSR-Trace) tqj [num] Quick-Trace Programm (ohne JSR/BSR-Trace) tr [A=] [num] Display Einträge der Trace-Tab (Befehle und Register) ts num Skip 'num' Befehle ab aktueller PC-Adresse tt [A=] [num] Display Einträge der Trace-Tab (nur Befehle) tta adr anz Listen Daten einer Trace-Tabelle (ohne Symbole) tu [{0/1}] Unterprogramm-Trace (bsr/jsr) Aus (0) / Ein (1) tua [adr1] [adr2] Setzen und Löschen Unterprogramm-Bereiche (Kein Trace) tuj [{0/1}] Jmp bei 'tua' Bereichen aus- oder einschalten tw {num/adr} Wiederhole Befehl (PC und Register alten Stand) tx Verlasse Test-Programm über Label _exit wa1 adr Eingeben List-Adresse fuer 1.Memory-Fenster wa2 adr Eingeben List-Adresse fuer 2.Memory-Fenster wf [{0/1}] Bei Trace-Stop Window nach vorn: Aus (0) / Ein (1) wf1 [{0/1}] Bei Trace-Stop 1.Mem-Window nach vorn: Aus (0) / Ein (1) wf2 [{0/1}] Bei Trace-Stop 2.Mem-Window nach vorn: Aus (0) / Ein (1) wfr [{0/1}] Bei Trace-Stop Reg-Window nach vorn: Aus (0) / Ein (1) wfs [{0/1}] Bei Trace-Stop Stack-Window nach vorn: Aus (0) / Ein (1) wm1 [{0/1}] Öffnen oder Schließen 1.Memory-Window wm2 [{0/1}] Öffnen oder Schließen 2.Memory-Window wmn [num] Listen und Verändern Refresh-Intervall für Memory-Windows wr [{0/1}] Öffnen oder Schließen Register-Window wrs [{0/1}] Register-Window mit Symbolen ws [{0/1}] Öffnen oder Schließen Stack-Window wtf UDebug-Window to Front > [{dev/name}] Output umleiten ? Hilfe-Funktion ============================================================================= Installieren UDebug ============================================================================= Für die Installation von UDebug reicht es, das eigentliche Programm 'UDebug' in die C:-Directory oder in ein andere Directory bzw. auf eine Diskette zu kopieren. Dann die Datei 'UDebug.Offsets' in die 'ENV:' oder 'S:'-Directory kopieren. Mit dieser einfachen Installation sollten Sie UDebug erstmal starten und einige Befehle ausprobieren. Über Pulldown-Menues (Help) oder der Help-Taste lassen sich die verfügbaren UDebug-Befehle anzeigen. Wenn Sie die beim Einlesen von Dateien ('sl' 'c' 'rof' und 'lu' Befehl) mit File-Requester arbeiten möchten, erwartet UDebug bis Kick 1.3 die 'Req.Library' und ab Kick 2.0 die 'Asl.Library'. Nachdem Sie diese Dokumentation gelesen haben, sollten Sie sich auch die drei Beispiel-Dateien anschauen, Ihren eigenen Wünschen anpassen, und wenn diese dann automatisch geleden werden sollen, in die 'ENVARC:', 'ENV:' oder 'S:'- Directory kopieren und ausprobieren: UDebug.Offsets enthält die Offsets des Amiga-Betriebssystems. -------------- Sie wird benötigt, um beim Tracen die System-Aufrufe des Amiga- Betriebssystems: 'JSR -..(A6)' statt des negativen Offsets mit ihrem LVO-Namen darzustellen. UDebug versucht beim Start die Datei 'udebug.offsets' einzulesen. Es wird in folgenden Directories gesucht: bis WB 1.3 ab WB 2.0 Option -d Option -o ----------- ---------- ----------- ---------- 1. aktuelle aktuelle nur in dir nur datei 2. S: ENV: 3. ENVARC: 4. S: Mit dem Befehl 'rof' können nach dem Start von UDebug weitere Offset-Dateien geladen werden. Die Datei kann auch mit den Offset anderer Libraries erweitert bzw. die Amiga-Offsets können bei einer neuen Version verändert werden. Die Format-Beschreibung befindet sich in der Datei. UDebug.LuCmd enthält Beispiele zum Installieren von List-Struktur-Befehlen: ------------ lci : Listen CLI-Struktur lio : Listen Standard-IO-Request-Struktur lfh : Listen File-Handle-Struktur ldp : Listen DOS-Packet-Struktur lfl : Listen File-Lock-Struktur lmn : Listen Message-Struktur lmp : Listen Message-Port-Struktur Diese Datei wird mit dem 'lu'-Befehl gelesen UDebug.Config.Beisp enthält Beispiele zum Konfigurieren von UDebug. ------------------- UDebug versucht beim Start eine 'udebug.config' einzulesen. Sie kann bis auf den 'c'-Befehl alle UDebug-Befehle enthalten. Die Reihenfolge der Suchpfade entspricht denen der Offset-Datei. In die beim Start automatisch eingelesene Config-Datei (siehe -c Option) empfehle ich, nur grundsätzliche Änderungen (z.B. neue Befehls-Zeichenfolge, nachladen von Offset- oder LU-Dateien, Window-Größen, F-Tasten-Belegungen usw.) durchzuführen und Befehle für die spezielle Test-Vorbereitung (Laden Test-Programm, Breakpoints und Trace-Schalter setzen usw.) in eine seperate Config-Datei zu stellen und bei Bedarf mit dem 'c'-Befehl laden. UDebug.Script ist ebenfalls eine Config-Datei. ------------- Sie enthält Beispiele zur Vorbereitung eines Test-Programms. Diese Datei kann mit dem 'c'-Befehl vor Beginn eines Programm- Testes eingelesen werden. ============================================================================= Starten von UDebug ============================================================================= UDebug kann von der Workbench oder vom CLI aufgerufen werden. Beim Aufruf vom CLI können Parameter übergeben werden. Ein Debugger muß, um wirksam arbeiten zu können, auch in das Betriebssystem eingreifen. So verändert UDebug beim Start ohne Optionen folgende System- Komponenten: Alle wichtigen Vectoren (2-F,18,20-2F) Routinen in der Exec- und Intuition-Library,um Guru's abzufangen. Die tc_TrapCode-Adresse der UDebug-Task Beim Programm-Trace wird eine IRQ 5 Routine aktiviert. UDebug habe ich zum größten Teil nur auf meinem Amiga 1000 (68000) und Kick- start 1.3 entwickelt und getestet. Falls Schwierigkeiten bei höheren Kickstart- oder Processor-Versionen auftreten, besteht mit den nachfolgend beschriebenen Optionen die Möglichkeit, einige der System-Modifikationen auszuschalten. Einige Tests mit 68010-Processor mit Kickstart 2.0 (ZKick-Version) und 68030 mit Kickstart 2.0 (A3000) sind erfolgreich verlaufen. Es können folgende Parameter beim Aufruf vom CLI mit angegeben werden: UDebug {-a / -e / -t / -n} [-g] [-i] [-c configdatei] [-o offsetdatei] [-d directory für config+offset] -a Alle Modifikationen werden wirksam (Ist Default). Damit UDebug die größte Kontrolle über den Rechner hat, ist es am sinnvollsten, alle System-Modifikationen wirksam werden zu lassen, und nur wenn es Probleme mit dem Rechner gibt, sollten andere Optionen angegeben werden. -e UDebug reagiert nur bei Fehlern der Test-Task Es werden auch alle Modifikationen wirksam, nur wenn eine fremde Task eine Exception erzeugt, wird diese nicht beachtet bzw. sie läuft weiter. Auftretende Guru's werden aber weiterhin angezeigt, außer diese Funktion wird mit der '-g'-Option ebenfalls abgeschaltet. -t Keine Modifikation der Vektoren (Nur beim Tracen Vector 9) Exception's werden dann über die vom Betriebssystem unterstützte tc_TrapCode-Adresse abgefangen, d.h. Exception anderer Task's werden nicht von UDebug kontrolliert. Es bleiben aber die vollen Trace-Möglichkeiten von UDebug erhalten. Diese Option ist sinnvoll, wenn UDebug mit anderen systemnahen Programmen, die ebenfalls die Vektoren verändern (z.B. Enforcer), zusammen laufen soll. -n Keine Modifikationen an den System-Routinen UDebug kann mit dieser Option nicht als Debugger, sondern nur als Monitor benutzt werden. Diese Option schließt die '-g'-Option mit ein. -g Es werden keine Guru's abgefangen Die Modifikationen an der Exec- (_LVOAlert) und Intuition-Library (_LVODisplayAlert) zum Abfangen vom Guru's werden nicht durchge- führt. -i Es wird beim Trace keine IRQ-Routine aktiviert. Um beim Testen von Programmen ohne UDebug-Kontrolle (z.B. GO) die Möglichkeit zur Unterbrechung zu haben, aktiviert UDebug beim Trace von Programmen eine IRQ 5 Routine (Wird 50 mal pro Sekunde aktiviert). Diese Irq-Routine versucht beim Drücken der Break-Taste (Default ESC) das laufende Test-Programm zu unterbrechen. Mit der Option '-i' wird keine IRQ-Routine aktiviert, d.h. ein im Go- Modus laufendes Testprogramm kann nicht mit der Break-Taste unter- brochen werden. -c Name einer UDebug-Config-Datei Lesen Config-Datei (Name folgt nach -c). In dem Config-File kann der Benutzer fast alle UDebug-Befehle defi- nieren, so zum Beispiel die Zeichenfolge der UDebug-Befehle seinen eigenen Vorstellungen und Gewohnheiten anpassen. Falls dieser Parameter fehlt, sucht UDebug ein Config-File mit Namen 'UDebug.Config' in folgender Reihenfolge in den Directories: Aktuelle, ENV: (nur ab 2.0), ENVARC: (nur ab 2.0) und in S: . Sonderfall: Wenn beim Start mit der '-d' Option für die UDebug- Dateien eine Directory vorgegeben wird, sucht UDebug nur in dieser Directory Mit dem 'c' Befehl können auch nach dem Start von UDebug Config- Dateien eingelesen werden. -o Name einer UDebug-Offsets-Datei Diese Option entspricht der '-c' Option, nur gilt sie für eine Offsets-Datei. Bei fehlen dieser Option wird nach einer Datei 'UDebug.Offsets' gesucht. -d Name einer Directory Vorgabe einer Directory zum Suchen der UDebug-Config- und UDebug- Offsets-Datei. Wenn eine Directory mit -d vorgegeben wird, entfällt das Suchen in den System-Directories. ============================================================================= Die UDebug-Befehle im Einzelnen ============================================================================= HELP-Taste => Zeigt die Befehle von UDebug in Kurzform an. Geänderte Befehle ---------- ('chg'-Befehl) werden in ihrer neuen Zeichenfolge angezeigt. ESC-Taste => Default-Break-Taste (kann mit 'set brk' geändert werden) --------- Unterbricht die laufende Listausgabe und den laufende Trace (Im Go-Trace-Modus und bei Direkt-Ausführung von Unterprogrammen (BSR/JSR) Befehle: 'tua', 'tl' und 'tu', etwas eingeschränkt). LEER-Taste => Hält die laufende Listausgabe an. Bei erneutem Drücken wird die ---------- Listausgabe fortgesetzt. Q => UDebug beenden --------------------- Mit diesem Befehl wird UDebug beendet. Falls noch ein Programm-Trace aktiv ist, fragt das Programm, ob wirklich beendet werden soll. Format: q : Ohne Parameter ============================================================================= Befehle zum Konfigurieren ============================================================================= CHG => Wechsel Command-Syntax ------------------------------ Mit diesem Befehl kann die Zeichenfolge aller UDebug-Befehle geändert werden. Die Typen-Kennungen für Hexadezimal, Dezimal, Oktal, Binär und Text kann ebenfalls geändert werden, wie auch die Interpretation von Zahlen ohne Typen-Kennung und ein Sonderzeichen für die 1-zeilige Anzeige beim 'm' (Memory-Display) und 'u' (Disassemble) Befehl. Die UDebug-Befehle sind 1-3 stellig. Die Typen-Kennung ist 1-stellig. Default: ($ = Hexadezimal) (! = Dezimal) (% = Binär) (& = Oktal) (' = Text) und (. = 1-Zeilig beim u,m,it,ir und Befehl). Für die Typen-Kennung sind die Zeichen '+' '-' '*' und '/' gesperrt. Format: chg alt neu chg defz={h/d/o/b} alt = Alte Zeichen-Folge neu = Neue Zeichen-Folge defz= = Interpretieren Zahlen-Eingabe ohne Typen-Kennung als Hexadezimal (h), Dezimal (d), Oktal (o) und Binär (b) Beisp.: chg ! # = Typen-Kennung für Dezimal von '!' in '#' ändern. chg tb b = Befehl Setze Breakpoint = 'tb' in 'b' ändern. chg q x = Befehl Quit UDebug = 'q' in 'x' ändern. chg defz=d = Interpretiere Zahlen ohne Typen-Kennung als Dezimal-Zahl (Default = Hexadezimal). SET => Setzen UDebug-Config-Daten ---------------------------------- Mit diesem Befehl werden einige Einstellungen von UDebug geändert. Da diese Einstellungen nicht dauernd geändert werden, ist dieser Befehl am besten für die Config-Datei geeignet. Es kann die Funktions-Tasten-Belegung, der Command zum Starten eines CLI's, die Test-Stack-Größe, das Prompt-Zeichen von UDebug, die Break-Taste, Window-Größen, der Labelname fuer den 'tx' Befehl und die verfügbaren Ram-Bereiche geändert werden. Bei dem Befehl 'set f1-9' und 'sf1-9' kann mit dem Zeichen '^' am Ende des Strings ein 'RETURN' erzeugt werden, d.h. der Befehl wird sofort ausgeführt. UDebug hat einen Befehl,der nur auf den F-Tasten wirksam ist: 'del^' Liegt dieser Befehl auf einer F-Taste, wird bei drücken der F-Taste in der Eingabe-Zeile ab Cursor gelöscht. Der Grund: Beim Editor benutze ich häufiger die Funktion 'lösche Rest der Zeile'. Da dies auch mal bei UDebug notwendig ist, drückte ich aus Gewohnheit also die beim Editor dafür bestimmte Funktions-Taste und ärgerte mich. Jetzt haben Editor und UDebug die gleiche Funktiontaste für diese Funktion und der Ärger ist vorbei. Default-Werte: F1 ?^ SF1 lm^ F2 th^ SF2 lf^ F3 mh^ SF3 li^ F4 lh^ SF4 lp^ F5 dir^ SF5 lr^ F6 > prt:^ SF6 ls^ F7 >^ SF7 F8 cli^ SF8 F9 set^ SF9 lt^ F0 ti^ SF0 lw^ Teststack $002000 CLI: NewCLI "CON:0/12/640/100/UDebug CLI" TX: _exit Window: 0000 0009 0280 00BE (Hex-Werte für Normal-Window) RegWin: 0000 0014 0280 0069 (Hex-Werte für Register-Window) StkWin: 00CA 0082 01B6 0045 (Hex-Werte für Stack-Window) Me1Win: 0000 00C0 0280 0021 (Hex-Werte für 1.Memory-Window) Me2Win: 0000 00DE 0280 0021 (Hex-Werte für 2.Memory-Window) Break-Key : Esc Available RAM : 00BFD000-00BFFFFF 00DC0000-00DFFFFF 00F80000-00FFFFFF + Mem-List-Daten Not readable RAM: 00BFD000-00BFFFFF 00DC0000-00DFFFFF > Format: set : ohne Parameter = Listen set-Daten --- set f1-9 befehl : Ändern F-Tasten 1-9 ----------------- Befehl: 1-16-stelliger Text ohne Befehl wird die Funktion gelöscht z.B. set f0 ti^ = Belegt die F10-Taste mit dem Befehl 'ti'. Der Befehl wird sofort ausgeführt. set f1 = Löscht die Belegung der F1-Taste. set sf1-9 befehl : Ändern Shift-F-Tasten 1-9 ----------------- Befehl: 1-16-stelliger Text ohne Befehl wird die Funktion gelöscht z.B. set sf2 hx = Belegt die Shift-F2-Taste mit dem Text 'hx'. set cli text : Ändern Befehl für ein neues CLI --------------- text: 1-60-stelliger Text z.B. set cli NewCLI "CON:0/12/600/180/UDebug CLI" = Ändert den Befehl zum Aufruf eines CLI's. set stk num : Ändern Stack-Größe für Programm-Test -------------- num: minimal 256 Bytes ACHTUNG: Die Stack-Größe läßt sich nur verändern, wenn kein Trace aktiv ist. z.B. set stk 4000 = Setzt den Test-Stack auf die Größe von $4000 Bytes (Dezimal = 16384 = 16 k) set pro text : Ändern Prompt-Zeichen --------------- text: 1-3-stelliger Text z.B. set pro : = Ändert das Prompt von UDebug '->' in ':' set win l t w h : Ändern Window-Größe (Pixel) ------------------ l: Linke Position (Left) t: Höhen-Position (Top) w: Breite (Widht) h: Höhe (Height) z.B. set win 0 10 280 dc = Verändert die Größe des UDebug-Window's. ACHTUNG! - Werte in Hex - in dezimal entspricht das 0 16 640 220 set win mx : Ändern Window-Größe auf Maximum ------------- z.B. set win mx = Setzt das Window auf die maximale Größe. set win mn : Ändern Window-Größe auf Minimum ------------- z.B. set win mn = Setzt das Window auf die minimale Größe. set wr l t w h/mx/mn : Ändern Register-Window ------------------------ siehe 'set win' set ws l t w h/mx/mn : Ändern Stack-Window ------------------------ siehe 'set win' set wm1 l t w h/mx/mn : Ändern 1.Memory-Window ------------------------ siehe 'set win' set wm2 l t w h/mx/mn : Ändern 2.Memory-Window ------------------------ siehe 'set win' set tx text : Ändern Labelname für 'tx' Befehl --------------- text: 1-16-stelliger Labelname z.B. set tx pgmende = Setzt den Labelnamen für den 'tx'- Befehl auf 'pgmende' set brk taste : Ändern Break-Taste. Default kann im ---------------- UDebug das Listen und Tracen mit der ESC-Taste abgebrochen werden. Mit diesem Set-Befehl wird einer anderen Taste die Break-Funktion übertragen. Folgende Tasten können belegt werden: Bck = Backspace-Taste Del = Del-Taste Tab = Tab-Taste F1-F0 = F-Tasten F1-F10 z.B. set brk f0 = Belegt die F10-Taste mit der Break- Funktion set ram adr-adr : Definieren verfügbare Ram-Bereiche. --------------- UDebug ermittelt selber die verfügbaren Ram-Bereiche, so daß ein Eingeben nicht erforderlich sein sollte. Aber lieber ein Befehl, der nicht benutzt werden muß, als Probleme. Die Adressen können vollständig oder auch aus Platzgründen nur in den oberen 2 Bytes der Bereiche angegeben werden. Dann rundet UDebug diese Adressen auf 64 K auf: z.B. set ram 0-7 wird 00000000-0007FFFF set ram f8-ff wird 00F80000-00FFFFFF Falls eine Änderung vorgenommen werden soll, sind alle Bereiche anzugeben. Es können bis zu 16 Bereiche definiert werden. z.B. set ram 0-7 20-3f bfd000-bfffff dc-df f8-ff = Es werden die Bereiche 00000000-0007FFFF, 00200000-003FFFFF, 00BFD000-00BFFFFF, 00DC0000-00DFFFFF und 00F80000-00FFFFFF definiert. set crm adr-adr : Definieren nicht lesbare Bereiche für --------------- die Befehle 'd' 'f' 'm' 'mc' und 'mi'. (Siehe Erklärungen bei Memory-Befehle) Die definierten Bereiche müssen eine Untermenge des definierten Ram's sein. Die Adressen müssen im Gegensatz zu dem 'set ram' Befehl immer vollständig ange- geben werden: z.B. set crm bfd000-bfffff Falls eine Änderung vorgenommen werden soll, sind alle Bereiche anzugeben. Es können bis zu 8 Bereiche definiert werden. Wird kein Bereich angegeben, sind auch keine Bereiche gegen Lesen geschützt. Siehe auch 'm'-Befehl. z.B. set crm 0-3 8-3ff bfd000-bfffff dc0000-dfffff Es werden die Bereiche 00000000-00000003 00000008-000003FF, 00BFD000-00BFFFFF und 00DC0000-00 DFFFFF für die Befehle 'd' 'f' usw. gesperrt. TIP: Falls Sie z.B. den 'Enforcer' neben UDebug aktiv haben, ist es sinnvoll, die Bereiche 0-3 und 8-3FF mit 'set crm' zusätzlich zu setzen, dann vermeidet UDebug ein Lesen dieser Bereiche und es gibt von UDebug keine unnötigen Enforcer- Hits. C => Lesen Config-Datei -------------------------- Mit diesem Befehl kann nach dem Start vom UDebug wie mit der Start- Option '-c' ein Config-File eingelesen werden. Wenn der 'c'-Befehl ohne Datei-Name eingegeben wird und die benötigte Requester-Library ist vorhanden (siehe Installation), wird die Datei über Requester angefordert. Format: c name : name = Name und Pfad der zu ladenen Config-Datei. Beisp.: c dh0:test/ud.script : Es wird die Config-Datei 'ud.script' aus der Directory 'dh0:test' geladen. ROF => Lesen Offset-Datei -------------------------- Mit diesem Befehl kann nach dem Start vom UDebug eine Offset-Datei eingelesen werden. Wenn regelmäßig eigene Offset-Daten beim Test benutzt werden, ist es sinnvoll, diesen Befehl in die Config-Datei einzubauen. Das Format der Offset-Datei ist in der mitgelieferten 'UDebug.Offsets' beschrieben. Werden z.B. die Daten der 'exec.library' nochmal eingelesen, so über- schreiben die neuen Daten die alten. UDebug hat Platz für bis zu 100 Libraries oder Resources oder Devices vorgesehen, d.h. jeder Benutzer kann zu den offiziellen Amiga-Betriebs- system-Daten weitere hinzufügen (z.B. req.library) Wenn der 'rof'-Befehl ohne Datei-Name eingegeben wird und die benötigte Requester-Library ist vorhanden (siehe Installation), wird die Datei über Requester angefordert. Format: rof name : name = Name und Pfad der zu ladenen Offset-Datei. Beisp.: rof dh0:req.offsets : Es wird die Offset-Datei 'req.offsets' aus der Directory 'dh0:' geladen. ============================================================================= Die Trace-Befehle ============================================================================= T => Trace Programm (Trace im Speicher und Display) ------------------------------------------------------ Mit diesem Befehl wird der Trace der einzelnen Programmschritte im Speicher (Trace-Tabelle) abgelegt und zusätzlich auf dem Bildschirm dargestellt. Das Programm wird immer an der aktuellen PC-Adresse fortgesetzt. Falls die Fortsetzung an einer anderen Adresse beginnen soll, muß der 'ta'- Befehl benutzt werden oder mit dem Befehl 'r pc=adr' die PC-Adresse vorher geändert werden. Die Darstellung auf dem Bildschirm verlangsamt die Trace-Geschwindigkeit, deshalb ist beim Durchlauf mehrerer Befehle der Quick-Trace (Befehl 'tq') zu empfehlen. Dann sieht man die ausgeführten Befehle zwar nicht, aber nach einem Stop kann mit Hilfe der Trace-Tabelle und der Befehle 'tt', 'tr' und 'tf' diese nachträglich angesehen werden. Format: t [num] : Ohne Parameter = 1 Trace-Schritt num = Anzahl Trace-Schritte (Default=1) TA => Trace Programm mit neuer PC-Adresse ------------------------------------------- Dieser Befehl entspricht dem Befehl 't', nur muß zusätzlich eine neue PC-Adresse mit angegeben werden. Ab dieser wird dann der Trace fortge- setzt. Format: ta adr [num] : adr = Neue PC-Adresse num = Anzahl Trace-Schritte (Default=1) TB => Listen und Setzen von Break-Points ----------------------------------------- Mit diesem Befehl werden im Test-Programm sogenannte Break-Points gesetzt, d.h. das Test-Programm wird an den angegebenen Adressen unterbrochen. Format: tb [adr] [num] [,udebug-befehl] : Ohne Parameter = Listen Break-Points Nur Adresse = Setzen Break-Point (num=1) Adresse + Nummer = Break erst bei 'num' Durch- läufen (Default: num=1) ,udebug-befehl = irgendeinen UDebug-Befehl, der bei Erreichen des Breakpoints automatisch ausgeführt wird. z.B Memory-Anzeige Als Trennzeichen muß vor dem Befehl ein Komma stehen Beisp.: tb = Listen Break-Points tb lesen = Setze Break-Point auf Label 'lesen' num=1 : Break bei jedem Durchlauf tb lesen 3 = Break beim 3.Durchlauf des Labels 'lesen' tb lesen,m dat1.= Beim Erreichen des Labels 'lesen' wird der Test unterbrochen und das Feld 'dat1' automatisch angezeigt (der Punkt bedeutet einzeilig) TBC => Löschen Break-Points --------------------------- Mit diesem Befehle werden die mit dem Befehl 'tb' gesetzten Break- Points wieder gelöscht. Format: tbc {adr/ALL} : Mit Adresse = Löschen angegebenen Break-Point ALL = Löschen alle Break-Points Beisp.: tbc all = Löschen alle gesetzten Break-Points tbc lesen = Lösche Break-Point am Label 'lesen' TBF => Schnelles Durchlaufen einer DBcc-Schleife ------------------------------------------------ Mit diesem Befehl wird das Testen einer DBcc-Zähl-Schleife wesentlich beschleunigt: Alle Adressen (max. 16) die innerhalb der Schleife mit Bcc-Befehlen (ohne BSR) angesprungen werden und das Ende der Schleife (Befehl hinter dem DBcc) werden mit temporären Breakpoints belegt. Dann wird die wird die Programm-Schleife im Go-Modus ausgeführt und sobald die Schleife verlassen wird, stoppt das Test-Programm. Damit UDebug erkennt, welche Schleife im Go-Modus ausgeführt werden soll, muß die aktuelle PC-Adresse auf den entsprechenden DBcc-Befehl zeigen oder der DBcc-Befehl muß in den letzten 8 ausgeführten Trace- Schritten enthalten sein. Dies gilt nur für DBcc-Befehle, die zurückspringen, d.h. die Schleifen- Anfangs-Adresse liegt vor dem DBcc-Befehl (Rückwärts-Schleife): Rückwärts-Schleife: labr move.b (a0)+,(a1)+ . . dbf d1,labr Bei Vorwärts-Schleifen wird nur ein Breakpoint nach dem DBcc-Befehl gesetzt. Eventuell kann man Vorwärtsschleifen besser mit dem nach- folgend beschriebenen Befehl 'tbl' testen. Vorwärts-Schleife : labv dbf d1,labw . . labw move.b (a0)+,(a1)+ bra labv ACHTUNG: Wenn in der Schleife BSR-, JSR- und JMP-Befehle enthalten sind, die nicht in die Schleife zurückkommen, kann es passieren, daß das ganze Programm im Go-Modus läuft. Format: tbf : ohne Parameter TBL => Schnelles Durchlaufen einer Bcc-Schleife ----------------------------------------------- Dieser Befehl entspricht dem vorherig beschriebenen Befehl 'tbf'. Nur gilt es diesmal nicht für einen DBcc-Befehl, sondern für einen Bcc-Befehle. Damit der Bcc-Schleifen-Befehl eindeutig bestimmt werden kann (Bcc- Befehle gibt es häufiger), muß die aktuelle PC-Adresse direkt auf diesen zeigen oder der Bcc-Befehl muß der letzte ausgeführte Trace- Befehl sein. Sonst gilt die Beschreibung des 'tbf'-Befehls, auch das mit der Vorwärts- und Rückwärts-Schleife. Format: tbl : ohne Parameter TBQ => BSR/JSR-Unterprogramm im Quick-Modus durchlaufen ------------------------------------------------------- Beim Tracen passiert es mir öfters, daß sich das Test-Programm in einem Unterprogramm befindet, mich aber erst der Trace nach Verlassen des Unterprogramms wieder interessiert. Deshalb hat UDebug 3 Befehle, um das Unterprogramm schnell zu durchlaufen. Dies sind die Befehle: 'tbq' 'tbr' und 'tbs' Der Befehl 'tbq' ist von dem drei Möglichkeiten der langsamste, aber er unterliegt auch keinen Einschränkungen. Zusätzlich stoppt dieser Befehl im Gegensatz zu den beiden nachfolgenden vor Ausführung des RTS- Befehls, d.h. der Stack kann vor dem Rücksprung noch auf Richtigkeit überprüft werden. Zum besseren Verständnis kurz die Funktionsweise dieses Befehls: Es werden bis zum nächsten RTS alle Befehle weiter im Trace-Modus aus- geführt. Dies geschieht im Quick-Trace-Modus (entspricht dem Befehl 'tqj'), d.h. keine Ausgabe der Trace-Schritte am Bildschirm, Unter- programme im Unterprogramm werden im Go-Modus ausgeführt und die ausgeführten Befehle werden in der Trace-Tabelle abgelegt. Falls das Unterprogramm sehr groß ist und damit auch die Laufzeit, kann einer der beiden nachfolgenden Befehle benutzt werden. Format: tbq : ohne Parameter TBR => BSR/JSR-Unterprogramm im Go-Modus durchlaufen ---------------------------------------------------- Bei diesem Befehl wird das Unterprogramm im Go-Modus (Echtzeit) durch- laufen, aber es gibt ein paar Einschränkungen. UDebug nimmt seine Stack-Verfolgung zu Hilfe und sucht den letzten BSR- bzw. JSR-Befehl und ersetzt dessen Return-Adresse durch eine eigene Adresse und dann wird die Unterroutine im Go-Modus durchlaufen. Falls im Unterprogramm der Stack manupuliert wurde, bringt das keine Probleme, da UDebug das mit Hilfe seiner Stack-Verfolgung merkt und das berücksichtigt. Aber wurde ein Unterprogramm nicht mit BSR bzw. JSR aufgerufen, sondern z.B. mit PEA und JMP, erkennt das UDebug nicht und es wird bis zum letzten BSR oder JSR zurückgesprungen. Dies läßt sich gut durch das An- zeigen der Stack-Verfolgung (Befehle 'ws 1' oder 'tk') kontrollieren. Ist das Test-Programm im Supervisor-Status (anderer Stack = SSP), so wird der 'tbr'-Befehl abgewiesen. Wenn ein Unterprogramm nicht mit BSR oder JSR aufgerufen wurde oder sich das Test-Programm im Supervisor-Modus befindet, kann das Unterprogramm eventuell mit dem Befehl 'tbs' im Go-Modus durchlaufen werden. Format: tbr : ohne Parameter TBS => Unterprogramm im Go-Modus durchlaufen -------------------------------------------- Bei diesem Befehl wird das Unterprogramm ebenfalls im Go-Modus durch- laufen und es gibt ebenfalls ein paar Einschränkungen. Aber Andere: Die letzte Adresse auf dem Stack muß die Return-Adresse sein, d.h. im Unterprogramm dürfen keine Daten zusätzlich auf dem Stack abgelegt worden sein, sonst stürzt das System eventuell ab. Damit können auch Unterprogramme im Go-Modus durchlaufen werden, die nicht mit BSR bzw. JSR aufgerufen wurden . Allerdings nimmt UDebug seine Stack-Verfolgung zu Hilfe und wenn der letzte Stack-Daten-Eintrag nicht von einem BSR- oder JSR-Befehl stam- men, fragt UDebug sicherhaltshalber noch mal nach. Wann also den 'tbq' oder den 'tbr' oder den 'tbs' Befehl benutzen: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - Wenn das Unterprogramm nicht zu lange Laufzeiten hat, sollte der 'tbq'-Befehl benutzt werden, da er keine zu beachtene Einschränkungen hat und bei falschen Ergebnissen die abgelaufenen Befehle noch in der Trace-Tabelle nachkontrolliert werden können. - Wenn das Unterprogramm mit BSR oder JSR aufgerufen wurde und die Return-Adresse als letztes auf dem Stack liegt, kann das Unterpro- gramm mit 'tbr' oder 'tbs' im Go-Modus durchlaufen werden. - Wenn das Unterprogramm schon Daten auf dem Stack abgelegt hat und noch nicht wieder entfernt hat, geht ein Durchlaufen im Go-Modus nur mit dem 'tbr' Befehl. Das Unterprogramm muß aber mit BSR oder JSR aufgerufen worden sein. - Wenn das Unterprogramm nicht mit BSR oder JSR aufgerufen wurde, geht ein Durchlaufen im Go-Modus nur mit dem 'tbs' Befehl. Allerdings darf das Unterprogramm keine Daten noch auf dem Stack haben, d.h. die Return-Adresse muß die letzte Adresse auf dem Stack sein. - Wenn das Unterprogramm nicht mit BSR oder JSR aufgerufen wurde und das Unterprogramm schon Daten auf dem Stack abgelegt hat oder das Test-Programm sich im Supervisor-Modus befindet, kann nur mit dem 'tbq' Befehl das Unterprogramm durchlaufen werden. Allerdings nicht im Go-Modus, sondern im Quick-Trace-Modus. - Mit dem Befehl 'tk' bzw. mit dem Stack-Window ('ws 1') kann der aktuelle Zustand des Stack's jederzeit angezeigt und kontrolliert werden. Format: tbs : ohne Parameter TC => Listen, setzen und löschen Change-Breakpoints ---------------------------------------------------- Mit diesem Befehl werden Change-Breakpoints (Stopp, wenn sich der Inhalt von Speicher-Bereichen verändert) bearbeitet. Es können maximal 20 Change-Breakpoints definiert werden. Da mit diesem Befehl auch die Möglichkeit besteht, größere Bereiche zu überprüfen, kann durch diese Funktion das Tracen stark verzögert werden. Deshalb ist im UDebug ein Überprüfungs-Intervall vorgegeben (Default 8), d.h. erst nach 8 getracten Befehlen werden die angegebenen Felder überprüft. Mit dem Befehl 'tci' kann dieser Überprüfungs-Inter- vall verändert werden. Wenn eine der gesetzten Bedingungen zutrifft, wird das Programm unter- brochen und die veränderten Felder angezeigt. Der oder die Befehle, die den Stopp ausgelöst haben, sind im Überprüfungs-Intervall zu finden, d.h. bei einem Überprüfungs-Intervall von 8 (default) ist der Befehl, der das Feld verändert hat, in den letzten 8 Befehlen (siehe Trace- Tabelle) zu finden. Dies gilt aber nur für Quicktrace 'tq' und Trace mit 'num'. Bei Einzelschritt-Trace gilt das nicht, da bei jedem Trace-Stopp auch auf Change-Breakpoints geprüft und somit eine zutreffende Bedingung sofort angezeigt wird. ACHTUNG: Wird das Programm auf Grund eines Change-Breaks unterbrochen, so wird der auslösende Change-Break sofort gelöscht. Dies ist notwendig, da die Bedingung beim nächsten Trace-Schritt eben- falls noch zutrifft und dann das Programm wieder stoppt. Falls Change-Break jedoch neu gesetzt werden soll, ist dies mit Hilfe der History-Funktion einfach und schnell möglich. Format: tc [adr] [bd] [{,lg/bytes}] : bd = Bedingung : Die Daten der angegebenen Adresse werden mit den Daten des 3. Parameters (,lg/wert) verglichen und wenn die Bedingung zutrifft, wird das Test-Pro- gramm gestoppt. Folgende Bedingungen sind zulässig: = : gleich != : nicht gleich > : größer !> : nicht größer < : kleiner !< : nicht kleiner ,lg = Länge : Der Vergleich erfolgt in der angegebenen Länge. Als Vergleichs-Daten werden die zum Zeitpunkt des 'tc'-Befehls an der Adresse stehenden Daten genommen. Vor der Länge muß ein KOMMA stehen, sonst wird sie als Vergleichswert (bytes) inter- pretiert. Als maximale Länge ist $ffff (65535) erlaubt. bytes = Zeichen : Byte-Folge mit der verglichen wird. Als Ver- gleichs-Länge wird die Anzahl definierter Bytes genommen. Als maximale Länge ist $4C (76) erlaubt. Ohne Parameter = Listen Change-Breakpoints Nur Adresse = Löschen Change-Breakpoint Adresse, Operand und ,lg/bytes = Vergleich auf Bedingung Beisp.: tc = Listen Break-Points tc feld1 = Lösche Change-Brekpoint auf Label 'feld1' tc feld1 != ,8 = Stopp, wenn sich die Daten ab Label 'feld1' (Länge=8) verändern. tc $20 > $0002 = Stopp, wenn der Wert auf Adresse $20 größer 2 wird. Vergleichslänge = 2 Bytes) TCI => Verändern Überprüfungs-Interval für Change-Breakpoints ------------------------------------------------------------- Da der TC-Befehl beim Trace verhältnismäßig viel Zeit verbrauchen kann, besteht mit diesen Befehl die Möglichkeit, den Überprüfungs- Intervall für alle definierten Change-Breakpoints zu verändern. Dieser Wert sollte nicht die Anzahl der Einträge in der Trace-Tabelle überschreiten, damit beim Stopp noch der Veränderungs-Befehl in der Trace-Tabelle vorhanden ist. Als Default-Intervall ist in UDebug 8 definiert. Format: tci num : num = Neuer Überprüfungs-Intervall Beisp.: tci 62 = Ändern Überprüfungs-Intervall auf 62 (Wenn die Zahlen-Eingabe Hex (default) ist, ent- spricht die Eingabe Hex 62 = dezimal 98) TE => Trace Programm mit UP-Trace ----------------------------------- Dieser Befehl entspricht dem Befehl 't', nur die JSR/BSR-Befehle werden mit Trace und unter UDebug-Kontrolle ausgeführt, d.h. alle bis zum nächsten Stopp abzuhandelden BSR/JSR-Befehle werden ohne Rücksicht des 'tu'-Schalters im Trace-Modus ausgeführt. Sinnvoll ist dieser Befehl, wenn man mit 'tu 1' alle BSR/JSR-Befehle im Direkt (Go)-Modus ausgeführen lassen will, aber dann doch einzelne Unterprogramme tracen will. Dann muß nicht der 'tu'-Schalter ver- ändert werden, sondern es reicht 'te'. ACHTUNG: Wenn nach Eingabe des 'te'-Befehls durch drücken der Return- Taste eine Trace-Fortsetzung erfolgt, entspricht das nur dem 't'-Befehl, d.h. der erzwungene BSR/JSR-Trace ist nicht mehr aktiv. Format: te [num] : Ohne Parameter = Einzelschritt-Trace num = Anzahl Trace-Schritte TF => Find Adresse in Trace-Tabelle ------------------------------------ Mit diesem Befehl wird eine angegebene Adresse in der Trace-Tabelle gesucht. Wenn man eine Trace-Tabelle mit mehren tausend Einträgen definiert hat, ist es sehr mühsam, durch Anzeigen der Trace-Daten (Befehl 'tt' und 'tr') bestimmte PC- oder Register-Werte zu suchen. Mit diesem Befehl macht das der Amiga. Das Suchen kann auch auf bestimmte Register eingeschränkt werden. Rx : PC / D0 - D7 / A0 - A7 Die Nummern der Trace-Einträge, die die gesuchten Daten enthalten, werden angezeigt, und können mit den Befehlen 'tt num' und 'tr num' detailiert angesehen werden. Format: tf [A=] [Rx=] adr : Nur Adresse = Durchsuchen gesamte Trace- Daten Mit Register = Suchen nur Wert in Register [A=] = Adresse der Resident-Daten Siehe bei Befehl 'tr' Beisp.: tf feld1 = Suchen Trace-Einträge, die die Adresse des Labels 'feld1' enthalten (PC und alle Regs) tf a0=feld1 = Suchen Trace-Einträge, die die Adresse des Labels 'feld1' im Register A0 enthalten tf pc=lesen = Suchen Trace-Einträge, die die Adresse des Labels 'lesen' als PC-Wert enthalten TG => GO : Starte Test-Programm ohne Trace -------------------------------------------- Mit diesem Befehl wird ein Test-Programm ohne Trace gestartet bzw. fortgeführt. Da UDebug keine Kontrolle ausübt, läuft das Programm in Orginal-Geschwindigkeit. Eine Unterbrechung aus diesem Modus geschieht bei Erreichen eines gesetzten Breakpoints (tb), beim Auftreten einer Exception (in der Regel ein Fehler) und beim Beenden des Programms. UDebug hat eine weitere, etwas eingeschränkte Möglichkeit zum Unter- brechen eines im Go-Modus laufenden Programms: Es wird eine Interrupt gesteuerte Routine gestartet (IRQ Level 5 = Bild- wechsel-Impuls = 50 mal pro Sekunde), die das Drücken der Break-Taste (Default ESC - siehe 'set brk') merkt und ab diesem Zeitpunkt 50 mal in der Sekunde versucht, das Programm zu unterbrechen. Diese Unterbrechung geschieht aber nur, wenn während der Interrupt- Routine das Test-Programm sich auf einer gültigen Programm-Adresse befindet (gültige Programm-Adresse = innerhalb der geladenen Segmente des Test-Programms). Dies ist notwendig, denn wenn das Programm in Betriebssystem-Routinen unterbrochen wird, kann es zu Schwierigkeiten kommen. Das heißt: Wenn das Programm nur in System-Routinen arbeitet, kann nicht unterbrochen werden. Auch ist zu beachten, daß Unterbrechungs-Versuche 50 mal pro Sekunde, sich zwar viel anhört, für einen 680x0-Processor aber mehr Zufalls- treffer sind und dann darf das Programm nicht in Betriebssystem-Routinen befinden. Das Aktivieren der IRQ-Routine kann man mit der Option -i unterdrücken. Dann kann ein Programm im Go-Modus mit der Break-Taste nicht unter- brochen werden. Format: tg [adr] : Ohne Parameter = Starten ein Programm ab der aktuellen PC-Adresse. adr = Go-Modus an der angegebenen Adresse starten. Beisp.: tg = Programm an der alten PC (Programm-Counter) Adresse fortsetzen. tg start+12 = Go-Modus an der Label-Adresse start+12 starten TH => Listen der Trace-Befehle (Hilfe) --------------------------------------- Format: th : Ohne Parameter Beisp.: th = Listen aller Befehle für Trace TI => Listen gesetzte Trace-Schalter und Trace-Tab-Daten --------------------------------------------------------- Format: ti : Ohne Parameter Beisp.: ti = Listen Trace-Daten Es werden die Trace-Daten in folgendem Format gelistet: Resident Trace $3605D8 Entries: $0064 (TF/TR/TT A=00C9FC) Gesamt-Trace: $003012 In Tab : $0064 Task: $2FF0A8 testpgm UP-Areas (no Trace) : Anf-Adr Symbol End-Adr Symbol 3519D4 upanf 352C14 upend Lib-Trace "JSR ..(a6)" OFF BSR/JSR-Trace ON Change-Check: Anf-Adr Anf-Symbol Op :Len Vergleichs-Werte Intv= $0008 00338178 start != 0004 4EF90033 Breakpoints: Adr Hits Set Symbol $34E320 $0001 $0003 lesen Resident Trace : Adr Beginn der Trace-Tabelle Entries : Größe der Trace-Tabelle ($0064=100 Einträge) (TR/TT A=....) : Hilfs-Adresse für die Befehle tf,tr,tt Gesamt-Trace : Summe aller Trace-Schritte In Tab : Anzahl Trace-Einträge in Trace-Tabelle Task : Adr der Test-Task und der Programm-Name UP-Areas (no Trace) : Befehl 'tua' Liste der UP-Bereiche, die bei JSR/BSR ohne Trace abgearbeitet werden. Lib-Trace "JSR ..(a6)" : Befehl 'tl' ON = JSR ..(a6) wird getraced OFF = JSR ..(a6) wird nicht getraced (default) BSR/JSR-Trace : Befehl 'tu' ON = BSR/JSR wird getraced OFF = BSR/JSR wird erst nach RTS weiter ge- traced. Unterschied zu den UP-Areas (Befehl 'tua') : 'BSR/JSR-Trace' betrifft alle JSR/BSR-Befehle des Test-Programms und schließt damit auch die 'UP-Areas' ein. Bei 'UP-Areas' werden nur die angegebenen Bereiche bei JSR/BSR nicht getraced. Change-Check : Befehl 'tc' Es wird in Interval von 8 (Befehl tci) Trace- Schritten die Adr in der Länge (:Len) mit dem Vergleichswert verglichen. Trifft die Bedin- gung (Op) zu, wird das Testprogramm unter- brochen. Breakpoints : Befehle 'tb/tbc' Liste der Break-Points Hits : Vorgekommene Durchläufe Set : Anzahl Durchläufe bei denen ein Break erfolgt TJ => Trace Programm ohne UP-Trace ------------------------------------ Dieser Befehl entspricht dem Befehl 't', nur die JSR/BSR-Befehle werden ohne Trace und ohne UDebug-Kontrolle ausgeführt, d.h. alle bis zum nächsten Stopp abzuhandelden BSR/JSR-Befehle werden im Direkt (Go)-Modus ohne Rücksicht des 'tu'-Schalters ohne Trace ausgeführt. Sinnvoll ist dieser Befehl, wenn man mit 'tu 0' alle BSR/JSR-Befehle im Trace-Modus ausgeführen lassen will, aber dann doch einzelne Unterprogramme ohne Trace durchlaufen will. Dann muß nicht der 'tu'- Schalter verändert werden, sondern es reicht 'tj'. ACHTUNG: Wenn nach Eingabe des 'tj'-Befehls und durch drücken der Return-Taste eine Trace-Fortsetzung erfolgt, entspricht das nur dem 't'-Befehl, d.h. der erzwungene BSR/JSR-Direkt-Aus- führung ist nicht mehr aktiv. Format: tj [num] : Ohne Parameter = Einzelschritt-Trace num = Anzahl Trace-Schritte TK => Listen Stack-Daten -------------------------- UDebug hat eine eingebaute Stack-Verfolgung. Mit diesem Befehl kann man diese anlisten und so sehen, von welcher Adresse und Befehl die Stack-Daten stammen. Siehe auch nachfolgenden Befehl 'tko'. Wenn der Stack von einer im Go-Modus laufender Routine verändert wird, kennt UDebug zwar nicht den ausgeführten Befehl, merkt aber trotzdem die Veränderung am Stack. In diesem Fall werden die unbekannten Befehle als Fragezeichen (???) dargestellt. Zusätzlich besteht die Möglichkeit, die Stack-Daten permanent in einem seperaten Window anzuzeigen (Befehl 'ws 1'). Es werden immer die letzten Befehle im Window angezeigt. Die Anzahl ist aber durch die Größe des Windows (kann vergrößert werden) begrenzt. Bei sehr viel Daten auf dem Stack kann der vollständige Inhalt dann nur mit diesem Befehl angezeigt werden. Format: tk : Ohne Parameter TKO => Setzen Stack-Verfolgung an oder aus ------------------------------------------- Die im UDebug eingebaute Stack-Verfolgung merkt sich nicht nur die Befehle, die den Stack verändern, sondern überprüft auch, ob der vor- gegebene Stack (von UDebug) ausreicht. Wenn jetzt das Test-Programm nicht den von UDebug vorgegebenen Stack benutzt, sondern einen eigenen Bereich benutzt, stoppt UDebug entweder mit der Meldung 'Stack Overflow' oder mit 'Error 4 in Stack-Control'. Damit ein solches Programm dann weiter getestet werden kann, muß die Stack-Verfolgung abgeschaltet werden. Das aber bedeutet, daß eine wichtige Funktion von UDebug nicht benutzt wird. Deshalb mein Vorschlag: Wenn das Test-Programm einen eigenen Stack benutzen soll, dies erst nach dem Austesten in das Programm einbauen. Mit dem 'set stk'-Befehl kann die Stack-Größe beliebig vergrößert werden. Die Stack-Verfolgung kann während des Testes abgeschaltet, aber nicht angeschaltet werden. Dies geht nur vor dem Start eines Test-Programms. Format: tko [{0/1}] : Ohne Parameter = Wechsel Stack-Verfolgung 0 = setzen Stack-Verfolgung aus 1 = setzen Stack-Verfolgung an Beisp.: tko = Wechsel Stack-Verfolgung tko 0 = Setzen Stack-Verfolgung aus tko 1 = Setzen Stack-Verfolgung an TL => Setzen Lib-Trace an oder aus ----------------------------------- Mit diesem Befehl kann man die speziellen Amiga Library-Aufrufe vom Trace ausschließen (Go-Modus) oder einschließen (Trace-Modus). Da die im System vorhandenen Libraries normalerweise ausgetestet und kaum Fehler haben, werden diese Aufrufe von UDebug ohne besondere Angabe (default) vom Trace ausgeschlossen. Mit der Befehl 'tl 1' kann das Tracen der Library-Aufrufe wieder eingeschaltet werden. Format: tl [{0/1}] : Ohne Parameter = Wechsel Lib-Trace-Status 0 = setzen Lib-Trace aus 1 = setzen Lib-Trace an Beisp.: tl = Wechsel Lib-Trace-Status tl 0 = Setzen Lib-Trace aus tl 1 = Setzen Lib-Trace an TN => Verändern Größe der Trace-Tabelle ---------------------------------------- Mit diesem Befehl kann man die Anzahl Trace-Einträge in der Trace- Tabelle verändern. Es wird zuerst die neue Trace-Tabelle erstellt, bevor die alte Trace-Tabelle gelöscht wird. Sollte nicht genug Speicher- platz für die neue Trace-Tabelle vorhanden sein, bleibt die alte erhalten. Die Größe der Trace-Tabelle hat keinen Einfluß auf die Geschwindigkeit beim Tracen der Programme. Format: tn num : num = Neue Anzahl Einträge in Trace-Tabelle Beisp.: tn 1000 = Ändern Trace-Entries auf 1000 (Wenn die Zahlen-Eingabe Hex (default) ist, entspricht die Eingabe Hex 1000 = dezimal 4096 Einträge) TQ => Quick-Trace : Trace nur im Speicher ------------------------------------------ Mit diesem Befehl wird der Trace der einzelnen Programmschritte im Speicher abgelegt (Trace-Tabelle: Größe siehe Befehl 'tn'). Die Darstellung am Bildschirm unterbleibt aus Geschwindigkeit-Gründen. Ein im Endlos-Quick-Modus (keine num-Angabe) laufendes Programm kann durch gesetzte Breakpoints (Befehl 'tb'), durch Change-Breakpoints (Befehl 'tc') und durch drücken der Break-Taste (Default ESC: siehe auch 'set brk') unterbrochen werden. Das Programm wird immer an der aktuellen PC-Adresse fortgesetzt. Falls die Fortsetzung an einer anderen Adresse beginnen soll, muß der 'tqa'- Befehl benutzt werden oder mit dem Befehl 'r pc=adr' die aktuelle PC- Adresse vorher geändert werden. Noch ein Tip: Dieser Trace-Art läßt ein Programm zwar nicht in Echtzeit ablaufen, kann aber doch eine akzeptable Geschwindigkeit erreichen. Dazu sollte der Library-Trace nicht aktiv sein (Befehl 'tl 0'). Noch schneller wird der Test, wenn eigene ausgetestete Unterprogramme mit dem Befehl 'tua' vom Trace ausgeschlossen werden. Auch sollten die Memory-Windows nicht aktiv sein ('wm1 0' und 'wm2 0'), da das dynamische Anzeigen in diesen Windows den Trace stark verzögert. Format: tq [num] : Ohne Parameter = Endlos Quicktrace num = Anzahl Quick-Trace-Schritte Beim Erreichen der Anzahl wird das Programm automatisch unter- brochen. Beisp.: tq = Endlos-Quicktrace tq 8 = Das Programm wird nach 8 Trace-Schritten unterbrochen TQA => Quick-Trace Programm mit neuer PC-Adresse ------------------------------------------------- Dieser Befehl entspricht dem Befehl 'tq', nur muß zusätzlich eine neue PC-Adresse mit angegeben werden. Format: tqa adr [num] : adr = Neue PC-Adresse num = Anzahl Quick-Trace-Schritte TQE => Quick-Trace mit UP-Trace --------------------------------- Dieser Befehl entspricht dem Befehl 'tq', nur die JSR/BSR-Befehle werden mit Trace und unter UDebug-Kontrolle ausgeführt, d.h. alle bis zum nächsten Stopp abzuhandelden BSR/JSR-Befehle werden ohne Rücksicht des 'tu'-Schalters im Trace-Modus ausgeführt. Sinnvoll ist dieser Befehl, wenn man mit 'tu 1' alle BSR/JSR-Befehle im Direkt (Go)-Modus ausgeführen lassen will, aber dann doch einzelne Unterprogramme tracen will. Dann muß nicht der 'tu'-Schalter ver- ändert werden, sondern es reicht 'tqe'. Format: tqj [num] : Ohne Parameter = Endlos Quicktrace num = Anzahl Quick-Trace-Schritte TQJ => Quick-Trace Programm ohne UP-Trace ------------------------------------------- Dieser Befehl entspricht dem Befehl 'tq', nur die JSR/BSR-Befehle werden ohne Trace und ohne UDebug-Kontrolle ausgeführt, d.h. alle bis zum nächsten Stopp abzuhandelden BSR/JSR-Befehle werden im Direkt (Go)-Modus ohne Rücksicht des 'tu'-Schalters ohne Trace ausgeführt. Sinnvoll ist dieser Befehl, wenn man mit 'tu 0' alle BSR/JSR-Befehle im Trace-Modus ausgeführen lassen will, aber dann doch einzelne Unterprogramme ohne Trace durchlaufen will. Dann muß nicht der 'tu'- Schalter verändert werden, sondern es reicht 'tqj'. Format: tqj [num] : Ohne Parameter = Endlos Quicktrace num = Anzahl Quick-Trace-Schritte TR => Listen Trace-Daten mit Register-Daten -------------------------------------------- Mit diesem Befehl werden die Daten der Trace-Tabelle angezeigt. Es werden die Befehle mit ihren zugehörigen Register-Daten gelistet. ^^^^^^^^ Wird der Befehl ohne Parameter eingegeben, erfolgt eine Fortsetzung des letzten Trace-Tabellen-Listings. Normalerweise reicht für die Fort- setzung das Drücken der Return-Taste, aber wenn dazwischen andere Befehle eingegeben wurden, kann so das Listing fortgeführt werden. Bei den Befehlen 'tf' 'tr' und 'tt' gibt es den Parameter [A=]. Dieser ist nur für Notfälle gedacht, denn es können bei einem Absturz auch die Resident-Strukturen des Betriebssystems zerstört werden und somit wird die alte Trace-Tabelle nicht gefunden. Da aber der Speicher nicht gelöscht wird und wenn UDebug als erstes nach dem Reset startet wird, ist die Wahrscheinlich groß, daß trotz zerstörter Resident-Struk- tur die UDebug-Trace-Tabellen-Struktur noch erhalten ist und mit Hilfe der Adress-Angabe A=adr ('adr' wird beim Befehl 'ti' angezeigt) ange- listet werden kann. Voraussetzung ist natürlich, daß die Strukturen der UDebug-Trace-Tabelle noch erhalten sind. Sollte auch die Struktur nicht mehr erhalten sein (wird geprüft) bleibt nur noch als Letztes der Befehl 'tta'. Siehe da nach. Format: tr [A=] [num/L/ALL] : [A=] = siehe oben Ohne Param. = Fortsetzung num = Liste ab Trace-Eintrag num L = Liste letzte Einträge ALL = Liste alle Einträge Beisp.: tr 20 = Listen ab Eintrag 20 (wenn Hex:20=32 dez) tr l = Listen die letzten Einträge tr all = Listen gesamte Trace-Tabelle TS => Skip Befehle ab aktueller PC-Adresse ------------------------------------------- Mit diesem Befehl werden ab der aktuellen PC-Adresse eine Anzahl von Befehlen geskipt und eine neue aktuelle PC-Adresse gesetzt. ACHTUNG: Die Register-Inhalte werden nicht verändert Format: ts num : Die aktuelle PC-Adresse wird um 'num'-Befehle vorgesetzt. Beisp.: ts 4 = Es werden 4 Befehle geskipt bzw. übersprungen. TT => Listen Trace-Daten (Nur Befehle) --------------------------------------- Mit diesem Befehl werden die Daten der Trace-Tabelle angezeigt. Der Befehl entspricht in Format und Wirkung dem Befehl 'tr', nur werden bei 'tt' nur die Befehle ohne Register-Inhalte angezeigt. Format: tt [A=] [num/L/ALL] : Siehe bei 'tr' TTA => Listen Trace-Tabelle --------------------------- Dieser Befehl sollte nur in Notfällen benutzt werden. Wenn nach einem System-Reset die Resident-Strukturen der UDebug-Trace-Tabelle nicht gefunden bzw. zerstört sind, besteht mit diesem Befehl die Möglichkeit, noch die Daten der Trace-Tabelle selbst zu listen. Allerdings gibt es zwei wichtige Einschränkungen: Bei der erzeugten Liste werden keine Symbole angezeigt und es muß der letzte aktuelle Befehl selbst gesucht werden. Die Adresse der Trace-Tabelle wird beim Befehl 'ti' unter 'Resident Trace' angezeigt. Format: tta adr num : Adresse der Trace-Tabelle (adr) und die Anzahl Trace-Einträge (num) Beisp.: tta 3605d8 64 = Adresse $3605d8 und 100 Einträge (Hex=64) TU => Setzen BSR/JSR-Trace an oder aus --------------------------------------- Mit diesem Befehl kann man die BSR- und JSR-Aufrufe vom Trace aus- schließen bzw. einschließen. Bei UDebug wird als Default das Tracen von BSR- und JSR-Aufrufe durchgeführt. Mit dem Befehl 'tu 0' kann man das Tracen der BSR- UND JSR-Aufrufe ausschalten und mit 'tu 1' wieder ein- schalten. Dieser Befehl gilt für die Trace-Befehle 'tq' und 't'. Bei diesen beiden Befehlen besteht auch die Möglichkeit die aktuelle Schalterstellung für JSR/BSR-Trace temporär zu umgehen: 'tj' und 'tqj' bedeuten JSR/BSR-Trace temporär aus und 'te' und 'tqe' bedeuten temporär an. Format: tu [{0/1}] : Ohne Parameter = Wechsel BSR/JSR-Trace-Status 0 = setzen BSR/JSR-Trace aus 1 = setzen BSR/JSR-Trace an Beisp.: tu = Wechsel BSR/JSR-Trace-Status tu 0 = Setzen BSR/JSR-Trace aus tu 1 = Setzen BSR/JSR-Trace an TUA => Listen, Löschen und Setzen von Unterprogramm-Bereichen (Kein Trace) -------------------------------------------------------------------------- Mit diesem Befehl kann man Unterprogramm-Bereiche definieren, bei deren Aufruf (JSR/BSR) bis zum RTS kein Trace erfolgt. Dies ist sinnvoll zum schnellen Durchlauf eigener schon ausgetesteter Unter-Programme. Es können maximal 10 UP-Bereiche definiert werden. In einer der ersten Versionen von UDebug hatte ich den gesamten Rom- bereich (Bei mir FC0000-FFFFFE) mit 'tua' definiert und so das Tracen der Rom-Routinen ausgeschaltet. Erst mit dem Befehl 'tl - No Lib-Trace' habe ich meiner Meinung nach das 'Nicht Tracen' der System-Routinen besser gelöst. Format: tua [adr1] [adr2] : Ohne Parameter = Listen UP-Bereiche Nur eine Adresse = Löschen UP-Bereich Zwei Adressen = Setzen UP-Bereich Beisp.: tua = Listen definierte Unterprogramm-Bereiche tua upanf upend = Setze UP-Bereich von Label 'upanf' bis 'upend' tua upanf = Lösche UP-Bereich upanf TUJ => TUA-Bereiche auch bei JMP-Befehlen aktiv/inaktiv ------------------------------------------------------- Dieser Befehl steht im Zusammenhang mit der 'tua'-Befehl. Die 'tua'- Bereiche (siehe oben) werden normalweise nur beim Aufruf über JSR/BSR- Befehle nicht getraced. Es kommt aber auch vor, das Routinen erst mit einem zwischengeschalteten JMP angesprungen werden. Für diese Fälle ist der 'tuj'-Befehl gedacht. Man kann die JMP-Funktion ein- und aus- schalten. ACHTUNG: Wenn nach dem BSR/JSR und vor dem JMP am Stack manipuliert wird und diese Manipulation dann im Unterprogramm wieder aufgehoben wird (vor RTS), gibt es einen System-Absturz. Format: tuj [{0/1}] : Ohne Parameter = Wechsel JMP-Funktion 0 = setzen JMP-Funktion aus 1 = setzen JMP-Funktion an Beisp.: tuj = Wechsel JMP-Funktion tuj 0 = Setzen JMP-Funktion aus tuj 1 = Setzen JMP-Funktion an TW => Wiederhole alten Befehl (PC und Register werden zurückgesetzt) --------------------------------------------------------------------- Mit diesem Befehl können PC und Register auf einen alten Zustand zurück- gesetzt werden. Voraussetzung dafür ist, daß der zu wiederholende Zu- stand sich noch in der Trace-Tabelle befindet, z.B. bei der Default- Trace-Tab-Größe von 100 Einträgen können die letzten 99 Befehle wieder- holt werden. Es kann eine Anzahl von Befehlen oder eine Adresse (auch Source-Label) angegeben werden. ACHTUNG: Sind in dem zurückgesetzten Befehls-Bereich Feldinhalte ver- ändert worden, so werden diese nicht automatisch zurückgesetzt und man muß diese manuell (Befehl 'mm') zurücksetzen. Format: tw {num/adr} : num = Es wird 'num'-Befehle zurückgesetzt adr = Es wird nach einem PC-Stand mit der angegebenen Adresse gesucht (rück- wärts) und wenn gefunden, auf diesen Zustand zurückgesetzt. Beisp.: tw 4 = Die aktuellen PC- und Register-Werte werden um 4 Befehle zurückgesetzt. tw start = Es wird auf die PC- und Register-Werte des letzten Trace-Schrittes mit dem Label 'start' zurückgesetzt. TX => Test-Programm am Label _exit starten -------------------------------------------- Dieser Befehl beruht auf einer Anregung, die mir ein C-Programmierer vor Jahren gegeben hat: Bei einem C-Compiler (ich weiß nicht welcher, oder ob alle) besteht die Möglichkeit, sein Programm, in welchen Zustand auch immer, über den Label '_exit' zu verlassen. Diese Routine '_exit' sollte so geschaffen sein, daß alle belegten Resourcen wieder frei- gegeben werden. Im Gegensatz zu den Befehlen 'ta _exit' 'tg _exit' und 'tqa _exit' wird beim 'tx'-Befehl zusätzlich das Stack-Register auf seinen Anfangs- Wert zurückgesetzt. Mit dem Befehl 'set tx' kann der Name des Labels '_exit' geändert werden. Format: tx : Ohne Parameter ============================================================================= Weitere Befehle für Trace ============================================================================= R => Listen und Verändern Register-Inhalte --------------------------------------------- Mit diesem Befehl kann der Inhalt der Test-Register angezeigt und geändert werden. Zusätzlich besteht die Möglichkeit, die Register-Daten permanent in einem seperaten Window anzuzeigen (Befehl 'wr'). Format: r [reg=num] : Ohne Parameter = Register listen reg= = Register-Name: PC,CC, A0-A7, D0-D7 num = Neuer Registerwert Beisp.: r = Register-Inhalte listen r pc=les = PC (Programm-Counter) auf Adresse des Labels les r cc=08 = Status-Register ändern (Negativ an) r d3=555 = Wert 555 nach Register D3 r a2=feld1 = Adresse von Label feld1 nach Register A2 r a4=a4+1 = Inhalt Register A4 um 1 erhöht r a4=0a4+1 = Inhalt Register A4 wird 000000A5 S => Listen Segment-Daten (Programmteile des Testprogramms) -------------------------------------------------------------- Mit diesem Befehl werden die Adresse, Länge, Typ und Anzahl Symbole der einzelnen Segmente des geladenen Testprogramms angezeigt. Falls die Anzahl Symbole Null ist, enthält das Segment keine Symbole. Um mit Source-Label zu testen, muß dem Assembler mit einer Option die Anweisung zum Erstellen der Symbole gegeben werden: Beim A68K ist es die -d Option. Beim Assem ist es die -s Option. Beim Aztec ist es die -W beim Linker ln. Beim Devpac ist es die -dl Option Beim OMA ist es die <-c s> Option Format: s : Listen die Segmente des geladenen Testprogramms SL => Laden Segmente (Test-Programm) -------------------------------------- Mit diesem Befehl wird ein Testprogramm geladen. Nach dem Laden werden die einzelnen Segmente und die eingestellten Trace-Optionen angezeigt. Es kann immer nur ein Testprogramm geladen werden. Um ein Programm zu testen, muß es mit dieser Funktion geladen werden. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Nach dem Laden des Test-Programms fragt UDebug nach den Programm-Start- Parametern. Damit kann man Parameter, die beim Cli-Start dem Programm übergeben werden, in gleicher Form von UDebug dem Test-Programm über- geben lassen. Ist Groß- und Kleinschreibung erforderlich, müssen die Parameter mit der Text-Kz (default: Hochkomma) beginnen. Dieses wird dem Test-Programm nicht mit übergeben. Falls keine Parameter erforderlich sind, nur Return drücken. Wenn der 'sl'-Befehl ohne Datei-Name eingegeben wird und die benötigte Requester-Library ist vorhanden (siehe Installation), wird die Datei über Requester angefordert. Format: sl name : name = Name und Pfad des zu ladenen Programms. Beisp.: sl dh0:bin/test : Es wird das Testprogramm 'test' aus der Directory 'dh0:bin' geladen. Programm-Start-Parameter: -t -g nur Kleinschreibung '-t -G Wenn Groß- und Kleinschreibung erf. SU => Unload Segmente (löschen Test-Programm) ----------------------------------------------- Mit diesem Befehl wird ein Testprogramm wieder entladen. Format: su : Ohne Parameter = Programm wieder entladen H6 => Hilfe für letzten 'JSR LVO..(A6)' Befehl ----------------------------------------------- Mit diesem Befehl wird das Aufruf-Format des letzten beim Trace aufge- tretenen Lvo-Funktion angezeigt. Allerdings muß die Offset-Datei beim Start bzw. mit dem 'rof'-Befehl eingelesen worden sein. Format: h6 : Ohne Parameter = Liste Format letzten Lvo-Cmd HD => Hilfe für Device-LVO-Funktionen --------------------------------------- Mit diesem Befehl wird das Aufruf-Format von Device-Lvo-Funktionen angezeigt. Das angegebene Symbol kann auch verkürzt angegeben werden. z.B 'hd r' zeigt alle Funktionen, die mit 'r' anfangen. Groß- und Kleinschreibung ist nicht erforderlich. Allerdings muß die Offset-Datei beim Start bzw. mit dem 'rof'-Befehl eingelesen worden sein. Format: hd [symbol] : Ohne Parameter = Listet alle Funktionen für Devices symbol = Anfang des Lvo-Funktions- Namens Beisp.: hd read = Zeigt alle Device-Funktionen, die mit 'read' anfangen HL => Hilfe für Library-LVO-Funktionen ---------------------------------------- Dieser Befehl entspricht dem 'hd'-Befehl, nur lassen sich Library- Funktionen damit listen. Format: hl [symbol] : Ohne Parameter = Listet alle Funktionen für Libraries symbol = Anfang des Lvo-Funktions- Namens Beisp.: hl read = Zeigt alle Library-Funktionen, die mit 'read' anfangen HR => Hilfe für Resource-LVO-Funktionen ----------------------------------------- Dieser Befehl entspricht dem 'hd'-Befehl, nur lassen sich Resource- Funktionen damit listen. Format: hr [symbol] : Ohne Parameter = Listet alle Funktionen für Resources symbol = Anfang des Lvo-Funktions- Namens Beisp.: hr read = Zeigt alle Resource-Funktionen, die mit 'read' anfangen SYK => Symbole vorne bzw. hinter verkürzen ------------------------------------------- UDebug hat bei seiner formatierten Ausgabe für die Anzeige von Symbolen eine Länge von 12 Zeichen vorgesehen. Da aber für die Darstellung der Displacements bis zu 4 Zeichen benutzt werden können (z.B. lesenwin+123) ist eine vollständige Anzeige der Symbol-Namen nur bis 8 Zeichen garan- tiert. Längere Symbole werden verkürzt dargestellt: z.B. '~enwindow+20' Die Verkürzung wird durch das '~' Zeichen angezeigt. In diesen Beispiel fehlen die Zeichen 'les'. UDebug schneidet normalerweise bei zu langen Symbolen den vorderen Teil ab. Es kann aber je nach Gestaltung der Symbolnamen sinnvoll sein, das nicht vorne sondern hinten abgeschnitten wird: z.B. 'lesenwin~+20'. Es fehlt 'dow'. Mit diesem Befehl kann jeder Benutzer die Art der Verkürzung selbst aus- wählen. Format: syk [{0/1}] : Ohne Parameter: Wechsel hinten/vorne hinten verkürzen (0) und vorne verkürzen (1) Beisp.: syk = Wechsel Verkürzung vorne/hinten syk 0 = Verkürzung hinten syk 1 = verkürzung vorne (default) SYM => Listen Symbole des Test-Programms ----------------------------------------- Mit diesem Befehl werden die Symbole des Test-Programms gelistet. Die Symbol-Namen können auch in verkürzter Form angegeben werden. Format: sym [symbol] : Ohne Parameter = Alle Symbole listen symbol = Listen Symbole mit gleichen Anfangs-Buchstaben Beisp.: sym = Listen alle Symbole des Test-Programms sym fel = Listen alle Symbole, die mit 'fel' anfangen ============================================================================= Window-Befehle ============================================================================= WR => Öffne Register-Window ----------------------------- Mit diesem Befehl wird ein Register-Window eröffnet bzw. wieder geschlossen. Es wird die Test-Register, das Status-Register, Adresse bei indirekter Adressierung, Branch-Bedingung und der nächste auszu- führende Befehl angezeigt. Das entspricht 11 Zeilen, und das Window kann nicht unter diese Größe verkleinert werden. Aber eine Vergrößerung mit dem Size-Gadget ist möglich. Dann werden weitere nachfolgende Befehle angezeigt. Mit dem 'set wr'-Befehl kann die Größe des Windows ebenfalls verändert werden. Falls Sie mit der Default-Größe des Register-Windows nicht ein- verstanden sind, ist es sinnvoll, mit Hilfe dieses 'set wr'-Befehls im Config-File Ihre gewünschte Größe vorzukonfigurieren. Die Daten im dem Window werden aus Geschwindigkeits-Gründen nur bei einem Trace-Stopp aktualisiert. Format: wr [{0/1}] : Ohne Parameter: Schalter ein/aus Ausschalten (0) und Einschalten (1) Beisp.: wr = Register-Window eröffnen, wenn es noch nicht vorhanden oder schließen, wenn es schon vor- handen ist. wr 1 = Register-Window eröffnen wr 0 = Register-Window schließen Wenn die Funktion Einschalten (1) für ein schon eröffnetes Window eingegeben wird, wird das Window nur nach vorne (Window to Front) gebracht. WS => Öffne Stack-Window -------------------------- Dieser Befehl entspricht dem 'wr'-Befehl, nur gilt er für das Stack- Window. Die Größe des Windows kann mit dem Befehl 'set ws' konfiguriert werden. Minimale Größe = 7 Zeilen. Format: ws [{0/1}] : Ohne Parameter: Schalter ein/aus Ausschalten (0) und Einschalten (1) WM1 => Öffne 1.Memory-Window ----------------------------- Mit diesem Befehl wird ein Memory-Window eröffnet bzw. geschlossen. Insgesamt kann UDebug maximal zwei Memory-Windows eröffnen. Wenn UDebug im Eingabe-Modus ist, werden die Daten des Memory-Windows ca. jede Sekunde erneuert. Wenn ein Test-Programm im Trace-Modus (nicht Go-Modus) läuft, wird der Inhalt des Window nach 512 getracten Befehlen (ohne Stop) erneuert. Dieser Wert kann mit dem 'wmn'-Befehl verändert werden. Beim Trace-Stop wird der Inhalt des Memory-Windows grundsätzlich erneuert. Die Größe des Windows kann mit dem Befehl 'set wm1' konfiguriert werden. Minimale Größe = 2 Zeilen. Format: wm1 [{0/1}] : Ohne Parameter: Schalter ein/aus Ausschalten (0) und Einschalten (1) WM2 => Öffne 2.Memory-Window ----------------------------- Dieser Befehl entspricht dem Befehl 'wm1' für ein zweites Memory-Window. Die Größe des Windows kann mit dem Befehl 'set wm2' konfiguriert werden. Minimale Größe = 2 Zeilen. WMN => Setze Intervall für Refresh Memory-Window's ---------------------------------------------------- Wenn ein Programm im Trace-Modus (nicht Go-Modus) läuft, werden die Daten im Memory-Window nach einer bestimmten Anzahl Trace-Schritte (Default 512) erneuert. Mit diesem Befehl kann der Intervall-Wert verändert werden. Es kann ein Wert von 0-7fff (32767) angegeben werden. Bei dem Wert Null erfolgt kein Refresh der Memory-Windows. Wenn sich UDebug im Eingabe-Modus befindet, d.h. kein Trace läuft, werden die Memory-Windows ca. jede Sekunde refresht. Dieser Wert ist nicht veränderbar. ACHTUNG: Bei einem kleinen Wert wird der laufende Trace stark verzö- gert. Format: wmn [num] : Ohne Parameter = Listen Refresh-Wert num = Wert von 0-32767 Beisp.: wmn = Listen Refresh-Wert wmn 0 = Refresh ausschalten wmn 560 = Refresh nach 560 Trace-Schritten WF => Bei Teststop UDebug-Window nach vorn bringen Ein/Aus ------------------------------------------------------------ Mit diesem Befehl kann gesteuert werden, ob bei Teststop (Breakpoint usw.) das Haupt-Window von UDebug nach vorne gebracht werden soll. ACHTUNG: Wenn bei mehreren Window's die Funktion 'To Front' aktiv ist, gibt es durch den Wechsel der Windows ein unangenehmes Flackern am Bildschirm. Mein Vorschlag: Legen Sie sich die Befehle 'wtf','wr 1','ws 1', 'wm1 1' und 'wm2 1' auf Funktions-Tasten. Mit diesen Befehlen werden nicht nur Windows eröffnet, sondern schon vorhandene auch nach vorne gebracht. In der unmodifizierten UDebug-Version sind folgende F-Tasten mit Window-Funktion belegt: F1 = UDebug-Window nach vorn F2 = Register-Window nach vorn F3 = Stack-Window nach vorn F4 = 1.Memory-Window nach vorn F5 = 2.Memory-Window nach vorn Format: wf [{0/1}] : Ohne Parameter = Wechsel Ein/Aus 0 = setzen to Front aus 1 = setzen to Front an Beisp.: wf = Wechsel ein/aus wf 0 = Setzen Funktion 'Window to Front' aus wf 1 = Setzen Funktion 'Window to Front' an WFR => Bei Teststop UDebug-Register-Window nach vorn bringen Ein/Aus --------------------------------------------------------------------- Mit diesem Befehl kann gesteuert werden, ob bei Teststop (Breakpoint usw.) das Register-Window nach vorne gebracht werden soll. Dieser Befehl kommt natürlich nur zum tragen, wenn ein Register-Window eröffnet ist. Format: wfr [{0/1}] : Ohne Parameter = Wechsel ein/aus 0 = setzen aus 1 = setzen an Beisp.: wfr = Wechsel Ein/Aus wfr 0 = Setzen Funktion 'Reg-Window to Front' AUS wfr 1 = Setzen Funktion 'Reg-Window to Front' AN WFS => Bei Teststop UDebug-Stack-Window nach vorn bringen Ein/Aus ------------------------------------------------------------------ Dieser Befehl entspricht dem 'wfr'-Befehl, nur gilt er für das Stack- Window. WF1 => Bei Teststop UDebug-1.Memory-Window nach vorn bringen Ein/Aus --------------------------------------------------------------------- Dieser Befehl entspricht dem 'wfr'-Befehl, nur gilt er für das 1.Memory-Window. WF2 => Bei Teststop UDebug-2.Memory-Window nach vorn bringen Ein/Aus --------------------------------------------------------------------- Diese Befehl entspricht dem 'wfr'-Befehl, nur gilt er für das 2.Memory-Window. WRS => Anzeige im Register-Window mit Symbolen Ein/Aus ------------------------------------------------------- Mit diesem Befehl kann gesteuert werden, ob im Register-Window auch Symbole angezeigt werden sollen. Format: wrs [{0/1}] : Ohne Parameter = Wechsel ein/aus 0 = Ohne Symbole 1 = Mit Symbolen Beisp.: wrs = Wechsel Ein/Aus wrs 0 = Register-Window ohne Symbole wrs 1 = Register-Window mit Symbolen WA1 => Setzen Anzeige-Adresse für 1.Memory-Window -------------------------------------------------- Mit diesem Befehl wird die Anzeige-Adresse für das 1.Memory gesetzt. Es kann eine absolute oder eine dynamische Adresse angegeben werden. Die dynamische Adresse wird mit dem Zeichen für eine Zeile (siehe 'm' und 'd'-Befehl: Default = '.' = Punkt) gekennzeichnet. Format: wa1 adr : adr = Anzeige-Adresse Beisp.: wa1 676 = Zeige im 1.Memory-Window die Daten ab Adresse 676 wa1 feld1 = Zeige die Daten ab Symbol feld1 wa1 a3 = Die Adresse des aktuellen Registers A3 wird als Anzeige-Adresse genommen. Die Anzeige ändert sich nicht, wenn sich der Inhalt von dem Register A3 ändert. wa1 a3. = Die Adresse des aktuellen Registers A3 wird als Anzeige-Adresse genommen. Der am Schluß stehende Punkt bedeutet: Die Anzeige-Adresse ändert sich, wenn sich der Inhalt des A3- Registers ändert. wa1 676. = Der Punkt nach einer absoluten Adresse oder nach einem Symbol bedeutet: Es wird nicht die Adresse 676 angezeigt, sondern als Anzeige- Adresse wird der Inhalt von dem 4-Byte-Feld 676-679 genommen. Ändert sich der Inhalt die- ses Feldes, ändert sich auch die Anzeige- Adresse. WA2 => Setzen Anzeige-Adresse für 2.Memory-Window -------------------------------------------------- Dieser Befehl entspricht dem 'wa1'-Befehl, nur gilt er für das 2.Memory-Window. WTF => UDebug-Window to Front ------------------------------ Mit diesem Befehl wird das UDebug-Window nach vorne gebracht. Format: wtf : Ohne Parameter ============================================================================= Memory-Befehle ============================================================================= UDebug ermittelt die verfügbaren Speicher-Bereiche und prüft dann bei ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ vielen Befehlen, ob für die angegebenen Adressen auch Ram vorhanden ist. Je nach Befehl kommt entweder die Nachricht 'Invalid address' oder der nicht verfügbare Ram wird umgangen ('f' 'm' 'mi'). Als Default werden der Bereiche 00BFD000-00BFFF00 00DC0000-00DFFFFF und 00F80000-00FFFFFF von UDebug angenommen. Dazu kommen dann die Werte der Exec-Mem-Liste. Mit dem Befehl 'set' werden die verfügbaren Ram-Bereiche angezeigt. Es gibt im Amiga Memory (Ram)-Bereiche, die für die Kommunikation mit den Custumer-Chip's reserviert sind. Dabei gibt es auch Bereiche, bei denen schon ein Lesen dieser Bytes Reaktionen der Chips auslöst. Das kann auch zum Absturz des Rechners führen. Deshalb sind diese Bereiche für die Befehle 'd' 'f', 'm', 'mi' und 'mc' gesperrt, um einen Absturz zu vermeiden. Bei 'm' werden die gesperrten Bereiche mit einem Fragezeichen '?' dargestellt. Als Default sind die Bereiche 00BFD000-00BFFF00 und 00DC0000-00DFFFFF von UDebug für diese Befehle gesperrt. Mit dem Befehl 'set crm' können diese Bereiche geändert werden. Damit aber trotzdem diese Bereiche nicht vollständig im Dunkeln sind, gibt es die Befehle 'mby', 'mwo' und 'mlo', mit denen einzelne Bytes, Words und Longs angezeigt werden können. Aber Vorsicht !!! Falls die von UDebug ermittelten Speicher-Bereiche nicht stimmen (Kon- trolle mit dem 'set'-Befehl), so besteht die Möglichkeit, mit den Befehlen 'set ram' und 'set crm' diese so korrigieren. Wenn die ermittelten Speicher-Bereiche nicht stimmen und Sie diese ändern mußten, würde ich mich freuen, wenn Sie mir eine kurze Mitteilung machen, damit ich den Grund bei der nächsten UDebug-Version berücksich- tigen kann. M => Display Memory in Hex und Ascii --------------------------------------- Mit diesem Befehl wird der Speicher in Hex und in Ascii angezeigt. Normalerweise werden soviel Zeilen gelistet, wie durch den 'nl'-Befehl vorgegeben (default=10), aber wenn nach der Adresse das Zeichen für eine Zeile (default='.'=Punkt) folgt, wird nur eine Zeile angezeigt. Eine Fortsetzung der Anzeige ist durch drücken der Return-Taste möglich. Format: m [adr1] [adr2] : Ohne Parameter = Listen ab letzter Adresse adr1 = Anfangs-Adresse adr2 = End-Adresse Beisp.: m 6766 = Liste 10 Zeilen ab Adresse 6766 m 6766. = Liste 1 Zeile ab Adresse 6766 m feld1. = Liste 1 Zeile ab Label-Adresse feld1 m = Liste 10 Zeilen ab letzter Adresse m . = Liste 1 Zeile ab letzter Adresse m feld1 feld4 = Liste von Adresse 'feld1' bis Adresse 'feld4' MA => Allokieren Memory ------------------------- Mit diesem Befehl wird ein Bereich im Memory von UDebug belegt und kann vom Anwender benutzt werden. Da man beim Amiga nie weiß, welches Programm gerade welchen Speicher- platz benutzt (Multitasking), darf niemand irgenwo im Speicher was verändern, da dadurch wichtige Daten zerstört werden können. Deshalb vor Benutzung eines Speicher-Platzes dieser erst allokiert werden. Format: ma len [CHIP] : len = Länge des zu allokierenden Bereichs chip = Der Bereich wird im Chip-Memory allokiert. Beisp.: ma 100 = Allokiere einen Bereich in der Länge von $100 Bytes ma 50 chip = Allokiere einen Bereich in der Länge von $50 Bytes im Chip-Memory MAA => Allokieren Memory absolut --------------------------------- Mit diesem Befehl wird ein Bereich im Memory ab der vorgegebenen Adresse von UDebug belegt und kann vom Anwender benutzt werden. Wenn der Bereich nicht zur Verfügung steht, gibt UDebug eine Fehlermeldung aus. Format: maa adr len : adr = Anfangs-Adresse des Bereichs len = Länge Bereich Beisp.: maa 180000 20 = UDebug versucht, einen Bereich in der Länge $20 ab der Adresse $180000 zu belegen. MBY => Display 1 Byte Memory in Hex und Ascii ---------------------------------------------- Mit diesem Befehl werden 1 Byte in Hex und in Ascii angezeigt. Normalerweise kann der 'm'-Befehl benutzt werden, aber für diesen sind die reservierten Chip-Bereiche gesperrt. Mit diesem Befehl können auch 4 Bytes des gesperrten Bereichs ausgelesen werden. Aber Vorsicht: Das Lesen einiger Bytes des gesperrten Bereichs kann auch zum Rechner-Absturz führen (siehe 'm'-Befehl). Die Befehle 'mwo' (Word) und 'mlo' (Long) haben die gleiche Funktion mit einer anderen Daten-Länge. Eine Fortsetzung der Anzeige ist durch drücken der Return-Taste möglich. Format: mby [adr1] : Ohne Parameter = Listen ab letzter Adresse adr1 = Byte-Adresse Beisp.: mby a00000 = Listen 1 Byte ab Adresse a00000 MC => Vergleichen (Compare) Memory ------------------------------------ Mit diesem Befehl wird ein Speicher-Bereich (vorgegeben mit adr1 - adr2) mit einem anderen (Anfangs-Adresse vorgegeben mit dest) verglichen. Die nicht übereinstimmenden Byte-Adressen werden angezeigt. Die für die Amiga-Chips reservierten Ram-Bereiche sind für diesen Befehl gesperrt (siehe 'm'-Befehl) Format: mc adr1 adr2 dest : adr1 = Anfangs-Adresse adr2 = End-Adresse dest = Anfangs-Adresse Vergleichs-Bereich Beisp.: mc 800 900 400 = Es wird der Bereich 800-900 mit dem Bereich 400-500 verglichen. MF => Freigeben Memory ------------------------ Mit diesem Befehl werden die mit den 'ma' und 'maa'-Befehlen allokierten Memory-Bereiche wieder freigegeben. Format: mf {adr/ALL} : adr = Anfangs-Adresse eines allokierten Bereichs. Die Länge muß nicht an- gegeben werden, die kennt UDebug. ALL = Alle allokierten Bereiche freigeben Beisp.: mf 180000 = Gebe Bereich ab Adresse 180000 frei mf all = Gebe alle Bereiche frei MFL => Laden File nach Memory ------------------------------ Mit diesem Befehl wird eine Datei (name) in den Speicher (adr) geladen. ACHTUNG: Der von der Datei benötigte Speicher muß vorher mit dem 'ma'- oder 'maa'-Befehl belegt werden, d.h. die Länge der Datei muß vorher ermittelt werden. ACHTUNG: Wenn Programme mit diesem Befehl geladen werden, sind sie nicht ausführbar. Format: mfl adr name : adr = Anfangs-Adresse eines allokierten Bereichs. name = Pfad und Name der Datei Beisp.: mfl 180000 test = Lade die Datei 'test' ab Adresse 180000 in den Speicher. MFS => Save Memory nach File ----------------------------- Mit diesem Befehl wird ein Speicher-Bereich (adr und len) nach einer Datei geschrieben. Format: mfs adr len name : adr = Anfangs-Adresse eines allokierten Bereichs. name = Pfad-Name der Datei Beisp.: mfs 180000 100 test = Save Speicher-Bereich (180000-1800ff) nach der Datei 'test'. MH => Anzeigen der Memory-Befehle (Hilfe) ------------------------------------------- Mit diesem Befehl alle Memory-Befehle angezeigt. Format: mh : Ohne Parameter MI => Display Memory Ascii ---------------------------- Mit diesem Befehl wird der Speicher in Ascii angezeigt. Der Befehl entspricht sonst dem 'm'-Befehl Die für die Amiga-Chips reservierten Ram-Bereiche sind für diesen Befehl gesperrt (siehe 'm'-Befehl) Format: mi [adr1] [adr2] : Ohne Parameter = Listen ab letzter Adresse adr1 = Anfangs-Adresse adr2 = End-Adresse Beisp.: siehe 'm'-Befehl ML => Listen Allokiertes Memory ---------------------------------- Mit diesem Befehl werden die mit den 'ma' und 'maa'-Befehlen allokierten Memory-Bereiche angelistet. Format: ml : ohne Parameter MLO => Display 4 Bytes Memory in Hex und Ascii ----------------------------------------------- Mit diesem Befehl werden 4 Bytes (Long) in Hex und in Ascii angezeigt. Normalerweise kann der 'm'-Befehl benutzt werden, aber für diesen sind die reservierten Chip-Bereiche gesperrt. Mit diesem Befehl können auch 4 Bytes des gesperrten Bereichs ausgelesen werden. Aber Vorsicht: Das Lesen einiger Bytes des gesperrten Bereichs kann auch zum Rechner-Absturz führen (siehe 'm'-Befehl). Die Befehle 'mwo' (Word) und 'mby' (Byte) haben die gleiche Funktion mit einer anderen Daten-Länge. Eine Fortsetzung der Anzeige ist durch drücken der Return-Taste möglich. Format: mlo [adr1] : Ohne Parameter = Listen ab letzter Adresse adr1 = Long-Adresse Beisp.: mlo a00000 = Listen 4 Bytes ab Adresse a00000 MM => Modifizieren Memory --------------------------- Mit diesem Befehl werden Daten im Memory modifiziert. Die Länge der der Modifikation wird durch die Anzahl Modify-Bytes bestimmt. Die Modify-Bytes können in einer Kombination von Text, Hex, Dez usw. eingegeben werden. Format: mm adr bytes : adr = Modify-Adresse bytes = Modify-Bytes Beisp.: mm 40500 $0001 = Die Adresse $40500 bekommt den Wert $0001 mm tx1 'Hallo' $00 = Die Label-Adresse 'tx1' wird mit dem Text 'Hallo' und einem Null-Byte gefüllt. MO => Überlagern (Occupy) Memory ---------------------------------- Mit diesem Befehl wird ein Speicher-Bereich (vorgegeben mit adr1 - adr2) mit einem Zeichen überschrieben. Format: mo adr1 adr2 byte : adr1 = Anfangs-Adresse adr2 = End-Adresse byte = Byte in Hex, Bin, Dez, Oct oder Text Beisp.: mo 300 340 'a' = Der Bereich 300-340 wird mit einem 'a' über- schrieben. MT => Kopieren (Transfer) Memory ---------------------------------- Mit diesem Befehl wird ein Speicher-Bereich (vorgegeben mit adr1 - adr2) in einen anderen (Anfangs-Adresse vorgegeben mit dest) kopiert. Format: mt adr1 adr2 dest : adr1 = Anfangs-Adresse adr2 = End-Adresse dest = Anfangs-Adresse Empfangs-Bereich Beisp.: mt 800 8ff f00 = Es wird der Bereich 800-8ff nach dem Bereich f00-fff kopiert. MWO => Display 2 Bytes Memory in Hex und Ascii ----------------------------------------------- Mit diesem Befehl werden 2 Bytes (Word) in Hex und in Ascii angezeigt. Normalerweise kann der 'm'-Befehl benutzt werden, aber für diesen sind die reservierten Chip-Bereiche gesperrt. Mit diesem Befehl können auch 2 Bytes des gesperrten Bereichs ausgelesen werden. Aber Vorsicht: Das Lesen einiger Bytes des gesperrten Bereichs kann auch zum Rechner-Absturz führen (siehe 'm'-Befehl). Die Befehle 'mby' (Byte) und 'mlo' (Long) haben die gleiche Funktion mit einer anderen Daten-Länge. Eine Fortsetzung der Anzeige ist durch drücken der Return-Taste möglich. Format: mwo [adr1] : Ohne Parameter = Listen ab letzter Adresse adr1 = Word-Adresse Beisp.: mwo a00000 = Listen 2 Bytes ab Adresse a00000 ============================================================================= Allgemeine Befehle ============================================================================= A => Assemble ---------------- Mit diesem Befehl werden Motorola-Commands in binär umgewandelt. Es gibt zur Zeit noch einige Einschränkungen: Es werden nur die 68000- Befehle erkannt und auch nur im alten Motorola-Format alt = 4(a0) neu = (4,a0). Dies wird bei späteren Versionen behoben. Nach der Eingabe eines Befehls wird dieser mit Hilfe des eingebauten Disassemblers sofort wieder formatiert ausgegeben und in der Folge- Zeile die Adresse für den nächsten Befehl angezeigt. In dieser kann dann der nächste Befehl eingegeben werden. Durch nur drücken der Return-Taste wird der Asm-Eingabe-Modus abgeschlossen. Format: a adr [cmd] : adr = Adresse für den Befehl cmd = Motorola-Befehl Beisp.: a 8888 move d2,4(a3,d2.w) CD => Ändern aktuellen Pfad für UDebug --------------------------------------- Diese Befehl entspricht dem DOS-Befehl 'CD'. Er ist sinnvoll, wenn z.B. Test-Programme aus einer Directory geladen werden sollen und nicht immer der volle Pfad-Name eingetippt werden soll. Format: cd path : path = DOS-Pfad Beisp.: cd c: : UDebug sucht in der C: Directory CLI => Eröffne ein CLI-Window ----------------------------- Mit diesem Befehl wird ein CLI-Window eröffnet. Der Befehl dazu kann mit dem 'set cli'-Befehl verändert werden. Format: cli : ohne Parameter CLS => Lösche Inhalt des UDebug-Windows --------------------------------------- Mit diesem Befehl wird der Inhalt des UDebug-Windows gelöscht. Format: cls : ohne Parameter D => Disassemble Binär-Daten ------------------------------ Mit diesem Befehl werden Binär-Daten in Motorola-Syntax umgewandelt. Normalerweise werden soviel Zeilen gelistet, wie durch den 'nl'-Befehl vorgegeben (default=10), aber wenn nach der Adresse das Zeichen für eine Zeile (default='.'=Punkt) folgt, wird nur eine Zeile angezeigt. Eine Fortsetzung der Anzeige ist durch drücken der Return-Taste möglich. Die für die Amiga-Chips reservierten Ram-Bereiche sind für diesen Befehl gesperrt (siehe 'm'-Befehl) Format: d [adr1] [adr2] : Ohne Parameter = Disass ab letzter Adresse adr1 = Anfangs-Adresse adr2 = End-Adresse Beisp.: d 6766 = Disass 10 Zeilen ab Adresse 6766 d 6766. = Disass 1 Zeile ab Adresse 6766 d feld1. = Disass 1 Zeile ab Label-Adresse feld1 d = Disass 10 Zeilen ab letzter Adresse d . = Disass 1 Zeile ab letzter Adresse d feld1 feld4 = Disass von Adresse 'feld1' bis Adresse 'feld4' DEL => Löschen (Delete) Datei ----------------------------- Mit diesem Befehl wird eine Datei (name) gelöscht. Er entspricht dem DOS-Befehl 'DELETE'. Format: del name : name = Pfad und Name der Datei Beisp.: del test:prog = Es wird die Datei 'prog' in der Directory 'test' gelöscht. DIR => Listen Directory ----------------------- Mit diesem Befehl wird eine Directory gelistet. Er entspricht dem DOS-Befehl 'DIR'. Format: dir [path] : Ohne Parameter = es wird die aktuelle Directory gelistet path = Name einer Directory Beisp.: dir test: = Es wird die 'test:'-Directory gelistet F => Finde Zeichenfolge im Speicher ------------------------------------- Mit diesem Befehl werden vorgegebene Zeichenfolgen im Speicher gesucht und wenn gefunden, angelistet. Die Länge für die Such-Zeichen wird durch die Anzahl Such-Bytes bestimmt. Die Such-Bytes können in einer Kombination von Text, Hex, Dez usw. eingegeben werden. Da ab WB 2.0 beim Text-Suchen auch sehr häufig die Ausgabe-Daten von UDebug selbst gefunden werden, wird erst gesucht und bis zu 100 Find- Adressen gemerkt, und erst nach Abschluß des Suchens diese Adressen angelistet. Die für die Amiga-Chips reservierten Ram-Bereiche werden beim 'f'-Befehl umgangen. Format: f adr1 adr2 bytes : adr1 = Anfangs-Such-Adresse adr1 = End-Adresse bytes = Such-Bytes Beisp.: f 0 200000 'Hallo; $00 = es wird von der Adresse 0 bis $200000 nach dem Text 'Hallo' mit abschließen- den Null-Byte gesucht. N => Einfacher Taschenrechner in Hex, Dez, Oct und Bin -------------------------------------------------------- Mit diesem Befehl werden die Rechenbefehle von links nach rechts ausgeführt und das Ergebnis in Hexadezimal, Dezimal, Octal und Binär dargestellt. Format: n num [+ - * / and or eor num] : num = Numerischer Wert + - * / = Grund-Rechenarten and or eor = Logische Verknüpfungen Beisp.: n $333 = Es wird die Hex-Zahl $333 in Hex, Dez, Oct und Bin umgewandelt. n $10*%10+&12/!2 = Es wird die Rechnung 16*2=32+10=42:2 durch- geführt und das Ergebnis 21 in Hex, Dez, Oct und Bin angezeigt. n $333 or $80 = Logische Verknüpfung : Ergebnis = $3b3 NL => Listen/Verändern Anzahl List-Zeilen ------------------------------------------ Mit diesem Befehl wird die Anzahl List-Zeilen bei den Befehlen 'm' 'mi' 'tr' 'u' 'tt' angelistet bzw. verändert. Format: nl [num] : Ohne Parameter = gesetzte Anzahl listen num = Neue Zeilen-Anzahl Beisp.: nl 5 = Setze Anzahl Zeilen auf 5 P => Verändern Task-Priorität ------------------------------- Mit diesem Befehl werden Task-Prioritäten geändert. Nach Eingabe des Befehls werden alle aktiven Task's nach Priorität sortiert angelistet und danach gefragt, welche Task welche Priorität haben soll. Wird nur die Return-Taste gedrückt, wird keine Priorität verändert. Format: p : Ohne Parameter ============================================================================= Die List-Befehle ============================================================================= Mit der Gruppe der List-Befehle werden Strukturen und Kontroll-Blöcke des Amiga-Betriebs-Systems mit ihren Feldnamen (teilweise gekürzt) angelistet. Es gibt im Programm fest eingebaute Struktur-List-Befehle und zusätzlich die Möglichkeit bis zu 20 selbst definierter Struktur-List-Befehle (Siehe 'lu'- Befehl). Bei verketteten Listen (Amiga-List-Struktur mit Node's) werden die vorhandenen Node's durchnumeriert angezeigt und man kann eine entsprechende Node zum an- zeigen auswählen. Durch drücken der Return-Taste wird die nächste Node (nächste lfd. Nr.) angezeigt. BPCL-Pointer (BPTR) werden in umgewandelter Form (mal 4) angezeigt. Diese umgewandelten Adressen werden mit einem '*' vor der Adresse gekennzeichnet. Falls die angezeigte Struktur mehr als 20 Zeilen hat, stoppt UDebug automatisch. Durch drücken einer Taste wird dann das Anlisten fortgesetzt. Ausnahme: Beim Drücken der Break-Taste (siehe 'set brk') wird das Listen abge- brochen. Die Anzahl Zeilen, bei der das Anlisten angehalten wird,kann mit dem Befehl 'lz' verändert werden. Durch das Multitasking des Amiga's werden dauernd Strukturen und Kontrollblöcke selbst bzw. ihre Verkettung geändert. Da UDebug für die List-Befehle nicht über längere Zeit das Multitasking abschalten will und auch nicht darf, kann es mal passieren, daß die angezeigten Strukturen nicht ganz zueinander passen oder schon ungültig sind. Das ist aber unkritisch. Im schlimmsten Fall kann der List-Befehl wiederholt werden. Bis auf 'lz', 'ln', 'll' und die User definierten Befehle, sind alle anderen ohne Parameter einzugeben. LB => Listet die Node's der Library-List-Struktur in der Exec-Base. LBE => Listet die Struktur der Exec-Base. LBG => Listet die Struktur der Gfx-Base. LBI => Listet die Struktur der Intuition-Base. LD => Listet die Node's der Device-List-Struktur in der Exec-Base. LE => Listet die Node's der Resident-Mem-List's (KickTagPtr) LF => Listet die Node's der Font-List-Struktur in der Gfx-Base. LH => Listen der L.-Befehle (Hilfe-Funktion für L-Befehle) LI => Listet die Node's der Interrupt-Struktur in der Exec-Base. LM => Listet die Node's der Memory-List-Struktur in der Exec-Base. LMF => Listet die freien Speicher-Bereiche (Adresse und Länge) LP => Listet die Node's der Port-List-Struktur in der Exec-Base. LR => Listet die Node's der Resource-List-Struktur in der Exec-Base. LS => Listet die Node's der Semaphore-List-Struktur in der Exec-Base. LT => Listet die Node's der Task-List-Strukturen in der Exec-Base. LW => Listet die Node's der Screen- und Window-Strukturen LZ => Anzeigen oder Verändern Anzahl List-Zeilen ------------------------------------------------- Mit diesem Befehl kann die Anzahl Zeilen, bei denen UDebug bei List- Befehlen anhält, angezeigt oder verändert werden. Default ist 20 Zeilen. Format: lz [num] : ohne Parameter = Nur gesetzte Anzahl anzeigen num = Anzahl Zeilen Beisp.: lz = Nur gesetzte Zeilen-Anzahl anzeigen lz 10 = Ändern Zeilen-Wert auf 16 (Hex=10) lz 80 = Die Unterbrechung erfolgt erst nach 128 Zeilen (d.h. die Anzeige wird nur durch die Leer- bzw. Break-Taste angehalten bzw. abgebrochen) LL => Listet die Node's einer mit Adresse angegebenen List-Struktur. --------------------------------------------------------------------- Mit diesem Befehl kann der Inhalt einer Amiga- oder eigenen List- struktur angelistet. Es wird eine Auswahl-Liste angezeigt, und durch Eingabe der ent- spechenden Nr die Node angelistet. Bei nochmaliges drücken der Return- Taste wird die nächste Node (z.B. nach Nr 6 - Nr 7) angelistet - usw. Normalerweise haben die Nodes des Amiga-Betriebs-System eine Typen-Ken- nung und UDebug erkennt daran, in welcher Form die in der Liste vorhan- denen Nodes anzulisten sind. Doch nicht immer ist die Typen-Kennung vorhanden und UDebug listet dann aus Hilflosigkeit nur vier Zeilen in Hexadezimal an. Um jetzt auch diese Nodes formatiert anzulisten, besteht die Möglichkeit zur Angabe einer Typen-Kennung. Sie kann numerisch oder als 3-stellige Buchstabenfolge angegeben werden. Format: ll adr [typ] : adr = Adresse der List-Struktur typ = Node-Typen-Kennung: = 01 = tas = Task-Struktur = 02 = int = Interrupt-Struktur = 03 = dev = Device-Struktur = 04 = msg = Msg-Port-Struktur = 05 = mes = Message-Struktur = 06 = fre = FreeMsg-Struktur = 07 = rep = Reply-Port-Struktur = 08 = res = Resource-Struktur = 09 = lib = Library-Struktur = 0a = mem = Memory-Struktur = 0b = sof = Soft-Interrupt-Struktur = 0c = fon = Font-Struktur = 0d = pro = Process-Struktur = 0e = sem = Semaphore-Struktur = 0f = sig = Signal-Semaphore-Struktur = 10 = boo = Boot-Node-Struktur = 11 = kic = Kick-Mem-Struktur = 12 = gra = Graphics-Struktur Beisp.: ll 8888 = Anlisten Inhalt einer verketteten Amiga-Liste Die Liste beginnt auf der Adresse 8888 ll 8888 mes = Wie davor, nur alle Nodes ohne Typen-Kennung werden als Messages-Node gelistet. LN => Listen Node ------------------ Listet ein Node der List-Struktur Wird der Befehl ohne Parameter eingegeben, erfolgt eine Fortsetzung des letzten List-Befehls. Normalerweise reicht für die Fortsetzung das Drücken der Return-Taste, aber wenn dazwischen andere Befehle eingegeben wurden, kann so die Folge-Node durch Eingabe des 'ln'-Befehls ohne Adresse angelistet werden. Beim Anlisten von einzelnen Nodes besteht das gleiche Problem der Typen- kennung, wie beim Befehl 'll' beschrieben. Deshalb kann auch wie beim 'll'-Befehl eine Typen-Kennziffer angegeben werden. Zusätzlich zu den unter dem Befehl 'll' beschriebenen Typenkennungen gibt es noch drei weitere Buchstabenfolgen, mit denen man Window- und Screen-Strukturen anlisten kann. Windows und Sreens sind zwar keine Node's, aber ich habe den 'ln'-Befehl auch dafür mißbraucht: wi = Window-Struktur wd = Window-Struktur sc = Screen-Struktur Format: ln [adr] [typ] : Ohne Parameter = Nächste Node listen (Fort- setzung) adr = Listen Node der angegebenen Adresse typ = siehe 'll'-Befehl + wi wd sc Beisp.: ln = Fortsetzung des Node-Anlistung ln 8888 = Listen Node an der Adresse 8888 LU => Lesen User definierte Struktur-List-Befehle -------------------------------------------------- Mit diesem Befehl wird eine editierbare Datei ('name') eingelesen und die darin definierten Struktur-List-Befehle im UDebug installiert. Ist der 1-3-stellige Befehl schon vorhanden, wird der Befehl abgewiesen. Es sei denn, dieser Befehl ist auch ein Struktur-List-Befehl. In diesem Fall wird gefragt, ob der alte Befehl überschrieben werden soll. Die so installierten Befehle werden bei dem 'l'-Befehl (Anzeige der L-Befehle) mit angezeigt. Bei den User definierten Stuktur-List-Befehlen muß immer die Adresse der Struktur mit angeben werden. Wenn der 'lu'-Befehl ohne Datei-Name eingegeben wird und die benötigte Requester-Library ist vorhanden (siehe Installation), wird die Datei über Requester angefordert. Format: lu name : name = Name und Pfad des zu verarbeiteten Datei mit den definierten Struktur- List-Befehlen. Beisp.: lu s:user1 : Lesen die Datei 's:user1' Format der editierbaren Datei mit den Struktur-List-Befehlen ------------------------------------------------------------ Ich hab mich bemüht, diese Definitionen nicht zu kompliziert und leicht merkbar zu machen. Es sind nur wenige Funktionen, aber ich hoffe sie reichen aus. Falls nicht, Verbesserungs-Vorschläge sind willkommen. Jetzt die Regeln: ----------------- Alle Zeilen in der Datei, die in Spalte 1 nicht mit cmd= oder ' (Hoch- komma) beginnen, sind Kommentar-Zeilen. Ein neuer Befehl wird definiert: cmd=ccc,ttttttttt ----------------- ccc = 1-3-stelliger Command-Syntax ttttttttt = 1-23-stelliger Text - Kurzbeschreibung des Befehls, wird beim Befehl 'lh' (Hilfe List-Befehle) mit ange- zeigt Diese Zeile definiert einen neuen Struktur-List-Befehl. Alle nachfol- genden Hochkomma-Zeilen werden diesem Befehl zugeordnet. Die Hochkomma-Zeile: 'fffffffff' kz [ kz's] ---------------------- fffffffff = 0-70-stelliger Text (Kurzbezeichnung des Feldes) Bei 2 direkt hintereinander folgenden Hochkommas wird eine Text-Länge von Null angenommen. Dies ist notwendig, wenn Daten ohne vorangestellten Text angelistet werden sollen. kz = Feld-Typen-Bezeichnung In einer mit Hochkomma beginnenden Zeile können mehrere Hochkomma-Texte mit ihren Kz's stehen. Bei Ende der Daten in der Hochkomma-Zeile wird auch beim Listen eine neue Zeile begonnen. Hier ein Beispiel zum 2-Zeiligen Anzeigen einer Node-Struktur (Erklärung der Kz's erfolgt später): Die Parameter: cmd=lnd,Listen Node 2-zeilig 'Succ ' 4 ' Pred' 4 ' Type' 1 ' Pri' 1 'Name' pt0 Die Anzeige im Window bei Eingabe von 'lnd 20356e' : 0020356E: Succ xxxxxxxx Pred xxxxxxxx Type xx Pri xx 00203578: Name xxxxxxxx=max 32 stellen text Kz = Feldtypen -------------- Zur Zeit gibt es die Feldtypen: #, b, px#, pt#, bx#, bt#, lh, ln, mn und mp Kz = # : Listet das Feld Hexadezimal in der Läenge '#' an. ------ Die nächste Feldadresse = lfd. + # '#' darf nur den Wert von 1-15 haben Beispiel: 'Feld1 ' 3 4 Inhalt Adr. 00300021: 000100 00003000 Anzeige : 00300021: Feld1 000100 00003000 Kz = B : 4 Bytes Bcpl-Adresse - Der Inhalt des Feldes wird mit 4 ------ multipliziert und mit einem Stern '*' gekennzeichnet in Hexadezimal angezeigt. Die nächste Feldadresse = lfd. + 4 Beispiel: 'Bcpl-Feld1 ' b b Adr. 00300020: 00000100 00003000 Anzeige : 00300020: Bcpl-Feld1 *00000400 *0000c000 Kz = PX# : P : 4 Bytes Pointer auf in Hex anzuzeigende Felder. Der -------- Pointer wird hexadezimal angezeigt, dann folgt ein '=' X : Der Inhalt der Adresse, auf die der Pointer zeigt, wird hexadezimal angezeigt. # : Länge der angezeigten Daten (# = 1-15) Die nächste Feldadresse = lfd. + 4 Beispiel: 'Ptr:' px4 Adr 00300020: 00000100 Adr 100: 00043000 Anzeige : 00300020: Ptr: 00000100=00043000 Kz = PT# : P : 4 Bytes Pointer auf als Text anzuzeigende Felder. Der -------- Pointer wird hexadezimal angezeigt, dann folgt ein '=' T : Der Inhalt der Adresse, auf die der Pointer zeigt, wird als Text-String angezeigt. # : Max. Länge der angezeigten Daten (# = 0-14). Bei der Länge Null ist die max. Länge 32. Wird im String ein x'00' gefunden, wird dies als Ende Strings betrachtet Die nächste Feldadresse = lfd. + 4 Beispiel: 'Text ' pt6 Adr 00300030: 00000100 Adr 100: 'Dortmund' Anzeige : 00300030: Text 00000100=Dortmu Kz = BX# : B : 4 Bytes Bcpl-Pointer auf als Hex anzuzeigende Felder. -------- Entspricht 'PXn' nur der Pointer wird mal 4 genommen und mit einem Stern '*' gekennzeichnet. Kz = BT# : B : 4 Bytes Bcpl-Pointer auf als Text anzuzeigende Felder. -------- Entspricht 'PTn' nur der Pointer wird mal 4 genommen und mit einem Stern '*' gekennzeichnet. Kz = LH : 14 Bytes Feld in List-Struktur - Der Inhalt des Feldes wird ------- hexadezimal in einer Zeile angezeigt. Die nächste Feldadresse = lfd. + 14 Beispiel: 'Msg-List: ' ln Adr. 00300040: 00200100 00000000 00300120 0000 Anzeige : 00300040: MsgList: Head 00200100 00000000 Pred 00300120 - Typ 00 00 Kz = LN : 14 Bytes Feld in Node-Struktur - Der Inhalt des Feldes wird ------- hexadezimal in einer Zeile angezeigt. Die nächste Feldadresse = lfd. + 14 Beispiel: 'Msg-' ln Adr. 00200100: 00200180 00300040 00050020 0880 Adr. 00200880: Beispiel-Text Anzeige : 00200100: Msg-Node: Suc+Pre 00200180 00300040 Typ 00 - Pri 05 Name: Beispiel-Text Kz = MN : 20 Bytes Feld in Message-Struktur (MN_) - Der Inhalt des ------- Feldes wird hexadezimal in zwei Zeilen angezeigt. Die nächste Feldadresse = lfd. + 20 Beispiel: 'Msg-' mn Anzeige : 00345000: Msg-Node: Suc+Pre 00203560 0031458C Typ 00 - Pri 00 Name: 0034500E: MsgReplyPort 20186700 Msg-Length 000E Kz = MP : 20 Bytes Feld in Message-Port-Struktur (MN_) - Der Inhalt ------- des Feldes wird hexadezimal in einer Zeile angezeigt. Die nächste Feldadresse = lfd. + 20 Beispiel: '' mp Anzeige : 003104C4: Node: Suc+Pre 00000000 00000000 Typ 00 Pri 00 Name: 003104D2: Flags 00 SigBit 08 SigTask 00310468 003104D8: MsgList: Head 003104DC 00000000 Pred 003104D8 - Typ 00 00 =leer Noch einige Hinweise zum Erstellen der 'LU'-Datei: Bei Benutzung des UDebug-Default-Window passen in eine Zeile zuzüglich der angezeigten Ram-Adresse noch 67 Zeichen. Falls die Ausgabe formatiert sein soll, ist es hilfreich, unter der Hochkomma- Zeile eine Kommentar-Zeile mit der erwarteten Ausgabe einzufügen. Dann kann man durch verkürzen bzw. verlängern der Text-Felder (in Hochkomma) die Ausgabe formatgerecht aufbauen. In dem UDebug-Paket ist eine Datei mit Namen 'UDebug.LuCmd' mit den Beispiel- Befehlen enthalten. Diese Datei kann unverändert, gekürzt oder mit eigenen Strukturen erweitert mit dem 'lu'-Befehl eingelesen werden. Noch mehr ist es zu empfehlen, den 'lu'-Befehl in die Config-Datei einzubauen. ============================================================================= Zum Schluß ============================================================================= UDebug-Fehler ------------- Wenn eine UDebug-Funktion nicht so arbeitet wie beschrieben, teilt in kurzer Form eine genaue Fehler-Beschreibung mit. Wenn der Fehler mir noch unbekannt und von mir auch nicht rekonstruierbar ist, werde ich mich melden. UDebug fängt auch seine eigenen Exeptions ab. Dann erscheint folgende Meldung: #### UDEBUG-ERROR: Error in UDebug-Programm #### Error in x.Segment Displacement $hhhhhh x = Nummer des UDebug-Segments dddddd = Displacement im Segment Mit dem Befehl 'err' können weitere Informationen zu dem Fehler abgerufen werden. Sinnvoll ist es, vorher die Ausgabe von UDebug auf eine Datei umzu- leiten (z.B. '> ram:err'). Dann können sie diese Daten später mir zusenden. Format: err [#] : Ohne Parameter = Kurze Fehler-Informationen (Reichen bei Internal Error) setzung) # = Nummer für ausführlichere Fehler-Informationen Vorschläge zu UDebug -------------------- Zu UDebug gehört auch eine Datei 'UDebug.Vorschlaege'. Mit dieser können interessierte Benutzer Vorschläge für neue UDebug-Funktionen machen. In dieser Datei können die Wünsche eingetragen und dann mir zugeschickt werden. Dies kann mit der Post oder an direkt an meine Netz-Adresse geschehen. Vielzahl UDebug-Befehle ----------------------- UDebug hat eine Vielzahl von Befehlen, die in ihrer Summe vielleicht auch verwirren. Ich hoffe aber, daß Sie trotzdem damit klar kommen. Als Hilfe hab ich die Zusammenfassung der Befehle zum Ausdrucken in eine seperate Datei gestellt (UDebug.Befehle). Noch ein Tip: Da die Zeichenfolge aller Befehle mit 'chg' geändert werden kann, sollte man häufig benutzte Befehle nur mit einem Buch- staben aufrufen oder auf Funktionstasten legen (Faulheit ist der Humus des Geistes) Vorbeugende Selbstkritik ------------------------ Vorab: Ich will mir Mühe geben, mich mit sachlicher Kritik auseinander zu setzen. Aber nur damit !! UDebug bildet für die zu testenden Programme keine eigene Prozeß-Struktur (noch nicht), sondern benutzt zum Testen des Programms seine eigene Prozeß- Struktur. Es ist möglich, das es dadurch bei einigen Programmen zu Schwierigkeiten kommen kann, aber bisher ist mir nur ein Fall bekannt geworden: ReadArg() unter Kick 2.0. UDebug baut aber für diesen Fall die Testumgebung so auf, das auch ReadArg() funktioniert. Falls Sie aber trotzdem Schwierigkeiten haben, teilen Sie es mir bitte mit. Die Zahlen-Eingabe ist variabel, d.h. sie kann in Hexadezimal, Dezimal, Octal und Binär erfolgen. Die Ausgabe erfolgt aber nur in Hexadezimal. Eine variable Ausgabe der Zahlen auch in Dezimal, Oktal usw. bringt leider Probleme im Aus- gabe-Format. Ich habe versucht, die UDebug-Texte in Englisch zu ändern, damit nicht nur deutschsprachige Benutzer mit UDebug umgehen können. Da ich aber kaum Eng- lisch kann, ist mir das wahrscheinlich nicht besonders gut gelungen. Zum Glück hat Kay-Uwe Drangmeister das schlimmste verhindert. Wenn einige Text mißver- ständlich oder falsch sein sollten, meckert nicht nur, sondern schickt mir einen besseren Text. Anschrift und Netz-Adresse -------------------------- Meine Anschrift: Udo Externbrink Vorläuferweg 41 4600 Dortmund 30 Tel. 0231/452821 Netz-Adresse : U_Externbrink@TOSCHIBO.ZER