2

I need help with my task in assembly (Intel 8086 CPU). The task is:

A program to try reading from the terminal line by line: Read input from the terminal line by line with INT 21h AH=0x0a and find the minimum line length in bytes. The length does not include characters ending the line, i.e. you use the length passed by the service AH=0x0a in the second byte as an unsigned number. Attention, you are comparing unsigned numbers.
You put the resulting minimum length in the byte variable rsltbe in the data segment as an unsigned number.
Assume that at least one row will always be loaded.
Since the length is an unsigned byte number, a line up to a total length of 255 bytes may be processed.

I tried many times rewriting the code. Last time I tried this one, but it too doesn't work correctly:

cpu 8086
segment code
..start mov bx,data
    mov ds,bx
    mov bx,stack
    mov ss,bx
    mov sp,dno
    
    mov al,0
    
lop mov bl,[loaded+1]
    cmp al,bl
    jb change
back    mov AH, 0x0a
    mov DX, loaded
    int 21h
    jnz lop
    mov [rsltbe],al
    hlt
    
change  mov al,bl
    jmp back
    
segment data
rsltbe  db 0
loaded db 255,0
    resb 255
    
segment stack
    resb 16
dno:    db ?
Sep Roland
  • 33,889
  • 7
  • 43
  • 76
Loosos
  • 83
  • 4
  • 1
    What does "it doesn't work correctly" mean, exactly? Does it give an error? An unexpected output? Try to narrow down which part of the problem you need help with, so that people don't have so much description and code to look through to help you – IMSoP Jan 01 '23 at 14:51
  • It gives incorrect result. Looks like my code is finding maximum line length, not minimum as the task requires. I dont know how to rewrite the code to do that thing. I am absolute begginer. – Loosos Jan 01 '23 at 14:57
  • 2
    That code is expecting (1) the flags to be set after the `int 21h` — but I believe the flags are undefined after int 21h, and (2) that `al` holds some interesting value after the `int 21h` — but I believe it doesn't even though it was set to zero originally. – Erik Eidt Jan 01 '23 at 15:31
  • Hmm I agree with you, but dont know how to rewrite it better. What would you change in code to make it working then? – Loosos Jan 01 '23 at 17:47
  • If you want to preserve the flags you could do `pushf int 21h popf` and you'll get the proper flags back. – puppydrum64 Jan 05 '23 at 11:44
  • Oh, and you need to `cli` before `hlt` if you're using `hlt` to freeze the program. Otherwise the next IRQ hit will allow your program to continue into `jmp back` and you'll be reading who knows what. – puppydrum64 Jan 05 '23 at 11:47

1 Answers1

1

Review

  • You tagged your question , but in emu8086 (that uses MASM-style), an instruction like mov DX, loaded will not load the address of the input structure in DX, but rather load a word from memory. That is not what you need. Nonetheless, DOS will perform an input and store the result somewhere else than what you expect.

  • The DOS.BufferedInput function 0Ah does not return any flags. Therefore acting on the zero flag (jnz lop) will produce unexpected results. And neither does this DOS function return any defined value in the AX register. Moreover, practice dictates that you should not trust any DOS function to even retain the pre-existing value from the AX register.

  • At 16 bytes, your stack is much too small to function correctly. Better make this something like 512 bytes.

  • Your current attempt interprets a length even before having performed a first input! The task description says "Assume that at least one row will always be loaded." So execute the input first.

Since the objective is to find the shortest line, initialize your reference variable CL with the maximum unsigned value which is 255. Then if the actual input is shorter than that, load the new value in the reference variable.

MASM-style

  ...
  mov  cl, 255               ; Reference variable
  mov  bx, OFFSET loaded + 1
Again:
  mov  byte ptr [bx], 0      ; Always a fresh input 
  lea  dx, [bx - 1]
  mov  ah, 0Ah               ; DOS.BufferedInput
  int  21h
  mov  al, [bx]              ; Actual length (excluding carriage return)
  cmp  al, 0
  je   Done                  ; Stop on an empty input
  cmp  al, cl
  jnb  Again                 ; This line is not shorter
  mov  cl, al
  jmp  Again                 ; This line is shortest up till now
Done:
  mov  rsltbe, cl            ; [1,254]
  ...

NASM-style

  ...
  mov  cl, 255               ; Reference variable
  mov  bx, loaded + 1
Again:
  mov  byte [bx], 0          ; Always a fresh input 
  lea  dx, [bx - 1]
  mov  ah, 0Ah               ; DOS.BufferedInput
  int  21h
  mov  al, [bx]              ; Actual length (excluding carriage return)
  cmp  al, 0
  je   Done                  ; Stop on an empty input
  cmp  al, cl
  jnb  Again                 ; This line is not shorter
  mov  cl, al
  jmp  Again                 ; This line is shortest up till now
Done:
  mov  [rsltbe], cl          ; [1,254]
  ...
Sep Roland
  • 33,889
  • 7
  • 43
  • 76