.XLIST
; Borra la pantalla
Rutina_Borrar PROC FAR
     Salvar_Registros <AX,BX,CX,DX>
     MOV  AX, 0600H
     MOV  BH, 07
     MOV  CX, 0000    ; Esquina superior izquierda
     MOV  DX, 184FH   ; Esquina inferior derecha
     INT  Video
     MOV  DX, 0       ; Posicionar el cursor en la esquina superior izquierda
     Posicion_x_y
     Recuperar_Registros <DX,CX,BX,AX>
     RET
Rutina_Borrar ENDP

; Posiciona el cursor el la fila DH y la columna DL
Rutina_Posicion PROC  FAR
     Salvar_Registros <AX,BX,DX>
     MOV  AH, 02       ; 02 = Funcion para posicionar cursor
     MOV  BH, 0
     INT  Video
     Recuperar_Registros <DX,BX,AX>
     RET
Rutina_Posicion ENDP

; Lee caracteres del teclado, en la zona apuntada por DI, hasta que se
; se teclee <return>
Rutina_Leer PROC  FAR
     Salvar_Registros <AX,BX,CX,DX>
     MOV  AH, 3FH     ; 3FH = Funcion de entrada de DOS
     MOV  BX, 0
     MOV  CX, 255     ; CX = Maximo de caracteres a leer
     LEA  DX, [DI+1]  ; DX = Direccion donde debe leer
     INT  Llamar_DOS
                      ; AX = Numero de caracteres leidos
     SUB  AL, 2       ; Se resta dos para eliminar el CR, LF del final
     MOV [DI], AL     ; AL = longitud de la cadena leida
     Recuperar_Registros <DX,CX,BX,AX>
     RET
Rutina_Leer ENDP

; Imprime en la pantalla la cadena de caracteres apuntada por DX
Rutina_Imprimir PROC  FAR
     Salvar_Registros <AX,BX,CX,SI>
     MOV AH, 40H       ; 40H = Funcion de salida de DOS
     MOV BX, 1
     MOV SI, DX
     MOV CL, [SI]      ; CL = Numero de caracteres a imprimir
     MOV CH, 0
     INC DX
     INT Llamar_DOS
     Recuperar_Registros <SI,CX,BX,AX>
     RET
Rutina_Imprimir ENDP

; Lee una cadena de caracteres de la pantalla, la convierte a numero. Deja el
; resultado en AX.
Convertir_a_Numero PROC  FAR
     Salvar_Registros <DS,SI,BX,CX,DX>
     PUSH CS           ; La cadena "Cadena_ASCII" esta en CS
     POP  DS           ; DS = CS
     Leer_Cadena Cadena_ASCII   ; "Cadena_ASCII" contiene el numero en
                                ; formato caracter
     LEA SI, Cadena_ASCII       ; SI = Direccion de "Cadena_ASCII"
     MOV AX, 0
     MOV CX, AX
     MOV CL, [SI]               ; CX = Numero de caracteres
     CMP CX, 0                  ; Cero caracteres?
     JE  Fin_Numero             ; Si, la respuesta es 0
     MOV BX, 10
     INC SI                     ; SI apunta a la 1a posicion libre
     MOV CS:Signo_Numero, 1     ; Signo_Numero = 1
     CMP BYTE PTR [SI], '-'     ; Es negativo?
     JNE Agregar_Digito         ; No, ir a calcular el numero
        MOV CS:Signo_Numero, -1 ; Si, Signo_Numero = -1
        INC SI                  ; SI apunta a la primera posicion libre
        DEC CX                  ; CX = numero de digitos
        CMP CX,0                ; Cero digitos?
        JE Fin_Numero           ; Si, la respuesta es 0
     Agregar_Digito:            ; BX = Numero equivalente a los caracteres
                                ; hasta antes de SI
       MUL BX
       MOV DL, [SI]             ; [SI] = Digito-caracter
       AND DX, 0FH              ; DX = Valor del digito
       ADD AX, DX
       MOV DX, 0
       INC SI                   ; BX = Numero equivalente a los caracteres
                                ; hasta antes de SI
     LOOP Agregar_Digito        ; Quedan digitos?
                                ; No, BX = | Numero |
     IMUL CS:Signo_Numero        ; BX = Numero
     Fin_Numero:
     Recuperar_Registros <DX,CX,BX,SI,DS>
     RET
     Signo_Numero DW ?
