adventofcode2023/02/main.s

%define BUFF_LIM 32768

%define red_lim 12
%define green_lim 13
%define blue_lim 14
%define limits ((red_lim << 16) | (green_lim << 8) | blue_lim)

;             call #  val  val2
; int $0x80   eax     eax  edx  -
;
; arg1  arg2  arg3  arg4  arg5  arg6  arg7  
; ebx   ecx   edx   esi   edi   ebp   -
global _start
[bits 32]
[section .text]
_start:
push 0 ; eof
mov eax, 5 ; open
mov ebx, filename
xor ecx, ecx ; read only
int 0x80
mov ebx, eax
mov eax, 3 ; read
mov ecx, read_buff
mov edx, BUFF_LIM
int 0x80
test eax,eax
js exit
add eax, read_buff
mov [file_lim], eax

mov esi, read_buff
; just try until number lol
.get_id:
call dec_parse
test eax, eax
jz .get_id
; we don't need to save the id
; get another number lol
xor ebx, ebx ; B
xor edi, edi ; G
xor ebp, ebp ; R
.get_num:
call dec_parse
test eax, eax
jz .get_num
mov ecx, eax
; r g b
lodsb
cmp al, 'r'
je .r_chk
cmp al, 'g'
je .g_chk
.b_chk:
cmp ecx, ebx
cmovg ebx, ecx
jmp .next
.g_chk:
cmp ecx, edi
cmovg edi, ecx
jmp .next
.r_chk:
cmp ecx, ebp
cmovg ebp, ecx
.next:
xor edx, edx ; game over flag
; find one of , ; \n
lodsb
cmp al, ','
je .get_num ; next number
cmp al, ';'
je .get_num ; we don't care about rounds
cmp al, 10 ; \n
je .new_game
cmp esi, dword [file_lim] ; end of file
jge .new_game
jmp .next ; other char
.new_game:
mov eax, ebx ; B
mul edi ; G
mul ebp ; R
.game_done:
; add power to final value
add dword [final_value], eax
; checked earlier but... meh
cmp esi, dword [file_lim] ; end of file
jl .get_id ; new game
; we can print final value now
mov eax, [final_value]
call print_dec
jmp exit

exit:
mov eax, 1
int 0x80    ; exit

; string in esi
; modifies EAX ESI
dec_parse:
push ebx
push ecx
push edx
push edi
xor eax, eax
xor ecx, ecx
xor edi, edi
mov ebx, 10
.loop:
lodsb
sub al, '0'
js .dec_done
cmp al, 9
jg .dec_done
xchg edi,eax
mul ebx
add edi,eax
jmp .loop
.dec_done:
mov eax,edi
pop edi
pop edx
pop ecx
pop ebx
ret

; input in EAX, all regs unmodified
print_dec:
pushad ; save regs
; max 4294967296 is 10 chars
; round to nearest 32-bit boundary
sub esp, 12
; string in ECX, length in EDX
lea ecx, [esp+11] ; last possible byte
; check for 0
test eax, eax
jz .zero
mov ebx, 10 ; base 10
xor esi, esi ; counter
.div_shit:
xor edx, edx
; divide
div ebx
dec ecx ; next char
inc esi
; store
add dl, '0'
mov byte [ecx], dl
; check if done
test eax, eax
jnz .div_shit ; continue
mov edx, esi ; counter in edx
jmp .write
.zero:
mov byte [ecx], '0'
mov edx, 1 ; length
.write:
mov eax, 4 ; write
mov ebx, 1 ; stdout
int 0x80
add esp, 12 ; restore stack
popad ; restore regs
ret

[section .data]
file_lim: dd 0
final_value: dd 0
filename: db "input",0

[section .bss]
read_buff: resb BUFF_LIM