/*
 *  vmss_decbin.c
 *  lab11
 *
 *
 * 11/15/2010: inline asm rewrite
 */

#include "vmss_decbin.h"
#include <assert.h>


//
void vmss_gettet(INTFIELD *f, int n, bit_tetrad *t) { _asm {
  mov ecx, 4         ; loop counter

it1:
  ; calculate bit position
  xor edx, edx
  mov eax, 4
  sub eax, ecx
  add edx, eax
  mov [ebp-32], eax

  mov eax, dword ptr[n]
  lea eax, [eax*4]
  add edx, eax

  ; assign
  mov eax, dword ptr[f]
  mov eax, dword ptr[eax+4*edx]
  mov edx, dword ptr[t];
  mov ebx, [ebp-32]
  mov dword ptr[edx+4*ebx], eax

  loop it1
}}

/*******************************************************************************************/
int vmss_tet2int(bit_tetrad *t) { __asm {
  mov dword ptr[ebp-8], 0       ; i
  mov dword ptr[ebp-12], 0      ; val
  jmp incr_body

incr:
  mov eax, dword ptr[ebp-8]
  inc eax
  mov dword ptr [ebp-8], eax
  cmp eax, 4
  jge incr_end

incr_body:
  mov eax, 3
  sub eax, dword ptr[ebp-8]
  mov ecx, dword ptr[t]
  mov edx, dword ptr[ecx+eax*4]
  mov ecx, dword ptr[ebp-8]
  shl edx, cl
  or  edx, dword ptr[ebp-12]
  mov dword ptr[ebp-12], edx

  jmp incr

incr_end:
  mov eax, dword ptr[ebp-12]     ; ret value
}}

void vmss_clearbits(INTFIELD *f) { __asm {
    mov ecx, BIT_COUNT-1    ; 32-1
  mov eax, dword ptr[f]

lp:
  mov dword ptr[eax+ecx*4], 0
  loop lp

  mov dword ptr[eax], 0   ; clear first element
}}

/*******************************************************************************************/
void vmss_int2decbin(int val, INTFIELD *f) { __asm {
  mov dword ptr[ebp-4], BIT_COUNT-4
  mov eax, dword ptr[f]
  push eax
  call vmss_clearbits
  pop eax

  ; eax = counter
  mov eax, dword ptr[val]
  mov dword ptr[ebp-8], eax

val_loop:
  mov eax, dword ptr[ebp-8]
  cmp eax, 0
  je end_loop

  mov eax, dword ptr[ebp-4]   ; i <= 4
  cmp eax, 4
  jle end_loop

  mov eax, dword ptr[ebp-8]
  cdq                         ; convert dbl to quad
  mov ecx, 10
  idiv ecx                    ; result in edx
  mov dword ptr[ebp-12], edx  ; save remainder

  ; write bits
  mov ebx, dword ptr[f]
  mov eax, dword ptr[ebp-4]
  lea ebx, [ebx+eax*4]
  ;add ebx, eax

  ; ebx: intfield, eax: digit

  ; f->bits[i].v = digit / 8;
  cdq
  mov eax, dword ptr[ebp-12]
  mov ecx, 8
  idiv ecx
  mov dword ptr[ebx], eax

  ; f->bits[i+1].v = (digit / 4) % 2;
  cdq
  mov eax, dword ptr[ebp-12]
  mov ecx, 4
  idiv ecx
  cdq
  mov ecx, 2
  idiv ecx
  mov dword ptr[ebx+4], edx

  ;f->bits[i+2].v = (digit / 2) % 2;
  cdq
  mov eax, dword ptr[ebp-12]
  mov ecx, 2
  idiv ecx
  cdq
  mov ecx, 2
  idiv ecx
  mov dword ptr[ebx+8], edx

  ;f->bits[i+3].v = digit % 2;
  cdq
  mov eax, dword ptr[ebp-12]
  mov ecx, 2
  idiv ecx
  mov dword ptr[ebx+12], edx

  ; i=i-4
  mov eax, dword ptr[ebp-4]
  sub eax, 4
  mov dword ptr[ebp-4], eax

  ; val / 10
  cdq
  mov eax, dword ptr[ebp-8]
  mov ecx, 10
  idiv ecx
  mov dword ptr[ebp-8], eax

  jmp val_loop

end_loop:

}}