Convertir_a_Numero ENDP

; Convierte el numero que se encuentra en AX a caracteres.
; y lo imprime en pantalla.
Cadena_ASCII DB 80 DUP (?)
Rut_Imprimir_Numero PROC  FAR
     Salvar_Registros <AX,BX,DX,DI,SI,DS>
     PUSH CS
     POP DS
     MOV BX, 10
     LEA SI, Cadena_ASCII
     PUSH SI
     INC SI
     CMP AX,0
     JGE Calcular_ASCII
        NEG AX
        MOV BYTE PTR [SI], '-'
        INC SI
     Calcular_ASCII:
     CALL Obtener_Digito
     MOV BYTE PTR [SI], CR
     INC SI
     MOV BYTE PTR [SI], LF
     POP DI
     MOV AX, SI
     SUB AX, DI
     MOV [DI], AL
     Escribir_Cadena Cadena_ASCII
     Recuperar_Registros <DS,SI,DI,DX,BX,AX>
     RET
Rut_Imprimir_Numero ENDP

;Calcula el digito decimal menos significativo del numero que recibe en AX
Obtener_Digito  PROC
     CMP AX, 10
     JB  Es_Digito
         MOV DX, 0
         DIV BX
         PUSH DX
         CALL Obtener_Digito
         POP AX
     Es_Digito:
     OR  AL, 30H
     MOV [SI], AL
     INC SI
     RET
Obtener_Digito  ENDP

;Imprime, en binario, el numero recibido en AX.
Rutina_Escribir_Binario  PROC  FAR
     Salvar_Registros <AX,BX,CX,DX>
     MOV BX, AX
     MOV AH, 2
     MOV CX, 16
     Imprimir_Bit:
        SHL BX, 1
        MOV DL, '0'
        ADC DL, 0
        INT Llamar_DOS
     LOOP Imprimir_Bit
     MOV DL, 'B'
     INT Llamar_DOS
     MOV DL, CR
     INT Llamar_DOS
     MOV DL, LF
     INT Llamar_DOS
     Recuperar_Registros <DX,CX,BX,AX>
     RET
Rutina_Escribir_Binario  ENDP

; rutina para imprimir el caracter AL en la posicion DH, DL
Rutina_Escribir_Caracter PROC  FAR
   Salvar_Registros <AX,BX,CX>
   MOV AH, 0AH
   MOV BX, 0
   MOV CX, 1
   INT Video
   Recuperar_Registros <CX,BX,AX>
   RET
Rutina_Escribir_Caracter ENDP

;Esta rutina se usa en las rutinas de abrir y cerrar archivo para convertir
;la cadena, con convenciones pascal, a cadena ASCIIZ.
;Parametro de salida: DX apunta a la cadena ASCIIZ en el segmento de codigo.
Crear_ASCIIZ PROC
   Salvar_Registros <ES,CX,SI,DI>
   MOV  SI, DX
   LEA  DX, Cadena_ASCII
   MOV  DI, DX
   PUSH CS
   POP  ES
   MOV  CL, [SI]
   MOV  CH, 0
   CMP  CX, 0
   JNE  Mover_Cadena     ;Si la cadena mide 0 o mas de 79, se pone en
   CMP  CX, 79           ;0 la cadena traducida.
   JLE  Mover_Cadena
	MOV Cadena_ASCII, 0
	JMP Fin_Crear_ASCIIZ
   Mover_cadena:
   INC  SI
   CLD
   REP  MOVSB
   MOV  BYTE PTR ES:[DI], 0
   Fin_Crear_ASCIIZ:
   Recuperar_Registros <DI,SI,CX,ES>
   RET
