.tabsize	3
				; ******************************
				; Test,- und Demofile für AS65xx
				; ******************************
				; Tabulatorabstand 3 Zeichen

				.sernr TLS_A0002	; Seriennummer
				.pro R65C02			; muß nicht angegeben werden, default Einstellung
										; ist ROCKWELL Standart
				.showsym fs			; Symboltabelle in File (f) und auf Screen (s)
				.ascii				; ASCII-File erzeugen
				.showpc 10			; PC-Anzeige nur jedes 10`te Byte
				.warnoff				; keine Warnings ausgeben
				.liston fs			; Assembler-Listing in File (f) und auf Screen(l)
				.setout "RAM:"		; alle Ausgabefiles, .obj, .asc, usw. ins RAM
				.error fs			; Fehlermeldungen ins .err File und auf Screen

poke			.macroseg	; Beginn der Definition des Macros "poke"
				lda #!2		; Einsetzen des 2.Parameters
				sta !1		; dito 1.Parameter
				.endmacro	; Ende der Macrodefinition

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

error			.macro
				ldx #<txt	; low-Byte
				ldy #>txt	; hi-Byte
				jsr print	; Text ausgeben
				lda #!1		; Parameter 1 einsetzen
				jmp error	; Fehlerbehandlung
txt			.null	"!2"	; Textparameter einsetzen, muß letzter Par. sein
				.endmacro




Start_adr	.equ	%1010			; unveränderbare Konstante Wert 10

				*= Start_adr		; PC setzen

		


				; Zeropageadressierung (Prg. soll in der Zeropage laufen)
zp_1			inx
				LDA zp_1				; Label 'zp_1' < 256, bereits bekannt
										; Opcode A5 und 1Byte Adr. von zp_1
				Lda @zp_2			; durch Voranstellen des '@' wird dem Assembler
										; mitgeteilt das es sich um ein Label im
										; Zeropagebereich handelt, Definition von 'zp_2'
										; erst später
										; ohne @ würde Opcode AD und 2Byte Adr. von zp_2
				iny
zp_2			brk


				; -----------
				; branch Test
				; -----------
				.block
loop			bne loop				; d0 fe
				bne loop				; d0 fc
				bne loop_1			; d0 02
				bne loop_1			; d0 00
loop_1

				*= *+126
				bne loop_1			; d0 80	max. Sprungweite $80 (backward)

				bne loop_2			; d0 7f	max. Sprungweite $7f (forward)
				*= *+127
loop_2
				.bend


				; ----------------------------
				; Mnenomic Schreibweise testen
				; ----------------------------
				asl a
				ASL A
				AsL a
				asL A



				; -------------------------
				; aritmethische Operationen
				; -------------------------
pc_add		.set	2

				*= *+1				; PC + dezimal 1
				*= *+2				; PC + dezimal 2
				*= *+3				; PC + dezimal 3
				*= *+4				; PC + dezimal 4
				*= **2				; PC *	2
				*= *+$2				; PC + hex 2
				*= *+%1010			; PC + binär 10
				*= *+pc_add			; PC + pc_add
				*= *+<pc_add		; PC + low-Byte von pc_add (02)
				*= *+>pc_add		; PC + high-Byte von pc_add (00)


				*= $1000				; PC neu setzen,
										; Bereich zwischen altem und neuem PC
										; wird mit $ff gefüllt

				
Label_2000 	.set 	$ffff			; veränderbare Konstante dezimal
Label_ffff	.set	%1111111111111111	; dito binär
Label_FFFF	.set	65535			; dito dezimal
Label_add	.set	*+5			; dito PC+5
Label_add	.set	**5			; dito PC*5

Label									; globales Label definieren
Label_1		Lda	#<Label_2000; dito direkt mit Befehl


				; ------------------
				; Datenbytes ablegen
				; ------------------
norm_txt		.text		"\"Thomas Lehmann\""	; Textstring: "Thomas Lehmann"
null_txt		.null		"Thomas Lehmann"	; Null wird angehängt
shift_txt	.shift	"Thomas Lehmann"	; letztes Zeichen wird geshiftet

Byte_lab_1	.byte		$0a		; hex
Byte_lab_2	.byte		%1010		; binär
Byte_lab_3	.byte		10			; dezimal
Byte_lab_4	.byte		>Label_10; high Byte von Label_10
Byte_lab_5	.byte		<Label_10; low Byte von Label_10

Dbyte_lab_1	.dbyte	$1000		; high/low hex
Dbyte_lab_2	.dbyte	%1111111111111111		; high/low binär
Dbyte_lab_3	.dbyte	1000		; high/low dezimal
Dbyte_lab_4	.dbyte	Label_10	; high/low Label_10

Word_lab_1	.word		$1000		; low/high hex
Word_lab_2	.word		%1111111111111111		; low/high binär
Word_lab_3	.word		1000		; low/high dezimal
Word_lab_4	.word		Label_10	; low/high Label_10

Rta_lab_1	.rta		$1000		; low/high hex, Value-1
Rta_lab_2	.rta		%1111111111111111		; low/high binär, Value-1
Rta_lab_3	.rta		1000		; low/high dezimal, Value-1
Rta_lab_4	.rta		Label_10	; low/high Label_10, Value-1


Lab
Arith_lab	.word		Lab,Lab+10,Lab+$10,%1010



				; ----------------------
				; bedingte Assemblierung
				; ----------------------
test_if		.set	1+4			; Val 5
test_if1		.set	1+test_if*2	; Val 11

				.if test_if			; erfüllt wenn !=0
				.byte 01				; assemblieren

				.ifequ test_if-5	; erfüllt wenn ==0
				.byte 02				; assemblieren
			
				.ifmi test_if-3	; erfüllt wenn < 0		------
				.byte 03				; nicht assemblieren			|
										; 									|
				; nicht assemblieren, da .ifmi nicht erfüllt	|
										; 									|
				.ifpl	test_if		; erfüllt wenn >=0			|
				.byte 04				; assemblieren					|
										;									|
				.endif				; .ifpl							|
				.endif				; .ifmi	<-----------------
				.endif				; .ifequ
				.endif				; .if

setdef		.set 1
equdef		.equ 1

				.ifdef setdef
				lda setdef
				.endif

				.ifdef equdef
				lda equdef
				.endif

				.ifndef equdef
equdef		.equ 5
				.endif



				; -------------
				; File einfügen
				; -------------
				.include "as6502_demo1.inc"

test_if		.set	6				; siehe as6502_demo1.inc

				.include "as6502_demo1.inc"


				*!= $5000			; PC neu setzen,
										; Bereich wird nicht gefüllt


				; ------------------
				; Adressierungsarten
				; ------------------
				lda #$10				; immediate
				lda 200				; zeropage
				lda 200,x			; zeropage,x
				ldx 200,y			; zeropage,y
				lda 1000				; absolute
				lda 1000,x			; absolut,x
				lda 1000,y			; absolut,y

				lda (200,x)			; indirekt,x		nur zeropage
				lda (200),y			; indirekt,y		nur zeropage

				jmp (1000)			; indirekt		2Byte
				jmp (10)				; indirekt		2byte
				jmp 1000				; absolut			2Byte
				jmp 10				; absolut			2Byte
				jsr 1000				; absolut			2byte
				jsr 10				; absolut			2byte



Lowhigh_1
				lda #<Lowhigh_1	; low Byte von Lowhigh_1
				lda #>Lowhigh_1	; high Byte
				lda Lowhigh_1		; high/low byte

				lda #"x"				; einfaches ASCII-Zeichen
				bpl Branch_1		; Sprung
				inx
Branch_1		bne Branch_2

Branch_2		asl


				; -------------
				; lokale Labels
				; -------------
				.block				; lokale Labels, nur zwischen .block und .bend
				ldx #00				; gültig
loop			lda null_txt,x		; letztes Textzeichen '0'
				beq end
				inx
				bne loop
end
				.bend

				.block
				brk
loop			bne loop
				lda norm_txt
				.bend


				; ------
				; Macros
				; ------
				?poke $1000,10		; Aufruf mit Übergabe von zwei Parametern

				?inc16 $79

				?error 10,"Syntax"

print			nop					; Label wird vom Macro error angesprungen
error			nop					; Label wird vom Macro error angesprungen


				; =====================================
				; Assemblerschleife ohne interne Labels
				; =====================================

				sei					; Interrupt abschalten
				ldx #$00

counter		.set	3				; 3 Durchläufe
				.assloop				; Beginn der Assemblerschleife

				; ---------------------------------
				; diese Routine wird 3x assembliert
				; ---------------------------------

				lda #$ff				
				sta $7000,x			; Speicher mit $ff füllen
				inx
counter		.set	counter-1	; counter erniedrigen
				.if	counter		; counter ungleich 0?
				.assend				; ja, weiter bei assloop
				.endif
				cli					; Interrupt wieder freigeben



				; =====================================
				; Assemblerschleife mit internen Labels
				; =====================================

				.breakpt	2			; Assemblierung im Pass2 anhalten
				sei					; Interrupt abschalten
				ldx #$00

count_bl		.set	6				; 6 Durchläufe
				.assloop				; Beginn der Assemblerschleife

				; ---------------------------------
				; diese Routine wird 6x assembliert
				; ---------------------------------

				.block
				lda Byte				
				sta Text,x			; Text überschreiben
				inx
Byte			.byte $01,$02,$03
				.bend

count_bl		.set	count_bl-1	; counter erniedrigen
				.if	count_bl		; counter ungleich 0?
				.assend				; ja, weiter bei assloop
				.endif
				.breakpt	2			; Assemblierung im Pass2 anhalten
				cli					; Interrupt wieder freigeben

Text			.null	"dieses Beispiel ist keine ernsthafte Anwendung"



				; ------------------------
				; aktuelle Zeit einsetzten
				; ------------------------
				.text "assm time: "		; siehe Ojektfile
				.time weekdayg				; Wochentag deutsch
				.byte " "
				.time day					; Tag (01-31)
				.byte "."			
				.time monthg				; Monat deutsch
				.byte " "
				.time year					; Jahr
				.byte 0						; Stringende kennzeichnen



Label_10								; Endadresse+1 merken

				.showpc val			; aktuellen PC zeigen
				.breakpt 1f

				.endasm				; Assemblierung beenden




						; **********************
						; Kurzbeschreibung  AS65
						; ----------------------
						; **********************



Label_1				; Labeldefinition, max. Länge = max. Anzahl Character/Zeile
						; Labels müssen mit Buchstaben oder Underline beginnen
						; alle Befehle und die Zeichen a, x, y sind reservierte
						; Wörter und können nicht als Label definiert werden
						; es wird zwischen Groß,- und Kleinschrift unterschieden
						; Labels müssen vor Eingabe von Befehlen definiert werden

						; Label_1				 			; erlaubt
						; Label_1 	lda $1234,x			; erlaubt
						; lda $1234,x 	Label_1 			; nicht erlaubt

						; die Anzahl der globalen und lokalen Labels und ist nur 
						; vom verfügbaren Speicherplatz abhängig


O p c o d e s:
--------------

.sernr				; Seriennummer eintragen


Files:
------
.include	"name"	; verketten mehrere Sourcefiles
.ascii				; ASCII-File erzeugen
.error f				; Fehlermeldungen nur ins Error-File schreiben, nicht
						; auf Screen
.error fs			; Fehlermeldungen ins Error-File und auf Screen


Prossesortypen:
---------------
.pro					; Prossesortype definieren (ROCKWELL Standart)
.pro R6500			; R6500
						; R65C00
						; R6501
						; R65C01
						; R6502
						; R65C02
						; R65C102
						; R65C112
						; R65C10
						; R6511


Programmcounter:
----------------
*=						; Programmcounter setzen, Bereich zwischen altem und
						; neuem PC wird mit $FF gefüllt
*!=					; PC setzen, Adressraum zwischen altem und neuem PC nicht
						; füllen


Daten:
------
.byte					; Byte-Definition
.dbyte				; 16 Bit Adr. Hi/Lo ablegen (Doppel-Byte)
.word					; 16 Bit Adr. Lo/Hi ablegen
.text					; Textstring ablegen
.null					; dito, Ende mit NULL kennzeichnen (ein Zeichen mehr)
.shift				; wie .text, jedoch letztes Zeichen geschiftet

						; 09.Juli 1989
.rta					; Return Adresse ablegen, 2-Byte Adr.-1
						; Programmiertrick die gewünschte Adresse wird auf den 
						; Stack "gepushed", um dann mit einem "rts" in die ent-
						; sprechende Routine einspringen zu können. Da der Prozessor
						; die Adr. auf dem Stack beim Ausführen von "rts" erhöht.
						; Sie muß deshalb vor dem Ablegen um 1 erniedrigt werden.
						; Diese Aufgabe hat der Pseudo-Opcode ".rta".

Beispiel:
=========
jump		asl a				; accu enthält Befehlsnummer (0-2)
			tax
			lda beftab+1,x	; hi-byte der Befehlsadr.-1
			pha				; auf Stack, vorgetäuschte Rückkehradr.
			lda beftab,x	; low-Byte der Befehlsadr.-1
			pha
			rts				; Sprung zur Rückkehradr.

beftab	.rta	plot,line,exit	; Tabelle der Routinen-1

			.word plot-1,line-1,exit-1		; würde die gleiche Tabelle erzeugen



Konstanten:
-----------
.set					; veränderbare Konstante
.equ					; unveränderbare Konstante
=						; dito andere Schreibweise


lokale Labels:
--------------
.block				; Labelblock: lokale Variablen
.bend					; Labelblock Ende


Symboltabelle:
--------------
.showsym				; Symboltabelle ausgeben
.showsym s			; s = dito, nur bei Angabe mehrerer Optionen notwendig
.showsym f			; f = Symboltabelle in Datei schreiben
.showsym fs			; Symboltabelle in File(f) und auf Screen(s)


Assemblersteuerung:
===================

bedingte Assemblierung:
-----------------------
.if					; erfüllt wenn Ergebnis != 0
.ifequ				;   " "	  "	 "	 "	   == 0
.ifpl					;   " "	  "	 "  "    >= 0 positiv
.ifmi					;   " "	  "	 "  "    <= 0 negativ
.ifdef				; erfüllt wenn Symbol als .set oder .equ definiert
.ifndef				; Gegenteil von .ifdef
.endif				; Ende der .if Anweisung

.endasm				; Assemblierung abbrechen */

.showpc off			; schaltet die Anzeige des Programmcounters beim Assemblieren
						; aus
.showpc val			; zeigt den aktuellen PC einmal
.showpc X			; Anzeige des PC`s nur jedes X'te Byte,
						; 'X' kann als dezimal, hex, binär oder bekannter Labelwert 
						; angegeben werden
						; diese Funktion dient nur der Beschleunigung des Assem-
						; bliervorgangs, da die ständige Ausgabe des PC einige
						; Zeit verschlingt

