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

				sernr TLS_B0001	; 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
				seterr 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				Variable anlegen, Wert 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
HLP			set	1 << 2		; HLP = 4 ( 1, 2x Shift links )
				*= * + HLP			; PC + 4
HLP			set	8 >> 1		; HLP = 4 ( 8, 1x Shift rechts )
				*= * + HLP			; PC + 4
				*= * + !$fffe		; PC + 1 ( Komplement = 1 )
HLP			set	5 ~ 2			; HLP = 1 ( Rest von 5/2, modulo )
				*= * + HLP			; PC + 1
				*= * + <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


				; -----------------------------------------------
				; Zuweisung von Werten an Symbole mit auto Offset
				; -----------------------------------------------
				org	$100	; Startadresse für .do festlegen
Dolab_100	sdo	1		; eine Variable mit dem Wert $100 wird angelegt
Dolab_101	edo	$10	; eine Konstante mit dem Wert $101 wird angelegt

Dolab_111	edo	%1		; der Wert $111 wird der Konstanten zugewiesen
Dolab_offs	sdo	0		; aktuellen Offset ermitteln ($112)


				org	$100	; Startadresse für .lo festlegen
Lolab_ff		slo	1		; der Wert $ff wird dem Symbol zugewiesen
Lolab_ef		slo	$10	; der Wert $ef wird dem Symbol zugewiesen

Lolab_ee		elo	%1		; der Wert $ee wird dem Symbol zugewiesen
Lolab_offs	slo	0		; aktuellen Offset ermitteln ($ee)



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
Byte_lab_6	byte		<$100A , 10, $0a, %1010		Tabelle mit 4*10 anlegen

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
				endasm				; Assemblierung beenden




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

						; Das erste Argument einer Source Zeile wird als Label
						; definiert. Befehle und Pseudo-Opcodes müssen daher
						; durch mindestenst ein SPACE oder TAB vom Zeilenanfang
						; getrennt sein.


Label_1				; Die Länge eines Labels wird nur durch die max. Anzahl
						; Character/Zeile (250) bestimmt.
						; Labels müssen mit Buchstaben oder Underline beginnen
						; Die Zeichen a, x, y sind reservierte Buchstaben 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
seterr f				; Fehlermeldungen nur ins Error-File schreiben, nicht
						; auf Screen
seterr 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
sdo					; mit auto Offset, erst zuweisen dann Offset erhöhen
slo					; mit auto Offset, erst Wert vom Offs abziehen dann zuweisen

equ					; unveränderbare Konstante
=						; dito andere Schreibweise
edo					; siehe .sdo
elo					; siehe .slo


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 definiert ist
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

conprt				; String auf die Console ausgeben
						; als Sonderzeichen können :
						; \n für New Line
						; \t für Tabulator
						; \" für Anführungszeichen verwendet werden

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
 ~				; Modulo
 !				; Komplement
 <<			; BIT Verschiebung nach links
 >>			; BIT Verschiebung nach rechts
 &				; logische AND-Verknüpfung
 |				; logische OR-Verknüpfung
 ^				; logische Exclusiv-OR-Verknüpfung



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"



allgemeine Informationen:
-------------------------
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 gleichzeitig durch "include" geöffnet werden.

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



		Thomas Lehmann, 18.November 1991