Crear_ASCIIZ ENDP

;Abre en entrada el archivo cuyo nombre esta apuntado por DX. Deja la manija
;en la variable $Archivo_de_Entrada.
$Archivo_de_Entrada  DW  0
Rutina_Abrir_Archivo PROC FAR
   Salvar_Registros <DS,AX,DX>
   MOV  $Archivo_de_Entrada, 0
   CALL Crear_ASCIIZ  ;Deja el nombre en el segmento de codigo. DX apunta
   PUSH CS            ;a la cadena ASCIIZ con el nombre (en seg de codigo)
   POP  DS
   MOV  AX, 3D00H     ;Funcion abrir (3DH) archivo de entrada (00H)
   INT  Llamar_DOS
   JC   Fin_Abrir_Archivo
	MOV $Archivo_de_Entrada, AX
   Fin_Abrir_Archivo:
   Recuperar_Registros <DX,AX,DS>
   RET
Rutina_Abrir_Archivo ENDP

;Crea en salida el archivo cuyo nombre esta apuntado por DX. Deja la manija
;en la variable $Archivo_de_Salida.
$Archivo_de_Salida  DW  1
Rutina_Crear_Archivo PROC FAR
   Salvar_Registros <AX,CX,DX,DS>
   MOV  $Archivo_de_Salida, 1
   CALL Crear_ASCIIZ  ;Deja el nombre en el segmento de codigo. DX apunta
   PUSH CS            ;a la cadena ASCIIZ con el nombre (en seg codigo).
   POP  DS
   MOV AH, 3CH   ;Funcion crear (3CH) archivo de salida
   MOV CX, 0
   INT Llamar_DOS
   JC Fin_Crear_Archivo
      MOV $Archivo_de_Salida, AX
   Fin_Crear_Archivo:
   Recuperar_Registros <DS,DX,CX,AX>
   RET
Rutina_Crear_Archivo ENDP

;Esta rutina lee un byte del archivo abierto con Abrir_Archivo, lo retorna
;en AL, AX = -1 si se termino el archivo.
Rutina_Leer_Byte PROC FAR
   Salvar_Registros <DS,BX,CX,DX>
   MOV  AH, 3FH
   MOV  BX, $Archivo_de_Entrada
   MOV  CX, 1
   LEA  DX, Cadena_ASCII
   PUSH CS
   POP  DS
   INT  Llamar_DOS
   JC   Fin_Leer_Byte
	CMP AX, 0
	JNE No_Es_Fin_Archivo
	    MOV AH, 3EH                 ;Fin de archivo. Cerrarlo y poner
	    MOV BX, $Archivo_de_Entrada ;AX en -1.
	    INT Llamar_DOS
	    MOV AX, -1
	    JMP Fin_Leer_Byte
	No_Es_Fin_Archivo:
	MOV AL, Cadena_ASCII
   Fin_Leer_Byte:
   Recuperar_Registros <DX,CX,BX,DS>
   RET
Rutina_Leer_Byte ENDP

;Esta rutina escribe un byte en el archivo creado con Crear_Archivo, lo
;recibe en AL.
Rutina_Escribir_Byte PROC FAR
   Salvar_Registros <AX,BX,CX,DX,DS>
   LEA  DX, Cadena_ASCII
   MOV  Cadena_ASCII, AL
   PUSH CS
   POP  DS
   MOV  AH, 40H
   MOV  BX, $Archivo_de_Salida
   MOV  CX, 1
   INT  Llamar_DOS
   Recuperar_Registros <DS,DX,CX,BX,AX>
   RET
Rutina_Escribir_Byte ENDP

;Esta rutina cierra el archivo creado con Crear_Archivo.
Rutina_Cerrar_Archivo PROC FAR
   Salvar_Registros <AX,BX>
   MOV AH, 3EH
   MOV BX, $Archivo_de_Salida
   INT Llamar_DOS
   Recuperar_Registros <BX,AX>
   RET
Rutina_Cerrar_Archivo ENDP

.LIST