ASxxxx Assembler V02.21  (Motorola 6809), page 1.
Ascii <--> Integer Conversion Routines


                              1 	.title	Ascii <--> Integer Conversion Routines
                              2 
                              3 	.module	aiconv
                              4 
                              5 	;	Summary of routines
                              6 	;
                              7 	;	a$o$i		Ascii in Octal to integer
                              8 	;	a$d$i		Ascii in Decimal to integer
                              9 	;	a$h$i		Ascii in Hexidecimal to integer
                             10 	;
                             11 	;	Integer Conversions with Leading Zeros
                             12 	;
                             13 	;	i$b$o		Integer byte to Octal Ascii
                             14 	;	i$w$o		Integer word to Octal Ascii
                             15 	;	i$b$d		Integer byte to Decimal Ascii
                             16 	;	i$w$d		Integer word to Decimal Ascii
                             17 	;	i$b$h		Integer byte to Hexidecimal Ascii
                             18 	;	i$w$h		Integer word to Hexidecimal Ascii
                             19 	;
                             20 	;	Integer Conversion with Leading Zeros Suppressed
                             21 	;
                             22 	;	i$b$oz		Integer byte to Octal Ascii
                             23 	;	i$w$oz		Integer word to Octal Ascii
                             24 	;	i$b$dz		Integer byte to Decimal Ascii
                             25 	;	i$w$dz		Integer word to Decimal Ascii
                             26 	;	i$b$hz		Integer byte to Hexidecimal Ascii
                             27 	;	i$w$hz		Integer word to Hexidecimal Ascii
                             28 	;
                             29 	;	All integer to Ascii conversion routines
                             30 	;	terminate the resulting string with 0q200
                             31 	;
                             32 	;	All Ascii to integer conversion routines
                             33 	;	expect the string to be terminated with 0q000 or 0q200
                             34 	;
                             35 	;	The input or output string is pointed to by index register x
                             36 	;	The input or output data is in register d
                             37 	;
                             38 	;
                             39 	;	Variable Requirements
                             40 	;
                             41 	;	i$ndgt::	.blkb	1
                             42 	;	i$dcnt::	.blkb	1
                             43 	;	i$zero::	.blkb	1
                             44 	;	i$data::	.blkb	2
                             45 	;
                             46 	;
                             47 
                             48 	.area	AICONV
                             49 
                             50 
                             51 
ASxxxx Assembler V02.21  (Motorola 6809), page 2.
Ascii <--> Integer Conversion Routines
convert ascii in octal to integer

                             53 	.sbttl	convert ascii in octal to integer
                             54 
   E318                      55 a$o$i::
   E318 34 10                56 	pshs	x
   E31A CC 00 00             57 	ldd	#0		; initialize result
                             58 
   E31D 6D 84                59 1$:	tst	,x		; check for end of string
   E31F 2F 10                60 	ble	2$
   E321 58                   61 	aslb			; *8
   E322 49                   62 	rola
   E323 58                   63 	aslb
   E324 49                   64 	rola
   E325 58                   65 	aslb
   E326 49                   66 	rola
   E327 EB 80                67 	addb	,x+		; add in octal digit
   E329 89 00                68 	adca	#0
   E32B C0 30                69 	subb	#'0
   E32D 82 00                70 	sbca	#0
   E32F 20 EC                71 	bra	1$
                             72 
   E331 35 10                73 2$:	puls	x
   E333 39                   74 	rts
                             75 
ASxxxx Assembler V02.21  (Motorola 6809), page 3.
Ascii <--> Integer Conversion Routines
convert ascii in decimal to integer

                             77 	.sbttl	convert ascii in decimal to integer
                             78 
   E334                      79 a$d$i::
   E334 34 10                80 	pshs	x
   E336 CC 00 00             81 	ldd	#0		; initialize result
                             82 
   E339 6D 84                83 1$:	tst	,x		; check for end of string
   E33B 2F 14                84 	ble	2$
   E33D 58                   85 	aslb			; *2
   E33E 49                   86 	rola
   E33F ED E3                87 	std	,--s
   E341 58                   88 	aslb
   E342 49                   89 	rola
   E343 58                   90 	aslb			; *8
   E344 49                   91 	rola
   E345 E3 E1                92 	addd	,s++		; *8 + *2
   E347 EB 80                93 	addb	,x+		; add in decimal digit
   E349 89 00                94 	adca	#0
   E34B C0 30                95 	subb	#'0
   E34D 82 00                96 	sbca	#0
   E34F 20 E8                97 	bra	1$
                             98 
   E351 35 10                99 2$:	puls	x
   E353 39                  100 	rts
                            101 
                            102 
