;
; Prozeduren für Eingabe bzw. Ausgabe einer ganzen Zahl (auf 16 Bits dargestellte 
; Dezimalzahl mit Vorzeichen)
;

; um int.asm zu übersetzen, ruft man:
;>tasm int
; -> es wird int.obj erzeugt
; Die hier geschriebene Unterprogrammen werden in intdemo.asm benützt

assume cs:code
code segment

public ReadInt, WriteInt


; ReadInt      - liest in AX eine Vorzeichenbehaftete, auf 16 Bits dargestellte ganze Zahl ein
; WriteInt     - zeigt am Bildschirm die Vorzeichenbehaftete, auf 16 Bits dargestellte 
;		 ganze Zahl vom Register AX an

 

ReadInt:
  push si
  push di
  push cx
  push dx
  xor  cx, cx             ; in CX werden wir die ganze Zahl aufbauen (und nur am Ende wird sie in AX kopiert)
  mov  ah, 01h            ; wir lesen den ersten Charakter ein; das kann -, + oder die erste Ziffer sein
  int  21h
  cmp  al, '-'
  jne  positiv           ; wenn der erste Charakter nicht - ist, dann ist die Zahl positiv
  mov  si, 1             ; wir setzen SI auf 1, wenn die Zahl negativ ist
  jmp  next
positiv:
  mov  si, 0              ; wir bezeichnen mit SI=0, dass die Zahl positiv ist
  cmp  al, '+'            ; eine positive Zahl kann mit + oder gleich mit einer Ziffer anfangen
  je   next
  cmp  al, '0'            ; eine Dezimalziffer soll zwischen 0 und 9 sein; wenn wir
                          ; einen anderen Charakter begegnen, beenden wir unsere Prozedur
  jb   ende
  cmp  al, '9'
  ja   ende
  mov  ah, 0              ; wir erweitern den (positiven) Wert von AL auf 16 Bits
  sub  al, '0'            ; wir korvertieren das eingelesene ASCII Kode in den entsprechenden 
                          ; Dezimalziffer (wir subtrachieren davon die ASCII Code des '0' Charakters)
  add  cx, ax
next: 		          ; Wenn wir schon ein Vorzeichen eingelesen haben, dann lesen wir 
			  ; den nächste Charakter, sondern lesen wir jetzt die erste Ziffer 
			  ; ein, und danach alle nächste Ziffern


  mov  ah, 01h
  int  21h
  cmp  al, '0'            ; die eingelesene Ziffern sollen zwischen 0 - 9 sein
  jb   ende
  cmp  al, '9'
  ja   ende
  mov  ah, 0
  sub  al, '0'            ; AX <- der Wert der letzten eingelesenen Ziffer
  mov  di, cx             ; wir 'kopieren' die neue Ziffer nach der, bis jetzt eingelesene Zahl;
                          ; wir multiplizieren den, bis jetzt eingelesenen Wertmit 10, dann
			  ; addieren wir dazu die letzte Ziffer
			  ; die Miltiplikation wird hier statt mul mit SHL durchgeführt so, dass
			  ; wir werden 2-mal Cx (SHL mit 1 Pos.) und 8-mal (SHL mit 3 Pos.) 
			  ; Cx addieren

  shl  di, 1              ; DI <- CX SHL 1
  shl  cx, 3              ; CX <- CX SHL 3
  add  cx, di
  add  cx, ax             ; dann addieren wir die letzte Ziffer dazu
  jmp  next
ende:
  mov  ax, cx             ; AX - die Rückgabewert ist in AX 
  cmp  si, 1              ; in SI haben wir das Vorzeichen gespeichert
  jne  ende2
  neg  ax                 ; wir negieren das Vorzeichen, wenn die Zahl negativ ist
ende2:
  pop  dx
  pop  cx
  pop  di
  pop  si
  ret


WriteInt:
  push si
  push di
  push cx
  push dx
  push ax
  push bx
  xor  cx, cx             ; in CX werden wir die Anzahl der Ziffern zählen
  mov  si, 10             ; wir werden immer dirch 10 teilen, damit wir 
			  ; durch dem Rest immer die letzten Ziffern der Zahl 
			  ; erhalten können

  mov  bx, ax             ; wir speichern in BX den übriggebliebenen Wert 
			  ; (der Quotient der Division)
  and  ax, 8000h          ; wir prüfen ob die Zal negativ ist
  jz   weiter
  mov  dl, '-'            ; wenn es negativ is, dann geben wir das Vorzeichen auf dem Bildschirm aus
  mov  ah, 02h
  int  21h
  neg  bx                 ; und negieren wir das Vorzeichen der Zahl, es wird also von jetzt an positiv 
weiter:
  xor  dx, dx             ; wegen der Division mit einem Wort (16 Bits) setzen wir DX auf 0
  mov  ax, bx
  div  si                 ; wir dividieren DX:AX  durch 10
  push dx                 ; den Rest (die letzte Ziffer) legen wir in den Stapel
  inc  cx                 ; und inkrementieren wir dia Anzahl der gefundenen Ziffern
  mov  bx, ax             ; der neur Wert wird in BX gespeichert (alte Wert / 10)
  cmp  ax, 0              ; Wenn der Wert nicht 0 ist (es gibt noch Ziffern), dann
                          ; schneiden wir die nächhste Ziffer ab
  jne  weiter
next_out:
  pop  dx                 ; wir nehmen die Ziffern eine nach dem anderen vom stapel heraus
  add  dl, '0'            ; dann wandeln wir sie in DL in den entsprechenden ASCII Charakter um
  mov  ah, 02h
  int  21h
  loop next_out           ; solange wir noch Ziffern haben (CX > 0), zeigen wir die nächste Ziffer
			  ; am Bildschirm an
  pop  bx
  pop  ax
  pop  dx
  pop  cx
  pop  di
  pop  si
  ret

code ends
end