cli.z80

include 'string.z80'

ParseLine:
	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	; BC is a pointer to the argc/argv array
	;	(it gets pushed and popped around comparisons)
	; DE is used by StrTok
	; HL is a pointer to the line to parse
	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	; Prepare to read arguments
	; Set argc to 0
	push		hl		; Keep string pointer
	push		bc		; Keep start of argcv struct
	inc		bc		; Skip counter
	ld		a, 0
	push		af		; Keep arg count on stack
ParseLine00:
	call StrTok
	; If string ended in a null, we're done
	cp		"\0"
	jr		z, ParseLine01
	; DE now points to the start of the first arg
	; Load this into (BC) and increment
	ld		a, e
	ld		(bc), a
	inc		bc
	ld		a, d
	ld		(bc), a
	inc		bc
	; Increment argc
	pop		af
	inc		a
	push		af
	; Prepare for next StrTok...
	ex		de, hl
	jr		ParseLine00
ParseLine01:
	pop		af		; Get arg count
	pop		bc		; Set BC back to start of argcv
	ld		(bc), a		; Store argc
	pop		hl		; Get string pointer back
	ret

MapString2Address:
	; In:
	; HL points to a string
	; BC points to table of (string address, arb address) pairs
	; The table MUST be terminated with a pointer to a null str,
	; which acts as a default match
	; This function writes the matching arb address into HL
	ld		a, (bc)
	ld		e, a
	inc		bc
	ld		a, (bc)
	ld		d, a
	inc		bc
	push		bc
	push		hl
	call		StrCmp
	pop		hl
	pop		bc
	jr		z, MapS2A01		; We've matched!
	inc		bc
	inc		bc
	jr		MapString2Address
MapS2A01:
	ld		a, (bc)
	ld		l, a
	inc		bc
	ld		a, (bc)
	ld		h, a
	ret

; Function which interprets the string pointed to by HL
; as a command and calls the appropriate function
Dispatch:
	call		MapString2Address
	jp		(hl)

HandleCommandLine:
	; HL - command string pointer
	; DE - dispatch table pointer
	; BC - argc/argv structure
	call		SkipWhitespace
	call		ConvertToUpper
	push		de
	call		ParseLine
	pop		bc
	call		Dispatch
	ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; UTILITY FUNCTIONS
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ValidateValue:
	call		StrLen
	cp		2
	jr		nz, ValidateValueError
	call		IsStrHex
	jr		nz, ValidateValueError
	cp		a	; Set zero flag
	ret
ValidateValueError:
	call		PrintStringA
	ld		hl, IsNotAValidStr
	call		PrintStringA
	ld		hl, ValueErrorStr
	call		PrintStringA
	or		1	; Reset zero flag
	ret
IsNotAValidStr:
	defm		" is not a valid \0"
ValueErrorStr:
	defm		"value (use 00-FF).\r\n\0"

ValidateAddress:
	call		StrLen
	cp		4
	jr		nz, ValidateAddressError
	call		IsStrHex
	jr		nz, ValidateAddressError
	cp		a	; Set zero flag
	ret
ValidateAddressError:
	call		PrintStringA
	ld		hl, IsNotAValidStr
	call		PrintStringA
	ld		hl, AddressErrorStr
	call		PrintStringA
	or		1	; Reset zero flag
	ret
AddressErrorStr:
	defm		"address (use 0000-FFFF).\r\n\0"

ValidateSector:
	call		StrLen
	cp		8
	jr		nz, ValidateSectorError
	call		IsStrHex
	jr		nz, ValidateSectorError
	cp		a	; Set zero flag
	ret
ValidateSectorError:
	call		PrintStringA
	ld		hl, IsNotAValidStr
	call		PrintStringA
	ld		hl, SectorErrorStr
	call		PrintStringA
	or		1	; Reset zero flag
	ret
SectorErrorStr:
	defm		"sector (use 8 digit hex).\r\n\0"

ValidateFilename:
	push		hl
	; Must be less than 13 chars
	call		StrLen
	cp		13
	jr		nc, ValidateFilenameBad ; filename too long!
	; Must have only one period
	pop		hl
	push		hl
	ld		d, 0
ValidateFilenameCountPeriodLoop:
	ld		a, (hl)
	inc		hl
	cp		"."
	jr		z, ValidateFilenameCountPeriod
	cp		"\0"
	jr		z, ValidateFilenameCountPeriodEnd
	jr		ValidateFilenameCountPeriodLoop
ValidateFilenameCountPeriod:
	inc		d
	jr		ValidateFilenameCountPeriodLoop
ValidateFilenameCountPeriodEnd:
	; d now contains period count
	ld		a, d
	cp		2
	jr		nc, ValidateFilenameBad ; Too many periods!
	; If no periods, no extension, so no need to check ext length
	cp		0
	jr		z, ValidateFilenameAllGood
	; Extension must be 3 chars or less
	; If we're here we *know* there is a period
	pop		hl
	push		hl
	ld		a, "."
	ld		bc, 12
	cpir
	; Now we've advanced to the first char after the period.
	call		StrLen
	cp		4
	jr		nc, ValidateFilenameBad ; Extension too long!
ValidateFilenameAllGood:
	; All good!
	pop		hl	; Get rid of filename pointer
	cp		a	; Set zero flag
	ret
ValidateFilenameBad:
	ld		hl, BadFilenameStr
	call		PrintStringA
	pop		hl	; Get rid of filename pointer
	or		1	; Reset zero flag
	ret
BadFilenameStr:
	defm		"Bad filename (use 8.3)\r\n\0"