.warnoff				; keine Anzeige der Warnings
.warnon				; Warnings wieder anzeigen

.assloop				; Beginn der Assemblerschleife
.assend				; Ende der Assemblerschleife
						; Routine zwischen .assloop und .assend wird mehrmals
						; assembliert
						; extrem zeitkritische Probleme, bei denen der benötigte
						; Speicherplatz nur eine untergeordnete Rolle spielt

.tabsize 5			; Tabulatorabstand, Defaulteinstellung ist TAB 3
						; ist nur in Verbindung mit Assemblerlisting von Bedeutung

.liston				; Assemblerlisting bis .listoff oder Fileende ausgeben
.listoff				; kein Assemblerlisting ausgeben

.breakpt				; Assemblierung im Pass2 anhalten
.breakpt	2			; dito
.breakpt	1			; Assemblierung im Pass1 anhalten
.breakpt	12			; Assemblierung im Pass1+2 anhalten
.breakpt	12f		; Assemblierung im Pass1+2 und auch bei "full Speed"
						; Einstellung anhalten

.fspeed				; volle Assembliergeschwindigkeit
						; Funktionen wie .ascii, .showsym usw. werden abgeschaltet
						; das Objekt-File wird im RAM erzeugt

.setout "path"		; alle Ausgabefiles, .obj, .sym, .asc, .lst werden im
						; angegebenen "path" erzeugt
						; wird setout nicht angegeben, so werden die Files in dem
						; Directory in dem das 1.Source-File steht erzeugt