/*******************************************************************************************/
int vmss_decbin2int(INTFIELD *f) { __asm {
  ; initialize local variables
  mov dword ptr[ebp-4], BIT_COUNT/4         ; tets: total tetrads
  mov dword ptr[ebp-64], BIT_COUNT/4 - 1    ; i
  mov dword ptr[ebp-8], 0                   ; k
  mov dword ptr[ebp-12], 0                  ; res

  mov ecx, dword ptr[ebp-64]
tl:

  mov eax, [ebp+8]                          ; dword ptr [f]
  lea edx, [ebp-32]                         ; &bit_tetrad in stack

  mov dword ptr[ebp-64], ecx

  push edx                                  ; &tetr
  push ecx                                  ; i
  push eax                                  ; f
  call vmss_gettet
  pop eax
  pop ecx
  pop edx

  lea edx, [ebp-32]
  push edx
  call vmss_tet2int
  pop edx

  ; eax = val
  mov ebx, 1
  mov edx, dword ptr[ebp-8]
  mov dword ptr[ebp-16], eax

  inc edx

l_pow:
  mov dword ptr[ebp-20], edx
  mov eax, 10
  mul ebx
  mov ebx, eax
  mov edx, dword ptr[ebp-20]

  dec edx
  cmp edx, 0
  jne l_pow

  mov eax, dword ptr[ebp-16]      ; restore eax=val
  mul ebx                         ; eax = [ebx] * [eax]

  ; lost zero fix ?
  mov ebx, 10
  div ebx

  mov ebx, dword ptr[ebp-12]      ; ebx = res
  add eax, ebx                    ; eax = eax + ebx
  mov dword ptr[ebp-12], eax      ; res = eax

  mov eax, dword ptr[ebp-8]       ; eax <- k
  inc eax                         ; eax++
  mov dword ptr[ebp-8], eax       ; k <- eax

  mov ecx, dword ptr[ebp-64]      ; restore i-counter

  loop tl                         ; ecx>0 ?

  mov eax, dword ptr[ebp-12]                ; ret res
}}

/*******************************************************************************************/
void vmss_makefixtet(INTFIELD *src, INTFIELD *fix) { __asm {
  mov dword ptr[ebp-4], 0       ; i
  mov eax, dword ptr[fix]
  push eax
  call vmss_clearbits
  add esp, 4

  jmp loop_body

loop_cond:
  mov eax, dword ptr[ebp-4]
  cmp eax, BIT_COUNT/4
  jne loop_end
  inc eax
  mov dword ptr[ebp-4], eax

loop_body:
  ; vmss_gettet(src, i, &tetr);
  lea ebx, dword ptr[ebp-64]
  push ebx
  mov eax, dword ptr[ebp-4]
  push eax
  mov ecx, dword ptr[src]
  push ecx
  call vmss_gettet
  add esp, 12

  ; if ( vmss_tet2int(&tetr) != 0  )
  lea ebx, dword ptr[ebp-64]
  push ebx
  call vmss_tet2int
  add esp, 4
  cmp eax, 0
  jz ifb_e

  mov eax, dword ptr[ebp-4]
  mov ecx, dword ptr[src]

  lea edx, dword ptr[ecx + 4*eax + 0]
  mov dword ptr[edx], 0
  lea edx, dword ptr[ecx + 4*eax + 4]
  mov dword ptr[edx], 1
  lea edx, dword ptr[ecx + 4*eax + 8]
  mov dword ptr[edx], 1
  lea edx, dword ptr[ecx + 4*eax + 12]
  mov dword ptr[edx], 0

ifb_e:
  jmp loop_cond

loop_end:

}}