ASxxxx Assembler V02.21  (Motorola 6809), page 4.
Ascii <--> Integer Conversion Routines
convert ascii in hexidecimal to integer

                            104 	.sbttl	convert ascii in hexidecimal to integer
                            105 
   E354                     106 a$h$i::
   E354 34 10               107 	pshs	x
   E356 CC 00 00            108 	ldd	#0		; initialize result
                            109 
   E359 6D 84               110 1$:	tst	,x		; check for end of string
   E35B 2F 19               111 	ble	3$
   E35D 58                  112 	aslb			; *16
   E35E 49                  113 	rola
   E35F 58                  114 	aslb
   E360 49                  115 	rola
   E361 58                  116 	aslb
   E362 49                  117 	rola
   E363 58                  118 	aslb
   E364 49                  119 	rola
   E365 ED E3               120 	std	,--s
   E367 4F                  121 	clra
   E368 E6 80               122 	ldb	,x+		; add in hexidecimal digit
   E36A C0 41               123 	subb	#'A		; A-F check
   E36C 2B 02               124 	bmi	2$
   E36E C0 07               125 	subb	#0d7		; A-F
   E370 CB 11               126 2$:	addb	#'A-'0		; 0-9
   E372 E3 E1               127 	addd	,s++
   E374 20 E3               128 	bra	1$
                            129 
   E376 35 10               130 3$:	puls	x
   E378 39                  131 	rts
                            132 
                            133 
ASxxxx Assembler V02.21  (Motorola 6809), page 5.
Ascii <--> Integer Conversion Routines
Octal byte to ascii conversion

                            135 	.sbttl	Octal byte to ascii conversion
                            136 
   E379                     137 i$b$o::
   E379 34 10               138 	pshs	x
   E37B 0F 3E               139 	clr	*i$zero
   E37D 0C 3E               140 	inc	*i$zero		; leading zeros enabled
   E37F 20 04               141 	bra	i$b
                            142 
   E381                     143 i$b$oz::
   E381 34 06               144 	pshs	d
   E383 0F 3E               145 	clr	*i$zero		; leading zeros suppressed
                            146 
   E385 1E 89               147 i$b:	exg	a,b		; position data
   E387 DD 3F               148 	std	*i$data		; save data
   E389 C6 03               149 	ldb	#3		; 3 digits
   E38B D7 3C               150 	stb	*i$ndgt
   E38D 0F 3D               151 	clr	*i$dcnt		; initialize result
   E38F DC 3F               152 	ldd	*i$data		; load data
   E391 20 1E               153 	bra	i$ob
                            154 
                            155 
                            156 	.sbttl	Octal word to ascii conversion
                            157 
   E393                     158 i$w$o::
   E393 34 06               159 	pshs	d
   E395 0F 3E               160 	clr	*i$zero
   E397 0C 3E               161 	inc	*i$zero		; leading zeros enabled
   E399 20 04               162 	bra	i$w
                            163 
   E39B                     164 i$w$oz::
   E39B 34 06               165 	pshs	d
   E39D 0F 3E               166 	clr	*i$zero		; leading zeros suppressed
                            167 
   E39F DD 3F               168 i$w:	std	*i$data		; save data
   E3A1 C6 06               169 	ldb	#6		; 6 digits
   E3A3 D7 3C               170 	stb	*i$ndgt
   E3A5 0F 3D               171 	clr	*i$dcnt		; initialize result
   E3A7 DC 3F               172 	ldd	*i$data		; load data
   E3A9 20 0C               173 	bra	i$ow
                            174 
                            175 
ASxxxx Assembler V02.21  (Motorola 6809), page 6.
Ascii <--> Integer Conversion Routines
Octal word to ascii conversion

                            177 
   E3AB 0F 3D               178 i$o:	clr	*i$dcnt		; initialize result
   E3AD DC 3F               179 	ldd	*i$data		; load data
   E3AF 58                  180 	aslb			; rotate 3 bits into position
   E3B0 49                  181 	rola
   E3B1 09 3D               182 i$ob:	rol	*i$dcnt
   E3B3 58                  183 	aslb
   E3B4 49                  184 	rola
   E3B5 09 3D               185 	rol	*i$dcnt
   E3B7 58                  186 i$ow:	aslb
   E3B8 49                  187 	rola
   E3B9 09 3D               188 	rol	*i$dcnt
   E3BB DD 3F               189 	std	*i$data		; save data
   E3BD D6 3D               190 	ldb	*i$dcnt		; get bits
   E3BF CB 30               191 	addb	#'0		; convert to ascii
   E3C1 0A 3C               192 1$:	dec	*i$ndgt		; last digit ?
   E3C3 27 08               193 	beq	2$		; yes - skip tests
   E3C5 0D 3E               194 	tst	*i$zero		; leading zeros ?
   E3C7 26 04               195 	bne	2$		; yes - skip
   E3C9 C1 30               196 	cmpb	#'0
   E3CB 27 04               197 	beq	3$
   E3CD E7 80               198 2$:	stb	,x+		; place character
   E3CF 0C 3E               199 	inc	*i$zero		; enable zeros
   E3D1 0D 3C               200 3$:	tst	*i$ndgt		; any more ?
   E3D3 26 D6               201 	bne	i$o
   E3D5 C6 80               202 	ldb	#0q200		; terminator
   E3D7 E7 84               203 	stb	,x
   E3D9 35 06               204 	puls	d
   E3DB 39                  205 	rts
                            206 
                            207 