Zeit/Datum zum Assemblierzeitpunkt einsetzen:
---------------------------------------------
.time					; Fri Jun 30 01:49:05 1989
.time s				; dito andere Schreibweise
.time weekdaye		; Wochentag (Mon-Sun) englisch
.time weekdayg		; Wochentag (Mon-Son) deutsch
.time year			; Jahr (1989-????)
.time monthe		; Monat englisch
.time	monthg		; Monat deutsch
.time month			; Monat als Zahl (01-12)
.time day			; Tag (01-31)
.time hour			; Stunden (00-23)
.time min			; Minuten (00-59)
.time sec			; Sekunden (00-59)

Beispiel:
=========
.time weekdayg
.byte " "	
.time day
.byte "."
.time monthg
.byte " "
.time year

würde wenn am 28.Juni assembliert im Objektfile folgenden String ablegen:
Fr 28.Jun 1989


a r i t h m e t i s c h e   O p e r a t i o n e n :
---------------------------------------------------
 +				; Addition
 -				; Subtraktion
 *				; Multiplikation
 /				; Division
 &				; logische AND-Verknüpfung
 |				; logische OR-Verknüpfung
 ^				; logische Exclusiv-OR-Verknüpfung

				; Klammerung noch nicht implementiert



Macros:
-------
.macroseg			; Beginn der Macrodefinition ohne interne Labels
.macro				; Beginn der Macrodefinition mit internen Labels
.endmacro			; Ende der Macrodefinition
.hidemac				; Macrodefinition bei Assemblerlisting nicht zeigen
.showmac				; dito, wieder zeigen

