Added a shift conversion LUT and finished read_line (except Writeback)

LUTs.asm

@@ -0,0 +1,100 @@
+@0x10000: ; Example address until we get a proper memory map for this
+
+; Shift conversion table
+; It stores the mapping from value 32-127 of the ASCII table to their shifted equivalents (both ways) in the standard US keyboard layout
+; e.g. 1 -> !
+U8 32 ; Space -> Space
+U8 49 ; ! -> 1
+U8 39 ; " -> '
+U8 51 ; # -> 3
+U8 52 ; $ -> 4
+U8 53 ; % -> 5
+U8 55 ; & -> 7
+U8 34 ; ' -> "
+U8 57 ; ( -> 9
+U8 48 ; ) -> 0
+U8 56 ; * -> 8
+U8 61 ; + -> =
+U8 60 ; , -> <
+U8 95 ; - -> _
+U8 62 ; . -> >
+U8 63 ; / -> ?
+U8 41 ; 0 -> )
+U8 33 ; 1 -> !
+U8 64 ; 2 -> @
+U8 35 ; 3 -> #
+U8 36 ; 4 -> $
+U8 37 ; 5 -> %
+U8 94 ; 6 -> ^
+U8 38 ; 7 -> &
+U8 42 ; 8 -> *
+U8 40 ; 9 -> (
+U8 59 ; : -> ;
+U8 58 ; ; -> :
+U8 44 ; < -> ,
+U8 43 ; = -> +
+U8 46 ; > -> .
+U8 47 ; ? -> /
+U8 50 ; @ -> 2
+U8 97 ; A -> a
+U8 98 ; B -> b
+U8 99 ; C -> c
+U8 100; D -> d
+U8 101; E -> e
+U8 102; F -> f
+U8 103; G -> g
+U8 104; H -> h
+U8 105; I -> i
+U8 106; J -> j
+U8 107; K -> k
+U8 108; L -> l
+U8 109; M -> m
+U8 110; N -> n
+U8 111; O -> o
+U8 112; P -> p
+U8 113; Q -> q
+U8 114; R -> r
+U8 115; S -> s
+U8 116; T -> t
+U8 117; U -> u
+U8 118; V -> v
+U8 119; W -> w
+U8 120; X -> x
+U8 121; Y -> y
+U8 122; Z -> z
+U8 123; [ -> {
+U8 124; \ -> |
+U8 125; ] -> }
+U8 125; ^ -> 6
+U8 45 ; _ -> -
+U8 126; ` -> ~
+U8 65 ; a -> A
+U8 66 ; b -> B
+U8 67 ; c -> C
+U8 68 ; d -> D
+U8 69 ; e -> E
+U8 70 ; f -> F
+U8 71 ; g -> G
+U8 72 ; h -> H
+U8 73 ; i -> I
+U8 74 ; j -> J
+U8 75 ; k -> K
+U8 76 ; l -> L
+U8 77 ; m -> M
+U8 78 ; n -> N
+U8 79 ; o -> O
+U8 80 ; p -> P
+U8 81 ; q -> Q
+U8 82 ; r -> R
+U8 83 ; s -> S
+U8 84 ; t -> T
+U8 85 ; u -> U
+U8 86 ; v -> V
+U8 87 ; w -> W
+U8 88 ; x -> X
+U8 89 ; y -> Y
+U8 90 ; z -> Z
+U8 91 ; { -> [
+U8 92 ; | -> \
+U8 93 ; } -> ]
+U8 96 ; ~ -> `

console.asm

@@ -4,43 +4,56 @@
 ; r1 - pointer to the buffer
 ; Result:
 ; r1 - pointer to the same buffer
-; Clobbers: r2, r3, r4, r5
+; Clobbers: r2, r3, r4, r5, r6, r7
 pub read_line:
+	mov r6, 1
+	lsl r6, r6, 16
+	sub r6, r6, 32 ; Calculating the address to the shift LUT
+	mov r2, 0 ; Storing the shift status here
 	mov r4, 0 ; Storing the last key here, so we don't repeat the same key
-	mov r5, 0 ; Storing the shift status
 	mov r3, r1 ; The pointer to after the last character
 
 	read_line_keyloop:
-		keyboard r2
+		keyboard r5
 		
-		cmp r2, r4
+		cmp r5, r4
 		je read_line_keyloop ; If the current key is same as previous, we loop
-		mov r4, r2 ; Storing current key as previous
+		mov r4, r5 ; Storing current key as previous
 		
-		cmp r2, 0x120 ; Is the key renderable or special?
+		cmp r5, 0x120 ; Is the key renderable or special?
 		jb read_line_special ; If the key was special, we handle it separately
+		xor r5, r5, 0x100 ; Clearing the "down" bit
 
-		; TODO: Converting based on shift value
-		store_8 [r3], r2 ; Else, we store the key in the buffer
+		cmp r2, zr ; Checking for shift status
+		je read_line_store ; If shift is up, we skip conversion
+
+		;;; converting from shift-down to shift-up keys
+		add r7, r6, r5 ; Calculating the index of the shift conversion
+		load_8 r5, [r7] ; Loading the shifted value
+		;;;
+
+		read_line_store:
+			store_8 [r3], r5 ; Else, we store the key in the buffer
 			add r3, r3, 1 ; We advance forward
+			; TODO: Writeback
 			jmp read_line_keyloop
 
 		read_line_special:
-			cmp r2, 13 ; Was the key Backspace?
+			cmp r5, 13 ; Was the key Backspace?
 			je read_line_backspace ; If yes we need to move one character back
 
-			cmp r2, 10 ; Was the key Enter?
+			cmp r5, 10 ; Was the key Enter?
 			je read_line_finished ; If so, we're finished
 
-			and r2, r2, 0x1FB ; Mask out the left/right shift direction bit
-			cmp r2, 0x110 ; Was the key Shift Down?
+			and r5, r5, 0x1FB ; Mask out the left/right shift direction bit
+			cmp r5, 0x110 ; Was the key Shift Down?
 			and flags, flags, 0x1 ; We care only about equality bit
-			or r5, r5, flags ; If shift was down before, it still is. If it was pressed now, it is down now
+			or r2, r2, flags ; If shift was down before, it still is. If it was pressed now, it is down now
 
-			cmp r2, 0x010 ; Was the key Shift Up?
+			cmp r5, 0x010 ; Was the key Shift Up?
 			and flags, flags, 0x1 ; We care only about equality bit
 			xor flags, flags, 0x1 ; We invert it, i.e. "if it's not up"
-			and r5, r5, flags ; The shift can be kept down if it's not currently up
+			and r2, r2, flags ; The shift can be kept down if it's not currently up
 
 			jmp read_line_keyloop ; If no special handling, we loop back
 
@@ -48,6 +61,7 @@ pub read_line:
 			cmp r3, r1 ; Compare the current pointer to start of buffer
 			je read_line_keyloop ; If we are at the start, we loop
 			sub r3, r3, 1 ; We move back one character
+			; TODO: Writeback
 			jmp read_line_keyloop
 
 	read_line_finished:

stdlib.asm

@@ -1,3 +1,6 @@
 pub include bit
 pub include imath
 pub include console
+
+; Needs to be last!
+pub include LUTs