ASxxxx Assembler V02.21  (Motorola 6809), page 7.
Ascii <--> Integer Conversion Routines
Decimal byte to ascii conversion

                            209 	.sbttl	Decimal byte to ascii conversion
                            210 
   E3DC                     211 i$b$d::
   E3DC 34 26               212 	pshs	d,y
   E3DE 4F                  213 	clra
   E3DF DD 3F               214 	std	*i$data		; save date
   E3E1 C6 02               215 	ldb	#3-1		; 3 characters for bytes
   E3E3 D7 3C               216 	stb	*i$ndgt
   E3E5 D7 3E               217 	stb	*i$zero		; leading zeros enabled
   E3E7 10 8E E4 52         218 	ldy	#i$dt+4
   E3EB 20 2F               219 	bra	i$d
                            220 
   E3ED                     221 i$b$dz::
   E3ED 34 26               222 	pshs	d,y
   E3EF 4F                  223 	clra
   E3F0 DD 3F               224 	std	*i$data		; save date
   E3F2 C6 02               225 	ldb	#3-1		; 3 characters for bytes
   E3F4 D7 3C               226 	stb	*i$ndgt
   E3F6 0F 3E               227 	clr	*i$zero		; leading zeros suppressed
   E3F8 10 8E E4 52         228 	ldy	#i$dt+4
   E3FC 20 1E               229 	bra	i$d
                            230 
                            231 
                            232 	.sbttl	Decimal Word to ascii conversion
                            233 
   E3FE                     234 i$w$d::
   E3FE 34 26               235 	pshs	d,y
   E400 DD 3F               236 	std	*i$data		; save date
   E402 C6 04               237 	ldb	#5-1		; 5 characters for words
   E404 D7 3C               238 	stb	*i$ndgt
   E406 D7 3E               239 	stb	*i$zero		; leading zeros enabled
   E408 10 8E E4 4E         240 	ldy	#i$dt
   E40C 20 0E               241 	bra	i$d
                            242 
   E40E                     243 i$w$dz::
   E40E 34 26               244 	pshs	d,y
   E410 DD 3F               245 	std	*i$data		; save date
   E412 C6 04               246 	ldb	#5-1		; 5 characters for words
   E414 D7 3C               247 	stb	*i$ndgt
   E416 0F 3E               248 	clr	*i$zero		; leading zeros suppressed
   E418 10 8E E4 4E         249 	ldy	#i$dt
                            250 
                            251 
ASxxxx Assembler V02.21  (Motorola 6809), page 8.
Ascii <--> Integer Conversion Routines
Decimal Word to ascii conversion

                            253 
   E41C DC 3F               254 i$d:	ldd	*i$data		; get data
   E41E 0F 3D               255 	clr	*i$dcnt		; initialize counter
                            256 
   E420 10 A3 A1            257 1$:	cmpd	,y++		; trial
   E423 25 06               258 	blo	2$		; ok - skip
   E425 A3 A3               259 	subd	,--y
   E427 0C 3D               260 	inc	*i$dcnt		; one more count
   E429 20 F5               261 	bra	1$
                            262 
   E42B DD 3F               263 2$:	std	*i$data
   E42D D6 3D               264 	ldb	*i$dcnt		; convert count to ascii character
   E42F CB 30               265 	addb	#'0
   E431 0D 3E               266 	tst	*i$zero		; leading zeros ?
   E433 26 04               267 	bne	3$		; yes - skip
   E435 C1 30               268 	cmpb	#'0
   E437 27 04               269 	beq	4$
   E439 E7 80               270 3$:	stb	,x+		; place character
   E43B 0C 3E               271 	inc	*i$zero		; enable zeros
   E43D 0A 3C               272 4$:	dec	*i$ndgt		; any more ?
   E43F 2E DB               273 	bgt	i$d		; yes - loop
   E441 D6 40               274 	ldb	*i$data+1	; last digit
   E443 CB 30               275 	addb	#'0
   E445 E7 80               276 	stb	,x+
   E447 C6 80               277 	ldb	#0q200
   E449 E7 84               278 	stb	,x		; terminator
                            279 
   E44B 35 26               280 	puls	d,y
   E44D 39                  281 	rts
                            282 
                            283 
   E44E 27 10               284 i$dt:	.word	0d10000		; conversion table
   E450 03 E8               285 	.word	0d1000
   E452 00 64               286 	.word	0d100
   E454 00 0A               287 	.word	0d10
                            288 
                            289 