/*******************************************************************************************/
void vmss_makefixtet_sub(INTFIELD *src, INTFIELD *fix, int count) { _asm {
  mov eax, dword ptr[count]
  mov ebx, BIT_COUNT/4
  sub eax, ebx
  mov dword ptr[ebp-4], eax       ; i
  mov eax, dword ptr[fix]
  push eax
  call vmss_clearbits
  add esp, 4

  jmp loop_body

loop_cond:
  mov eax, dword ptr[ebp-4]
  cmp eax, BIT_COUNT/4
  jne loop_end
  inc eax
  mov dword ptr[ebp-4], eax

loop_body:
  ; vmss_gettet(src, i, &tetr);
  lea ebx, dword ptr[ebp-64]
  push ebx
  mov eax, dword ptr[ebp-4]
  push eax
  mov ecx, dword ptr[src]
  push ecx
  call vmss_gettet
  add esp, 12

  lea ebx, dword ptr[ebp-64]
  push ebx
  call vmss_tet2int
  add esp, 4
  cmp eax, 0
  jz ifb_e

  mov eax, dword ptr[ebp-4]
  mov ecx, dword ptr[src]

  lea edx, dword ptr[ecx + 4*eax + 0]
  mov dword ptr[edx], 1
  lea edx, dword ptr[ecx + 4*eax + 4]
  mov dword ptr[edx], 0
  lea edx, dword ptr[ecx + 4*eax + 8]
  mov dword ptr[edx], 1
  lea edx, dword ptr[ecx + 4*eax + 12]
  mov dword ptr[edx], 0

ifb_e:
  jmp loop_cond

loop_end:

}}
/*******************************************************************************************/
int vmss_gettet_count(INTFIELD *src) { __asm {
  mov dword ptr [ebp-4], 0        ; i
  mov eax, dword ptr[src]
  mov dword ptr [ebp-8], eax

begin_loop:
  mov eax, dword ptr[ebp-4]
  cmp eax, BIT_COUNT/4
  jge end_loop

  lea ebx, dword ptr[ebp-64]
  push ebx
  push eax
  mov ecx, dword ptr[ebp-8]
  push ecx
  call vmss_gettet
  add esp, 12

  lea ebx, dword ptr[ebp-64];
  push ebx
  call vmss_tet2int
  add esp, 4

  cmp eax, 0
  jnz end_loop

  mov eax, dword ptr[ebp-4]
  inc eax
  mov dword ptr[ebp-4], eax
  jmp begin_loop

end_loop:
  mov ebx, dword ptr[ebp-4]
  mov eax, BIT_COUNT/4
  sub eax, ebx
}}

/*******************************************************************************************/
void vmss_tsum(INTFIELD *b1, INTFIELD *b2, INTFIELD *res, INTFIELD *transfer) { __asm {
  mov dword ptr[ebp-4], 0     ; add
  mov dword ptr[ebp-8], 0     ; i

  mov ecx, BIT_COUNT-1

  mov dword ptr [ebp-8], BIT_COUNT-1
  jmp loop_1
loop_incr:
  mov eax,dword ptr [ebp-8]
  sub eax,1
  mov dword ptr [ebp-8],eax
loop_1:
  cmp dword ptr [ebp-8],0
  jl loop_exit

  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b1]
  cmp dword ptr[ecx+eax*4], 0
  jne if_case_2
  mov ecx, dword ptr[b2]
  cmp dword ptr[ecx+eax*4], 0
  jne if_case_2

;if_case_1:
  ; case_1 body
  mov eax,dword ptr [ebp-8]
  mov ecx,dword ptr [res]
  mov edx,dword ptr [ebp-4]
  mov dword ptr [ecx+eax*4],edx
  mov dword ptr [ebp-4],0

  jmp ex_if
if_case_2:

  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b1]
  cmp dword ptr[ecx+eax*4], 1
  jne m_1

  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b2]
  cmp dword ptr[ecx+eax*4], 0
  je m_2

m_1:
  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b1]
  cmp dword ptr[ecx+eax*4], 0
  jne if_case_3

  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b2]
  cmp dword ptr[ecx+eax*4], 1
  jne if_case_3

m_2:
  ; case_2 body
  xor eax,eax
  cmp dword ptr [ebp-4],0
  sete al
  mov ecx,dword ptr [ebp-8]
  mov edx,dword ptr [res]
  mov  dword ptr [edx+ecx*4],eax
  jmp ex_if

if_case_3:
  ; else if ( b1->bits[i].v == 1 && b2->bits[i].v == 1 )
  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b1]
  cmp dword ptr [ecx+eax*4],1
  jne ex_if
  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b2]
  cmp dword ptr[ecx+eax*4],1
  jne ex_if

  ; case_3 body
  mov eax,dword ptr [ebp-8]
  mov ecx,dword ptr [res]
  mov edx,dword ptr [ebp-4]

  mov dword ptr [ecx+eax*4],edx
  mov dword ptr [ebp-4],1         ; add <- 1

