World of A1200

home *** CD-ROM | disk | FTP | other *** search

/ World of A1200 / World_Of_A1200.iso / programs / develop / as65 / docu / as65xx_txt < prev

Wrap

Text File | 1995-02-27 | 41.3 KB | 1,167 lines

Bedienungsanleitung AS65, V2.3d Cross-Assembler für die 6502 Prozessorfamilie lauffähig auf allen AMIGA Modellen (c) 1989-93 Thomas Lehmann Zedernstraße 36 41239 Mönchengladbach Tel.: 02166/340012 Inhaltsverzeichnis Einleitung ...................................................... Installation .................................................... Assembleranweisungen, ein Überblick ............................ Assemblersteuerung .............................................. PSO "pro" ..................................................... PSO "*=" ...................................................... PSO "*!=" ..................................................... PSO "showsym" ................................................. PSO "ascii" ................................................... PSO "liston" .................................................. PSO "listoff" ................................................. PSO "tabsize" ................................................. PSO "error" ................................................... PSO "setout" .................................................. PSO "fspeed" .................................................. PSO "showpc" .................................................. PSO "breakpt" ................................................. PSO "conprt" .................................................. PSO "warnoff" ................................................. PSO "warnon" .................................................. PSO "include" ................................................. PSO "endasm" .................................................. Labels und Symbole ............................................. PSO "block" ................................................... PSO "bend" .................................................... PSO "set" ..................................................... PSO "equ" ..................................................... PSO "=" ....................................................... PSO "org" ..................................................... PSO "edo" ..................................................... PSO "sdo" ..................................................... PSO "elo" ..................................................... PSO "slo" ..................................................... PSO "macroseg" ................................................ PSO "macro" ................................................... PSO "endmac" .................................................. PSO "hidemac" ................................................. PSO "showmac" ................................................. PSO "hidemac" ................................................. PSO "showmac" ................................................. arithmetische Ausdrücke ......................................... Rechenzeichen ................................................... Bedingte Assemblierung ......................................... PSO "if" ...................................................... PSO "ifequ" ................................................... PSO "ifpl" .................................................... PSO "ifmi" .................................................... PSO "ifdef" ................................................... PSO "ifndef" .................................................. PSO "endif" ................................................... Tabellen ...................................................... PSO "byte" .................................................... PSO "dbyte" ................................................... PSO "word" .................................................... PSO "rta" ..................................................... PSO "text" .................................................... PSO "null" .................................................... PSO "shift" ................................................... PSO "time" .................................................... Assemblerschleifen .............................................. PSO "assloop" ................................................. PSO "assend" .................................................. Aufruf des Assemblers ........................................... Assembler Optionen .............................................. Option -w ..................................................... Option -p ..................................................... Option -P ..................................................... Option -f ..................................................... Option -a ..................................................... Option -s ..................................................... Option -S ..................................................... Option -l ..................................................... Option -L ..................................................... Option -e ..................................................... Option -E ..................................................... Option -i ..................................................... Option -I ..................................................... Option -D ..................................................... Option -d ..................................................... Option -o ..................................................... Utilitys ........................................................ ShowOpc ........................................................ MakeDef ........................................................ Convert ........................................................ Einleitung: Dieses Programm ist Public Domain. Die nicht komerzielle Weitergabe wird von mir ausdrücklich unterstützt. Für evt. eintretende Fehler bei der Benutzung dieses Prg.`s übernehme ich keine Haftung. Sollten ggf. irgentwelche Fragen auftauchen stehe ich Euch gerne, zu normalen Zeiten, zur Verfügung. Auf jeden Fall möchte ich Euch viel Spaß bei der Entwicklung eigener 6502 Software wünschen. Der "AS65" Assembler ist ein komfortabler und leistungsfähiger 2 Pass Cross-Assembler für die gesamte 6502 Prozessor-Familie. Er liest Quellangaben die aus 6502 Maschinensprache bestehen, von einem oder mehreren Inputfiles, übersetzt sie in 6502 Maschinencode und schreibt das Resultat in ein anderes File. Optional kann parallel hierzu auch ein, von einem Editor lesbares, ASCII-File erzeugt werden. Eine Zeile des Source-Files kann aus maximal 250 Zeichen bestehen, es können bis zu 30 Files gleichzeitig geöffnet (include) werden. Die Anzahl der bei der Assemblierung eingelesenen Files ist jedoch unbegrenzt. Die Größe des zu Assemblierenden Codes sowie die Anzahl der möglichen Symbole, Labels und Macros ist nur vom verwendetem Speicherplatz abhängig. Der Objekt-Code ist Prozessorbedingt auf 64kB begrenzt, (maximaler Adressierungsbereich der 6502 Familie). Zu beachten ist, daß Label Definitionen grundsätzlich am Anfang einer Zeile beginnen müssen und alle anderen Anweisungen durch mindestens eine Spalte vom Anfang der Zeile getrennt sein müssen. Diese Einschränkung wurde zu Gunsten der Übersetzungs Geschwindigkeit gemacht. Installation In dem folgendem Beispiel wird davon ausgegeangen das der Assembler unter dem Directory "DH0:AS65" installiert werden soll. die folgende Enviroment Variablen für den Assembler muß eingestellt werden: setenv AS65_HOME DH0:AS65/AS65_Home ; Include Directory (Opcodes, defaults) folgende Enviroment Variablen für den Assembler sollten eingestellt werden: setenv AS65_TMP ram: ; TMP-File wird im RAM: erzeugt setenv AS65_OUT ram: ; alle erzeugten Files ins RAM: setenv AS65_INC d/,s/ ; Such Path für Includes Resident DH0:AS65/as65 ; Assembler Resident installieren Assembleranweisungen, ein Überblick Assemblersteuerung: liston Assemblerlisting einschalten listoff Assemblerlisting ausschalten tabsize 5 Tabulatorabstand Ihres Editors, für die korrekte Ausgabe des erzeugten Listings setout "path/dir" alle vom Assembler erzeugten Files im angegeben Directory erzeugen fspeed auf maximale Assembliergeschwindigkeit umschalten showpc $100 Programmcounter nur alle $100 Bytes anzeigen showpc val aktuellen Programmcounter einmal anzeigen breakpt Assemblierung im Pass 2 anhalten breakpt 2 dito, andere Schreibweise breakpt 1 Assemblierung im Pass 1 anhalten breakpt f Assemblierung auch bei "full Speed" anhalten conprt String während Assemblierung auf Console ausgeben warnoff keine Assembler Warnings zeigen warnon Warnings wieder zeigen endasm Assemblierung vorzeitig beenden assloop Beginn einer Assemblerschleife assend Ende einer Assemblerschleife Prozessortypen: pro R65C02 Opcodes der ROCKWELL 65C02 CPU zulassen Files: ascii erzeugt neben dem Object- auch ein ASCII-File error f Fehlermeldungen nur in ein Error-File error fs Fehlermeldg. in ein Error-File und auf Screen anzeigen include path/name weiteres Source-File in die Assemblierung aufnehmen Programmcounter: *= $1000 Programmcounter setzen, hier Hex 1000, Bereich zwischen altem und neuen PC wird mit $FF gefüllt *!= $2000 PC neu setzen, Bereich nicht füllen Tabellen: byte einzelnes Byte aufnehmen dbyte 16 BIT Wert high/low aufnehmen, doppel Byte word 16 BIT Adresse low/high aufnehmen, z.B. Tabellen rta 16 BIT Adresse minus 1 aufnehmen text Textstring aufnehmen null Textstring aufnehmen, Null anhängen shift Textstring aufnehmen, letztes Zeichen geshiftet time aktuelleZeit aufnehmen: Fri Jun 30 01:49:05 1989 time s dito, andere Schreibweise time weekdaye Wochentag, Mon-Sun in englisch time weekdayg Wochentag, Mo-So in deutsch time year Jahr,1989-???? time monthe Monat, Jan-Dez in englisch time monthg Monat, Jan-Dez in deutsch time month Monat als Zahl (01-12) time day Tag, 01-31 time hour Stunden, 01-23 time min Minuten, 00-59 time sec Sekunden, 00-31 Symboltabelle: set Definition einer Variablen equ Definition einer Konstanten = dito, andere Schreibweise block öffnen eines Labelblocks, lokaleLabels bend Labelblock schließen showsym Symboltabelle auf Screen anzeigen showsym f Symboltabelle in ein File schreiben showsym fs Symboltabelle zeigen und in ein File schreiben Macros: macroseg Beginn der Definition eines Macros ohne interne Labels macro dito, mit internen Labels endmacro Ende der Macrodefinition hidemac Macroausgabe beim Assemblerlisting unterdrücken showmac Macrodefinition wieder anzeigen Bedingte Assemblierung: if erfüllt wenn Ergebnis ungleich 0 ifequ erfüllt wenn Ergebnis gleich 0 ifpl erfüllt wenn Ergebnis positiv ifmi erfüllt wenn Ergebnis kleiner 0, negativ ifdef erfüllt wenn Symbol (Variable oder Konstante) definiert ist ifndef Gegenteil von .ifdef endif Ende einer .if Anweisung Assemblersteuerung PSO "pro": Wollen Sie Opcodes in Ihrem Programm verwenden die nicht dem Standart Type "6502" entsprechen, z.B.: "mul" bei der ROCKWELL 65C00/XX-Familie, müßen Sie den Prozessortype mittels dem PSO "pro" definieren. Dadurch haben Sie die Gewißheit nur Befehle der angegebenen CPU verwendet zu haben. Dieses kann Ihnen eine unötige Fehlersuche ersparen, als wenn Sie z.B. einen Befehl verwenden könnten der auf einer anderen CPU durchaus zugelassen ist. Angenommen Sie wollen ein Prg. für einen R65C02 schreiben und auch die Prozessorspezifischen Opcodes verwenden: -> pro R65C02 durch diese Anweisung werden die Opcodes des R65C02 nachgeladen und benutzbar. Das `R` steht hier für ROCKWELL. mögliche Prozessortypen bzw. kompatible: R6500 oder R_STD Standarttype und default-Einstellung R65C00 R6501 R65C01 R6502 R65C02 R65C102 R65C112 R65C10 R6511 PSO "*=": PSO "*!=": Mit diesen beiden PSO`s läßt sich der Programmcounter beeinflussen. Durch "*=" erhält er einen neuen Wert. War der PC vorher schon definiert, so wird der Adressbereich zwischen dem aktuellem PC und dem neuen PC mit $FF gefüllt. *= $2000 ;PC erhält den Wert $2000 asl a ;PC hat den Wert $2001, ($2000+1 Byte "asl a") *= $3000 ;PC wird neu gesetzt, Bereich von $2001 bis $2fff ;wird mit $FF gefüllt Der PSO "*!=" verhält sich genauso wie "*=" mit der Ausnahme daß der Bereich zwischen altem und neuem PC nicht gefüllt wird. Eine Anwendung hierfür wäre z.B. ein 8K Eprom welches in zwei Adressbereichen unterteilt ist ($7000-$7FFF und $F000-$FFFF). PSO "showsym": Bei der Assemblierung weist der Assembler den gefunden Symbolen bzw. Labeln einen bestimmten Wert zu. Um sich nun alle verwendeten Symbole auf dem Bildschirm anzeigen zu lassen dient der PSO -> "showsym". Die Ausgabe kann auch auf ein File umleitet werden, benutzen Sie hierfür den Parameter "f". -> showsym f Der Assembler erzeugt ein File im aktuellem Directory, (wenn die Ausgabe nicht mittels setout umgeleitet worden ist), welches den Namen des Source-Files, jedoch mit der Endung "sym", trägt. Wollen Sie die Ausgabe der Symboltabelle gleichzeitig in ein File und auf den Bildschirm, so benutzen Sie die Parameter "fs". -> showsym fs PSO "ascii": Der Assembler erzeugt neben dem Objektfile, welches binär vorliegt, auch ein von einem Editor lesbares ASCII-File, Endung ".asc" PSO "liston": Der Assembler erzeugt im Pass2 ein Listing welches die Adresse, den assemblierten Code und die dazugehörige Sourcezeile ausgibt. Das Listing wird erst ab der Position erzeugt, an der ".liston" angegeben wurde. Auch hier gelten die Parameter "f" und "fs". Das erzeugte File trägt jedoch die Endung ".lst". -> liston f Assemblerlisting in ein File umleiten. -> liston fs dito, und auf dem Bildschirm anzeigen. PSO "listoff": Das durch "liston" eingeschaltete Assemblerlisting wird durch -> "listoff" wieder ausgeschaltet. So können Sie sich bestimmte Routinen nach der Assemblierung anzeigen lassen. PSO "tabsize": Angenommen Sie haben Ihren Editor auf einen Tabulatorabstand von vier Zeichen eingestellt und erzeugen ein Listing welches auf dem Bildschirm angezeigt werden soll dann wird durch tabsize 4 dem Assembler der aktuelle Tabulatorabstand mitgeteilt. Anstelle von TAB`s wird bis zur nächsten TAB-Position SPACE ausgegeben. Hierdurch wird das Listing immer korrekt erzeugt, unabhängig von dem im CLI eingestelltem Tabulatorabstand. Die default-Einstellung ist TAB 3. PSO "error": In der Standarteinstellung werden alle Fehlermeldungen, die bei der Assemblierung auftreten, auf dem Bildschirm angezeigt. Wollen Sie diese Ausgabe ausschalten, benutzten Sie den PSO "error" ohne Parameter. Der Parameter "f" leitet diese Ausgabe auf ein File mit der Endung ".err" um. Sollen die Fehler ebenfalls auf dem Bildschirm angezeigt werden so ist der Parameter "fs" zu benutzen. -> error fs PSO "setout": Normalerweise werden alle vom Assembler erzeugten Files, (.obj, .asc, .sym, .lst, .err), im aktuellem Directory erzeugt. Angenommen Sie wollen diese Files in der RAM-Disk erzeugen lassen, so teilen Sie dies dem Assembler durch -> setout "RAM:" mit. PSO "fspeed": Der Assembler schaltet auf volle Geschwindigkei um. Es werden keine Ausgabe- files erzeugt. Die Ausgabe der Symboltabelle und des Assemblerlisting werden unterdrückt. Der Programmcounter wird während der Assemblierung nicht mehr angezeigt. Dieser PSO dient der schnellstmöglichen Assemblierung Ihres Source-Codes. PSO "showpc": In der Grundeinstellung wird die Adresse an der sich der Assembler befindet, (aktueller Programmcounter), Byte für Byte ausgegeben. Diese Ausgabe verschlingt jedoch unötige Zeit, die besser dem eigentlichem Assembliervorgang zur Verfügung gestellt werden sollte. Bei längeren Programmen reicht es durchaus wenn der PC nur jedes 256`te Byte angezeigt wird, dies erreicht man durch: -> showpc 256 (Hex $100) oder -> showpc $100 Um die Anzeige des PC`s vollständig auszuschalten geben Sie den Parameter "off" an. -> showpc off Haben Sie den PC durch "showpc off" oder "fspeed" ausgeschaltet und wollen ihn trotzdem einmal angezeigt bekommen gibt es auch hierfür eine Möglichkeit: -> showpc val wobei val für die Adresse an der der PC ausgegeben werden soll steht. PSO "breakpt": Angenommen Sie wollen sich das Assemblerlisting an einer bestimmten Stelle genauer ansehen so wäre es das einfachste die Ausgabe an dieser Stelle anzuhalten, hierzu dient der PSO "breakpt". -> breakpt Wird kein Parameter angegeben, gilt der Breakpoint erst im Pass2. -> breakpt 1 Die Assemblierung wird nur im Pass1 angehalten. -> breakpt f Die Assemblierung wird auch angehalten wenn "fspeed" angegeben wurde. Eine Kombination der Parameter ist durchaus möglich. PSO "conprt": Mit diesem PSO kann während der Assemblierung eine Ausgabe auf die Console ge- macht werden. Hierdurch kann man z.B. eine Bedingung dokumentieren. if MEMORY-1000 ; ist Memory überschritten ? conprt "Memory overflow" ; Ausgabe auf Console endif PSO "warnoff": Wenn z.B. während der Assemblierung ein Überlauf bei einer Berechnung stattfindet, wird dem User dies durch ein WARNING angezeigt. Der PSO "warnoff" unterdrückt diese Anzeigen. PSO "warnon": Dies ist das Gegenteil von "warnoff", war die Anzeige durch "warnoff" ausgeschaltet, so werden WARNINGS nach "warnon" wieder angezeigt. PSO "include": Ein weiteres Source-File wird mit assembliert. In dem "include"-File könnte ein weiteres File durch "include" mit in die Assemblierung einbezogen werden. Maximal 30 Source-Files können auf diese Art gleichzeitig geöffnet werden. include source_file PSO "endasm": Dieser PSO markiert das Ende der Assemblierung. So können Sie die Assemblierung an jeder beliebigen Stelle im Source beenden. Anwendungen dieses PSO sind besonders in der Testphase eines Prg.`s denkbar. Labels und Symbole Labelnamen müssen mit einem Buchstaben oder Underline "_" beginnen. Alle Befehle und die Zeichen "a,x,y" sind reservierte Wörter/Zeichen und können nicht als Label definiert werden. Es wird zwischen Groß und Kleinschrift unterschieden. Die maximale Länge eines Labelnamens ist nur durch die Anzahl der Zeichen pro Zeile begrenzt. Ein Label muß in der ersten Spalte definiert werden!! PSO "block": PSO "bend": Mit diesen PSO`s steht Ihnen ein starkes Werkzeug zur strukturierten Programmierung zur Verfügung. Alle Labels die zwischen "block" und "bend" vereinbart werden sind auch nur innerhalb dieses Blocks bekannt. Um eine konsequente Nutzung zu ermöglichen, können die Blöcke auch geschachtelt werden. block loop sta $1000,x inx bne loop block loop sta $1000,x ;kein double defined inx bne loop block loop sta $1000,x inx bne loop bend bend bend PSO "set": Mit diesem PSO werden Variablen definiert. Variablen sind im Gegenteil zu Konstanten und automatischen Labels veränderbar, d.h. ihnen kann an jeder beliebigen Stelle im Source ein anderer Wert zugewiesen werden ohne das die Fehlermeldung "double defined" auftritt. -> var_1 set 10 Mit dieser Anweisung erhält das Symbol "var_1" den Wert 10. Der angegebene Wert kann allerdings auch aus einer anderen Variablen oder Konstanten errechnet werden, wie das folgende Beispiel zeigt. var_2 set var_1+$0a+10 Bei dieser Kombination würde dem Label "var_2" der Wert 30, (var_1 == 10+$0a+ 10), zugewiesen werden. PSO "equ": PSO "=": Im Gegensatz zu Variablen sind Konstanten nicht veränderbar. Konstanten werden durch "equ" oder "=" vereinbart. konst equ 10 oder konst = 10 In diesem Beispiel erhält das Symbol "konst" den Wert 10 Variablen und Konstanten müßen vor Ihrem ersten Einsatz definiert werden, ansonsten tritt der Fehler "label not defined" im Pass2 auf. PSO "org": PSO "edo": PSO "sdo": PSO "elo": PSO "slo": Mit diesen Pso`s ist es auf einfache Art und Weise möglich Aufzählungen zu definieren. Mittels "orq" wird eine Startadresse festgelegt. Nach dieser Anweisung können mittels "edo" oder "sdo" Labels vereinbart werden. Die aktuelle Aresse wird je- weils um den angegebenen Wert erhöht. Durch "edo" wird eine Konstante, mit "sdo" eine Variable angelegt, siehe auch "equ" / "set". org 1000 ; Startadresse == 1000 Konst1 edo 1 ; Konst1 erhält den Wert 1000, aktuelle Adr. ist 1000+1 Konst2 edo 9 ; Konst2 erhält den Wert 1001, aktuelle Adr. ist 1001+9 Var1 sdo 10 ; Var1 erhält den Wert 1010, aktuelle Adr. ist 1010+10 Im Gegensatz zu "edo" und "sdo" wird bei "elo" und "slo" die Adresse herunter- gezählt. Ansonsten gelten die gleichen Regeln. org 1000 ; Startadresse == 1000 Konst1 elo 1 ; Konst1 erhält den Wert 1000, aktuelle Adr. ist 1000-1 Konst2 elo 9 ; Konst2 erhält den Wert 999, aktuelle Adr. ist 999-9 Var1 slo 10 ; Var1 erhält den Wert 990, aktuelle Adr. ist 990-10 Macros: PSO "macroseg": PSO "macro": PSO "endmac": PSO "hidemac": PSO "showmac": Häufig wird eine Funktion an verschiedenen Stellen im Programm mehrfach verwendet. Im Normalfall kann man diese Funktion als Unterprogramm definieren und sie dann bei Bedarf mit "jsr xxxx" aufrufen. Dies ist jedoch nicht immer möglich, sei es aus Geschwindigkeitsgründen oder weil sich die Parameterübergabe als zu kompliziert gestaltet. Hier stellt ein komfortabler Asembler dem Benutzer sogenannte Macros zur Verfügung. Ein Macro muß vor der ersten Verwendung definiert werden. Im folgendem Sourcetext kann es dann mehrfach aufgerufen werden. Dabei können beliebig viele Parameter übergeben werden. Definition des Macros "poke": poke macroseg ;Beginn der Definition des Macros "poke" lda #!2 ;Einsetzen des 2.Parameters sta !1 ;dito 1.Parameter endmacro ;Ende der Macrodefinition Aufruf des Macros "poke": ?poke $1000,10 ;Aufruf mit Übergabe von zwei Parametern Das "?" kennzeichnet den Einsatz eines Macros. Trifft der Assembler bei der Assemblierung auf den Befehl ?poke .., so assembliert er genau die Befehle die ihm bei der Definition mitgeteilt wurden. In unserem Beispiel verhält sich der Assembler so, als ob man ihm folgende Befehle gegeben hätte: lda #10 sta $1000 Sowohl "macroseg" als auch "macro" kennzeichnen den Beginn der Macrodefinition. Der Unterschied zwischen den beiden Befehlen zeigt sich erst beim Aufruf eines Macros. Ein mit "macro" definiertes Macro öffnet automatisch einen Labelblock, der bei "endmacro" wieder geschlossen wird. Das ist in dem folgenden Beispiel nötig: inc16 macro ;Macro zum Erhöhen eines 16-Bit Pointers inc !1 ;low-Byte erhöhen bne end ;kein Überlauf, <>0 inc !1+1 ;hi-Byte erhöhen end endmacro ?inc16 pointer bzw. ?inc16 $79 Bei jedem Aufruf von "inc16" muß dem Label "end", das ja intern als Sprungziel verwendet wird, ein Wert zugewiesen werden. Eine Mehrfachdefinition eines Labels ist aber nur dann möglich, wenn es sich die Definitionen in verschiedenen Blöcken befinden. Bisher wurde nur eine Zahl oder einen anderer 16-Bit-Wert an ein Macro übergeben. Es besteht jedoch auch die Möglichkeit einen Textstring zu übergeben, dadurch können Macros noch universeller eingesetzt werden. !!! der Text muß als letzter Parameter eingesetzt werden !!!. Die Syntax der Textparameterübergabe verdeutlicht das folgende Beispiel: error macro ldx #<txt ;low-Byte ldy #>txt ;high-Byte jsr print ;Text ausgeben lda #!1 ;Parameter 1 einsetzen jmp error ;Fehlerbehandlung txt null "!2" ;Textparameter 2 einsetzen, hier "Syntax" endmacro ?error 10,"Syntax" PSO "hidemac": PSO "showmac": Diese beiden PSO`s steuern die Anzeige eines Macros beim Assemblerlisting. Bei jedem Macroaufruf werden Zeilen erzeugt, auch diese Zeilen werden zur Kontrolle ausgegeben. Ist diese Ausgabe für Sie uninteressant, so können Sie sie mit dem PSO "hidemac" verbieten. Die Ausgabe kann mit "showmac" wieder eingeschaltet werden. arithmetische Ausdrücke: Der Assembler kann während der Assemblierung arithmetische Ausdrücke berrechnen. Eine Klammerung ist in dieser Version des Assemblers nicht implementiert!!! lda offs-1,y byte %0101*2,1+2*3 ;ergibt 10, 9 Dabei werden die Ausdrücke von links nach rechts (ohne Berücksichtigung der Punkt-vor-Strich-Regel) ausgewertet. Erlaubte Ausdrücke sind Labels, Zahlen, ASCII-Zeichen und der Programmcounter. Zahlen können in drei Zahlensystemen eingegeben werden: $ff Hexadezimal: gekennzeichnet durch ein vorangestelltes "$" Zeichen. 255 Dezimal %0101 Binär: gekennzeichnet durch ein vorangestelltes "%" Zeichen. Binärzahlen bestehen aus maximal 16 BIT. Sollten nicht alle BIT`s angegeben worden sein, so wird der resultierende Wert von rechts nach links ermittelt. %10 ergibt 2 %00000010 ergibt 2 * Programmcounter: der PC kann in Ausdrücken über das Zeichen "*" verwendet werden. *= $1000 start equ *+4 ;dem Symbol "start" wird der Wert $1004 zugewiesen. word *,*+2 ;PC ablegen *= *+10 ;neuer PC = aktueller PC+10 Rechenzeichen: Die oben beschriebenen Ausdrücke können mit folgenden Rechenzeichen verknüpft werden: "+" Addition "-" Subtraktion "*" Multiplikation "/" Division "&" logische AND-Verknüpfung "|" logische OR-Verknüpfung "^" logische Exclusiv-OR-Verknüpfung "<" Ermittelt das low-Byte des gesamten Ausdrucks. ">" wie "<", nur wird das high-Byte ermittelt. Bedingte Assemblierung: PSO "if": PSO "ifequ": PSO "ifpl": PSO "ifmi": PSO "ifdef": PSO "ifndef": PSO "endif": Diese PSO`s dienen der Assemblierung unter bestimmten Voraussetztungen, bzw. Abruchbedingungen bei Assemblerschleifen. PSO erfüllt nicht erfüllt ------------------------------------------------------------- if <>0 Ergebnis ungleich Null ==0 gleich Null ifequ ==0 " " gleich NULL <>0 ungleich Null ifpl >=0 " " positiv < = negativ ifmi < 0 " " negativ >=0 positiv ifdef wenn Symbol definiert nicht definiert ifndef Symbol nicht " " Symbol definiert Ist die Bedingung erfüllt, wird der folgende Teil normal assembliert. Ist die Bedingung nicht erfüllt, dann wird der folgende Teil des Sourcetextes bis zum nächsten "endif" nicht assembliert, d.h. überlesen. Achtung: Eine Schachtelung der bedingten Assemblierung ist möglich. Tritt also im überlesenen Teil ein "if" auf, so erwartet der Assembler auch zwei "endif", bis er die normale Assemblierung fortsetzt. "ifdef" und "ifndef" testen ob eine Variable oder Konstante bereits definiert wurde. Beispiel: test = 1 *=$1000 if test-1 ;prüft ob "test" <> 1 endasm ;dann Ende endif ;sonst normal assemblieren ..... ;ab hier wird assembl. wenn "test_if" ==1 Tabellen: PSO "byte": PSO "dbyte": PSO "word": PSO "rta": PSO "text": PSO "null": PSO "shift": PSO "time": In jedem größerem Maschinenprogramm werden außer dem eigentlichen Maschinencode auch Tabellen benötigt. Tabellen sind Datenbereiche auf die das Programm während seiner Operationen zurückgreift. Sie können z.B. Texte, Sprungadressen oder voreingestellte Parameter enthalten. Um solche Tabellen möglichst bequem erstellen zu können, dienen die folgenden Assembleranweisungen. PSO "byte": "byte" ist der wichtigste Teil dieser Gruppe. Mit ihm kann theoretisch jede Tabelle erzeugen. Bei der Assemblierung werden die angegebenen Werte Byte für Byte in den Objectcode aufgenommen. label = $1000 byte 5,"a"+1,$aa,>label PSO "dbyte": Im Gegensatz zu "byte" können mit "dbyte" direkt 16 BIT Werte aufgenommen werden. Die Werte werden im high/low Format abgelegt. -> dbyte $1122 oder -> byte $11,$22 PSO "word": dieser PSO dient zum Ablegen von 16-BIT Adressen in Tabellen. Die angegebenen Werte werden im low/high Format ins Maschinenprogramm übernommen. print = $fa21 ;Adresse der Print Routine error = $fbca word print,error oder byte <print,>print,<error,>error ; low/high Byte print Routine, dito error PSO "rta": Häufig werden 16-BIT Tabellen verwendet, um verschiedene Routinen mittels einer Befehlsnummer anzuspringen. Ein beliebter Programmiertrick: Die gewünschte Befehlsadresse wird auf den Stack "gepushed", um dann mit einem "rts" die gewünschte Routine anspringen zu können. dabei müßen Sie aber beachten, daß der Prozessor die Adresse auf dem Stack beim Ausführen von "rts" erhöht. Sie muß deshalb vor dem Ablegen um 1 erniedrigt werden. Diese Aufgabe hat der PSO "rta" (return adress): jmp_rout asl a ;accu enthält Befehlsnummer tax ;Nummer*2 ins x-Register lda tab+1,x ;high Byte der Befehlsadr.-1 pha ;auf Stack, vorgetäuschte Rückkehradresse lda tab,x ;low Byte der Befehlsadr.-1 pha ;auf Stack rts ;Routine anspringen tab rta print,error,exit ;Tabelle der Befehlsadressen oder word print-1,error-1,exit-1 byte <print-1,>print-1,<error-1,>error-1,<exit-1,>exit-1 PSO "text": Häufig benötigt man ASCII-Zeichen im Programm. Sie können mit dem PSO "text" auf einfache Art abgelegt werden. Bei der Assemblierung wird der angegebenen Text Byte für Byte in Hex-Werte umgerechnet, und dann an der aktuellen Adresse abgelegt. Der Textstring muß in Anführungszeichen (") stehen. -> text "1234" oder -> byte 49,50,51,52 Das Anführungszeichen selbst wird durch Voranstellen des Zeichens `\` in einen Textstring aufgenommen. Beispiel: -> text "\"dieser Text steht zwischen 2 Anf.zeichen\"". PSO "null": hat dieselbe Bedeutung wie "text", jedoch wird dem angegebenen Text ein Null-Byte als Endekennzeichnung angehängt. -> null "1234" oder -> text "1234" byte 0 oder byte 49,50,51,52,0 PSO "shift": Bei "null" wird davon ausgegangen, daß Sie ein Null-Byte als Endekennzeichen der Texte verwenden. Eine andere Möglichkeit ist, beim letztem Zeichen der Zeichenkette BIT 7 zu setzen. Das ist natürlich nur sinnvoll, wenn die Codes aller verwendeten Zeichen kleiner als 128 ($80) sind. -> shift "1234" oder byte 49,50,51,52|$80 ;"|" = or, ist das gleiche wie 52+$80 PSO "time": Das aktuelle Datum bzw. die Zeit werden zum Assemblierzeitpunkt ins Object-File aufgenommen. Wird "time" ohne Parameter angegeben wird ein String im folgendem Format erzeugt: Fri Jun 30 18:43:43 1989 -> time oder -> time s Der Parameter "s" erzeugt den selben String. Sie haben jedoch auch die Möglichkeit den Zeitstring nach eigenen Vorstellungen zu erstellen. Dazu übergeben Sie den entsprechenden Parameter beim Einsatz von "time": time weekdaye ;Wochentag, englische Schreibweise (Mon-Sun) time weekdayg ;dito, deutsch (Mo-So) time year ;1989-???? time monthe ;Monat, englisch (Jan-Dez) time monthg ;Monat, deutsch (Jan-Dez) time month ;Monat als Zahl (01-12) time day ;Tag (01-31) time hour ;Stunde (00-23) time min ;Minute (00-59) time sec ;Sekunde (00-59) folgendes Beispiel soll dieses näher erklären: time weekdayg byte " " time day byte "." time monthg byte " " time year angenommen Sie assemblieren am Montag den 28.05.1989, so wird folgender String erzeugt: "Mo 28.Mai 1989" Assemblerschleifen: PSO "assloop": PSO "assend": Manchmal hat man ein Problem zu lösen, dessen Abarbeitung so schnell gehen muß, daß man keine bedingte Maschinenspracheschleife verwenden kann, die über einen Zähler das Ende der Abarbeitung abfragt. Es bleibt einem dann nichts anderes übrig als die benötigten Befehle x-mal ins Maschinenprogramm zu schreiben. Diese Arbeit kann Ihnen der Assembler mit Hilfe der Assemblerschleifen erleichtern. Mit Ihnen ist es möglich, eine bestimmte Routine beliebig oft zu assemblieren. z.B. kopieren eines Speicherbereichs: Die Befehle zwischen "assloop" und "assend" werden 5x ins Object-File geschrieben. *= $2000 counter set 5 ldx #00 sei ;Interrupt abschalten assloop ;Beginn der Assemblerschleife lda $7000,x ;Byte holen sta $8000,x ;und ablegen inx counter set counter-1 ;counter erniedrigen if counter ;counter ungleich Null? assend ;ja, weiter bei .assloop endif ;counter ist Null cli ;Ende der Schleife wenn counter = Null ... ;weitere Befehle Aufruf des Assemblers: Der Assembler startet bei Eingabe der folgenden Befehlszeile: as65 filename [-optionen] Wobei "filename" der Name des Files ist, welches assembliert werden soll, und [-optionen] wahlfreie Parameter spezifizieren. Die Parameter können kombiniert werden. Der Assembler ließt Assembler Quell-Anweisungen der 65`er Prozessorfamilie aus einem Input File, schreibt den übersetzen Object-Code in ein Output File, und erzeugt auf Wunsch ein Listing. Stößt der Assembler während der Assemblierung auf eine Include-Anweisung, fügt er Assembler-Code von anderen Files hinzu. Der Name des Quell-Files, welches dem Assembler beim Aufruf übergeben wird, muß die Endung ".asm" haben. Ist keine Endung, oder eine von ".asm" abweichende angegeben, wird ".asm" vom Assembler angehängt. "Include"-Filenamen sind frei wählbar. Aufruf des Assemblers mit Übergabe des Source-Files: as65 test.asm oder as65 test Der Object-Code, den der Assembler produziert, wird in ein File geschrieben. Der Filename wird vom Input-File abgeleitet. Die Endung ändert sich zu ".obj". Das File wird, wenn nicht anders angegeben, in das aktuelle Directory geschrieben. mögliche Parameter: -w WARNINGS werden unterdrückt -p der Programmcounter wird während der Assemblierung nicht angezeigt -P der PC wird während der Assemblierung angezeigt -f maximale Assembliergeschwindigkeit -a neben dem Object-File erzeugt der Assembler ein ASCII-File -s die Symboltabelle wird auf dem Screen angezeigt -S die Symboltabelle wird in ein File geschrieben -l der Assembler erzeugt ein Listing, dieses wird auf dem Screen angezeigt -L der Assembler erzeugt ein Listing-File -e alle Fehlermeldungen werden in ein File umgeleitet, keine Anzeige auf dem Screen -E dito, die Fehlermeldungen werden jedoch auch auf dem Screen angezeigt -i Pfad für includes -I extra Informationen während der Assemblierung -D Konstante definieren -d`name` Default-Einstellungen nachladen -o`name` Filename für die vom Assembler erzeugten Files Assembler Optionen Option -w: Mit der option -w werden alle WARNINGS unterdrückt. Siehe auch PSO "warnoff". Option -p: Option -P: Normalerweise wird während des Assembliervorgangs der aktuelle Programmcounter, die Adresse an der sich der Assembler befindet, auf dem Screen angezeigt. Mit der Option "-p" schalten Sie diese Anzeige aus. Haben Sie in Ihrem Quell-File den PC durch den PSO "showpc off" ausgeschaltet, können Sie die Anzeige durch die Option "-P" erreichen. siehe auch PSO "showpc". Option -f: Mit dieser Option schaltet der Asembler auf maximale Geschwindigkeit um. Die Anzeige des Programmcounters wird unterdrückt, es wird nur das Object-File erzeugt, das Outputdirectory wird auf "RAM:" gesetzt. siehe auch PSO "fspeed". Option -a: Der Assembler erzeugt neben dem Object-File, welches binär vorliegt, auch ein ASCII-File. Der Name wird vom Quell-File abgeleitet, hat jedoch die Endung "asc". siehe auch PSO "ascii". Option -s: Option -S: Die Symboltabelle wird mit der Option "-s" auf dem Screen ausgegeben. Wollen Sie die Tabelle in ein File schreiben lassen, so benutzen Sie die Option "-S". Das erzeugte File erhält die Endung ".sym". siehe auch PSO "showsym". Option -l: Option -L: Wird die Option "-L" angegeben, erzeugt der Assembler ein Listing File. Der Name des Listing Files wird wieder vom Input-File abgeleitet, jedoch mit der Endung ".lst". Neben der Adresse zeigt das Listing-File die Quellangaben und deren Äquivalent in Maschienensprache an. Mit der Option "-l" leiten Sie diese Ausgabe auf den Screen um, es wird kein Listing-file erzeugt. siehe auch PSO "liston" Option -e: Option -E: Im Normalfall werden die Fehlermeldungen, die bei der Assemblierung auftreten, auf dem Screen angezeigt. Mit der Option "-e" leiten Sie diese Anzeige in ein File um. Das so erzeugte File trägt die Endung ".err". Mit der option "-E" erzeugt der Assembler ebenfalls ein Error-File, die Anzeige auf dem Screen wird jedoch nicht unterdrückt. siehe auch PSO "error". Option -i: Mittels "-i Pfad" wird angegeben in welchen Directorys der Assembler nach include Files (PSO include) suchen soll. Option -I: Während der Assemblierung werden extra Informationen ausgegeben. Option -D: Ein Symbol kann definiert werden. "-D Symbol=10" Die Konstante "Symbol" wird angelegt und erhält den Wert 10. Diese Konstante ist dann im Source benutzbar. Option -d: Mit dem mitgelieferten Utility "makedef" können Sie Default-Files nach eigenen Wünschen erstellen. Alle bisher besprochenen Optionen werden in diesem File abgelegt. Mit der Option "-d" wird nun dieses File nachgeladen, so das sich die Parameterübergabe wesentlich vereinfacht. Wird hinter "-d" kein Filename angegeben, so werden die Einstellungen aus dem File "as65.def" geladen. Der Filename muß in Hochkomma gefasst sein: -d `filename`. Option -o: In der Standarteinstellung werden alle vom Assembler erzeugten Files vom Source-Filenamen, welcher dem Assembler beim Aufruf übergeben wird, abgeleitet. Mit dieser Option können Sie den Assembler veranlassen diese Files von Ihrem angegebenen Namen abzuleiten. Der Filename muß in Hochkomma gefasst sein: `filename`. as65 test.asm -o`my_name` Ein Beispiel soll die bisher besprochenen Optionen näher erläutern: Angenommen Sie wollen ein ASCII-File erzeugen, die Symboltabelle soll auf dem Screen angezeigt und in ein File geschrieben werden, Fehlermeldungen sollen in ein File umgeleitet werden und alle vom Assembler erzeugten Files sollen von "my_name" abgeleitet werden, so gestaltet sich die Parameterübergabe wie folgt: as65 test.asm -asSeo`my_name` Utilitys ShowOpc: Mit dem mitgelieferten Programm ShowOpc können Sie sich die Prozessorspezifischen Befehle und die der Adressierungsart entsprechenden Hex-Werte anzeigen lassen. Wollen Sie sich z.B. über den R65C02 informieren, geben Sie ShowOpc R65C02 ein. Danach erscheint eine Liste der auf dieser CPU benutzbaren Befehle. Geben Sie nur den Programmnamen, ShowOpc, ohne Angabe eines Prozessors, erhalten Sie eine Liste der möglichen Prozessortypen. Durch den Parameter "all" der dem Programmnamen folgt, können Sie sich alle implementierten Prozessortypen der Reihe nach angezeigen lassen. MakeDef: Mit diesem Programm können Sie sich ein auf Ihre Wünsche zugeschnittenes Default-File erstellen. In diesem File werden sämtliche Voreinstellungen abgespeichert. Das so erstellte File wird mit der Option -d'name' vom Assembler geladen, wodurch eine umfangreiche Parameterübergabe nicht mehr notwendig ist. Folgt dem Programmaufruf kein Filename, wird das File "as65.def" benutzt. MakeDef Test Erzeugt ein Default-File im aktuellen Directory mit dem Namen "Test". Dieses Prg. sollte nach Möglichkeit nicht benutzt werden. Es ist nur noch der Vollständigkeit halber dabei !! Convert: Mit diesem Programm wird ein File im MOTOROLA S-RECORD Format erzeugt. Input ist ein maximal 64kB großes binär File. Das so erzeugte ASCII-File kann dann z.B. zu einem Eprommer geschickt werden. convert binär_file