ASxxxx Assembler V02.21  (Motorola 6809), page 9.
Ascii <--> Integer Conversion Routines
Hex byte to ascii conversion

                            291 	.sbttl	Hex byte to ascii conversion
                            292 
   E456                     293 i$b$h::
   E456 34 06               294 	pshs	d
   E458 1E 89               295 	exg	a,b
   E45A DD 3F               296 	std	*i$data		; save data
   E45C C6 02               297 	ldb	#2		; 2 digits
   E45E D7 3C               298 	stb	*i$ndgt
   E460 D7 3E               299 	stb	*i$zero		; leading zeros enabled
   E462 20 24               300 	bra	i$h
                            301 
   E464                     302 i$b$hz::
   E464 34 06               303 	pshs	d
   E466 1E 89               304 	exg	a,b
   E468 DD 3F               305 	std	*i$data		; save data
   E46A C6 02               306 	ldb	#2		; 2 digits
   E46C D7 3C               307 	stb	*i$ndgt
   E46E 0F 3E               308 	clr	*i$zero		; leading zeros suppressed
   E470 20 16               309 	bra	i$h
                            310 
                            311 
                            312 	.sbttl	Hex word to ascii conversion
                            313 
   E472                     314 i$w$h::
   E472 34 06               315 	pshs	d
   E474 DD 3F               316 	std	*i$data		; save data
   E476 C6 04               317 	ldb	#4		; 4 digits
   E478 D7 3C               318 	stb	*i$ndgt
   E47A D7 3E               319 	stb	*i$zero		; leading zeros enabled
   E47C 20 0A               320 	bra	i$h
                            321 
   E47E                     322 i$w$hz::
   E47E 34 06               323 	pshs	d
   E480 DD 3F               324 	std	*i$data		; save data
   E482 C6 04               325 	ldb	#4		; 4 digits
   E484 D7 3C               326 	stb	*i$ndgt
   E486 0F 3E               327 	clr	*i$zero		; leading zeros suppressed
                            328 
                            329 
ASxxxx Assembler V02.21  (Motorola 6809), page 10.
Ascii <--> Integer Conversion Routines
Hex word to ascii conversion

                            331 
   E488 0F 3D               332 i$h:	clr	*i$dcnt		; initialize result
   E48A DC 3F               333 	ldd	*i$data		; get data
   E48C 58                  334 	aslb			; rotate 4 bits into position
   E48D 49                  335 	rola
   E48E 09 3D               336 	rol	*i$dcnt
   E490 58                  337 	aslb
   E491 49                  338 	rola
   E492 09 3D               339 	rol	*i$dcnt
   E494 58                  340 	aslb
   E495 49                  341 	rola
   E496 09 3D               342 	rol	*i$dcnt
   E498 58                  343 	aslb
   E499 49                  344 	rola
   E49A 09 3D               345 	rol	*i$dcnt
   E49C DD 3F               346 	std	*i$data		; save data
   E49E D6 3D               347 	ldb	*i$dcnt		; get bits
   E4A0 CB 30               348 	addb	#'0		; convert to ascii
   E4A2 C1 39               349 	cmpb	#'9
   E4A4 23 02               350 	blos	1$
   E4A6 CB 07               351 	addb	#0d7
   E4A8 0A 3C               352 1$:	dec	*i$ndgt		; last digit ?
   E4AA 27 08               353 	beq	2$		; yes - skip tests
   E4AC 0D 3E               354 	tst	*i$zero		; leading zeros ?
   E4AE 26 04               355 	bne	2$		; yes - skip
   E4B0 C1 30               356 	cmpb	#'0
   E4B2 27 04               357 	beq	3$
   E4B4 E7 80               358 2$:	stb	,x+		; place character
   E4B6 0C 3E               359 	inc	*i$zero		; enable zeros
   E4B8 0D 3C               360 3$:	tst	*i$ndgt		; any more ?
   E4BA 26 CC               361 	bne	i$h
   E4BC C6 80               362 	ldb	#0q200		; terminator
   E4BE E7 84               363 	stb	,x
   E4C0 35 06               364 	puls	d
   E4C2 39                  365 	rts
                            366 
                            367 