ex_if:
  ; transfer bit
  cmp dword ptr [transfer], 0
  je loop_end
  mov eax,dword ptr [ebp-8]
  mov ecx,dword ptr [transfer]
  mov edx,dword ptr [ebp-4]
  mov dword ptr [ecx+eax*4],edx

loop_end:
  mov ecx, dword ptr[ebp-8]
  jmp loop_incr

loop_exit:
}}

/*******************************************************************************************/
void vmss_sum_notf(INTFIELD *b1, INTFIELD *b2, INTFIELD *res) { __asm {
  mov dword ptr[ebp-4], 0     ; add
  mov dword ptr[ebp-8], 0     ; i

  mov ecx, BIT_COUNT-1

  mov dword ptr [ebp-8], BIT_COUNT-1
  jmp loop_1
loop_incr:
  mov eax,dword ptr [ebp-8]
  sub eax,1
  mov dword ptr [ebp-8],eax
loop_1:
  cmp dword ptr [ebp-8],0
  jl loop_exit

  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b1]
  cmp dword ptr[ecx+eax*4], 0
  jne if_case_2
  mov ecx, dword ptr[b2]
  cmp dword ptr[ecx+eax*4], 0
  jne if_case_2

;if_case_1:
  ; case_1 body
  mov eax,dword ptr [ebp-8]
  mov ecx,dword ptr [res]
  mov edx,dword ptr [ebp-4]
  mov dword ptr [ecx+eax*4],edx
  mov dword ptr [ebp-4],0

  jmp ex_if
if_case_2:

  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b1]
  cmp dword ptr[ecx+eax*4], 1
  jne m_1

  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b2]
  cmp dword ptr[ecx+eax*4], 0
  je m_2

m_1:
  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b1]
  cmp dword ptr[ecx+eax*4], 0
  jne if_case_3

  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b2]
  cmp dword ptr[ecx+eax*4], 1
  jne if_case_3

m_2:
  ; case_2 body
  xor eax,eax
  cmp dword ptr [ebp-4],0
  sete al
  mov ecx,dword ptr [ebp-8]
  mov edx,dword ptr [res]
  mov  dword ptr [edx+ecx*4],eax
  jmp ex_if

if_case_3:
  ; else if ( b1->bits[i].v == 1 && b2->bits[i].v == 1 )
  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b1]
  cmp dword ptr [ecx+eax*4],1
  jne ex_if
  mov eax, dword ptr[ebp-8]
  mov ecx, dword ptr[b2]
  cmp dword ptr[ecx+eax*4],1
  jne ex_if

  ; case_3 body
  mov eax,dword ptr [ebp-8]
  mov ecx,dword ptr [res]
  mov edx,dword ptr [ebp-4]

  mov dword ptr [ecx+eax*4],edx
  mov dword ptr [ebp-4],1         ; add <- 1

ex_if:
  ; add bit
  mov eax, dword ptr[ebp-8]   ; i
  mov ecx, 4
  cdq
  idiv ecx
  cmp edx, 0  ; remainder
  jnz loop_end
  mov dword ptr [ebp-4], 0    ; add <- 0

loop_end:
  mov ecx, dword ptr[ebp-8]
  jmp loop_incr

loop_exit:
}}

/*******************************************************************************************/
void vmss_decbinsum(INTFIELD *b1, INTFIELD *b2, INTFIELD *res) {
    INTFIELD cr, cr2, res1, res2, tf;
    int tet_count;
    // make correction
    printf("A:  %s\n", bits2string(b1));
    printf("B:  %s\n", bits2string(b2));
    vmss_makefixtet(b1, &cr);
    printf("F:  %s\n", bits2string(&cr));
    // sum A + CR = A'
    vmss_tsum(b1, &cr, &res1, 0);
    printf("A': %s\n", bits2string(&res1));
    // sum A' + B = B'
    vmss_tsum(&res1, b2, &res2, &tf);
    printf("B:  %s\n", bits2string(b2));
    printf("B': %s\n", bits2string(&res2));
    // 2nd correction
    printf("TF: %s\n", bits2string(&tf));
    tet_count = vmss_gettet_count(&cr);
    vmss_makefixtet_sub(&tf, &cr2, tet_count);
    printf("F': %s\n", bits2string(&cr2));
    // B' + CR' = B
    vmss_sum_notf(&res2, &cr2, res);
    printf("RS: %s\n", bits2string(res));

}