Beispiel:
=========

poke	.macroseg	; Beginn der Definition des Macros "poke"
		lda #!2		; Einsetzen des 2.Parameters
		sta !1		; dito 1.Parameter
		.endmacro	; Ende der Macrodefinition

	?poke $1000,10	; Aufruf mit Übergabe von zwei Parametern

						; trifft der Assembler bei der Assemblierung auf den
						; Befehl ?poke .., so assembliert er genau die Befehle die
						; ihm bei der Definition mitgeteilt wurden
		lda #10
		sta $1000

						; sowohl ".macroseg" als auch ".macro" kennzeichnen den
						; Beginn der Macrodefinition. Der Unterschied zwischen
						; 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 verschie-
						; denen Blöcken befinden.

						; Bisher wurde nur eine Zahl oder einen anderer 16-Bit-Wert
						; an ein Macro übergeben. Es besteht jedoch noch die Möglich-
						; keit einen Textstring zu übergeben, dadurch können Macros
						; noch universeller eingesetzt werden.
						; !!! Text muß als letzter Parameter eingesetzt werden !!!
						; die Syntax der Textparameterübergabe verdeutlicht das
						; folgende Beispiel:

error	.macro
		ldx #<txt	; low-Byte
		ldy #>txt	; hi-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"



folgende Pseudo-Opcodes sind noch nicht implementiert:
------------------------------------------------------
.extern		; Symbol ist extern definiert, in Verbindung mit Linker
.global		; Symbol ist auch extern zu benutzen, dito


allgemeine Informationen:
-------------------------
das Verzeichnis in dem die Opcodes liegen durch 
assign AS65xx: "Verzeichnis/Opcodes" zuweisen.

der Name des Source-File welches beim Assembleraufruf übergeben wird muß die
Endung '.asm' haben.
Filenamen die eingebunden (.include "Name") werden sollen sind frei wählbar.

eine Source-Zeile darf maximal 250 Zeichen enthalten, wobei TAB als ein
Zeichen gilt.

max. 30 Files können geöffnet werden (.include)

es können max. 20 .if Anweisungen gleichzeitig geöffnet sein (Verkettung)



		Thomas Lehmann, 10.August 1989