QL80

Priskribo de la ĉi-paĝa enhavo

Z80-tradukilo verkita en SuperBASIC por Sinclair QL.

Etikedoj:

QL80 estas tradukilo (asemblilo) por Z80-kodo, verkita en SuperBASIC por Sinclair QL. Per ĝi mi verkis multan Z80-kodon por ZX Spectrum.

La notoj en la fontkodo, kaj la nomoj de variabloj, konstantoj kaj funkcioj, estas hispanlingvaj. La uzanto-interfaco estas en la hispana, esperanta kaj angla lingvoj.

Fontkodo

REMark ---------------------------------------------------------------
REMark                          QL80
REMark ---------------------------------------------------------------
:
REMark versio.n: / versio: / version:   0.40
:
REMark Ensamblador de Z80 para el ordenador Sinclair QL
REMark Z80-asemblilo por la komputilo Sinclair QL
REMark Z80 assembler for the Sinclair QL computer
:
REMark Copyright (C) 1992 Marcos Cruz (http://programandala.net)
REMark Licencia/Permesilo/License: http://programandala.net/license
:
REMark L-lmites de esta versio.n:
REMark Cxiversiaj limoj:
REMark Limits of this version:
:
REMark - 4095 etiquetas de 6 letras, que empiecen por mayetscula
REMark - 32768 l-lneas de programa fuente
REMark - 10 pardometros como mdoximo en DEFB y DEFW
REMark - 136 columnas como m-lnimo en impresora para los listados
REMark - no puede emplearse el punto y coma dentro de las cadenas
REMark - lista las etiquetas por orden de creacio.n, no alfabketico
:
REMark Herramientas usadas: / Uzitaj iloj: / Toolkits used:
:
REMark              Care/QJUMP Toolkit II 2.11
REMark                  TURBO Toolkit 1.32
REMark                  TURBO Compiler 1.09
:
REMark ---------------------------------------------------------------
:
REMark (1.00)
REMark 1988
REMark Intento de hacer un ensamblador en Forth
REMark que traduzca lenguaje ensamblador del Z80 escrito
REMark de forma totalmente estdondar en un fichero de texto
REMark Abandonado debido a las complicaciones:
REMark pantallas del Forth, tratamiento de ficheros, cadenas...
:
REMark (2.00)
REMark 1988
REMark En SuperBasic
REMark Intento de hacer un ensamblador que interprete
REMark los nemo.nicos Z80 como o.rdenes de Basic
:
REMark (3.00)
REMark 1988
REMark Intento de ensamblador en Forth que lea
REMark una versio.n especial de ensamblador de Z80, adaptada
REMark a la sintaxis del Forth: los nemo.nicos son palabras,
REMark el programa estdo escrito en pantallas de Forth, etc.
REMark Abandonado antes de ser totalmente depurado
REMark por no poder usarlo para compilar Z80 estdondar
:
REMark (4.00)
REMark 1988
REMark Primera versio.n esquelketica en SuperBasic con plantemientos
REMark totalmente tradicionales: dos pasadas
:
REMark (4.44)
REMark 1988 06
:
REMark (6.30) 0.00
REMark 1988
REMark Primera versio.n realmente utilizable, despukes de
REMark sucesivas betsquedas de errores
:
REMark (6.40) 0.01
REMark 1988
REMark - Detecta etiquetas con mdos de seis caracteres y da error
:
REMark (7.00) 0.02
REMark - Reconoce cadenas de un cardocter en las expresiones
:
REMark (8.00) 0.10
REMark - Crea fichero objeto con cabecera para enviar al Spectrum
REMark - Emplea la parte superior de la pantalla, no la inferior
REMark - Emplea mdos o.rdenes del Toolkit II, y menos del Turbo Toolkit
REMark - Muestra correctamente la l-lnea, en caso de error
REMark - Corregido error al calcular "dir_vale", en "localiza_etiqueta%"
:
REMark (9.00) 0.20
REMark - Lista todos los errores posibles sin detener el ensamblado
REMark - A_fadido el procedimiento "lista_error"
REMark - Cita l-lnea del mo.dulo en la que se produce cada error
REMark - Corregido error de "RETurn" en "ex%"
REMark - A_fadida comparacio.n de pardometros en la primera pasada en "RET"
REMark - Si se agota el espacio para las etiquetas, le a_fade la memoria libre
:
REMark (9.01) 0.21
REMark 1989 04 17
REMark - Corregida columna de impresio.n del nombre del mo.dulo actual
REMark - Inicializada variable "fin_cadena_no_encontrado" en "interpreta"
:
REMark (10.00) 0.22
REMark - Eliminado el tratamiento final de error en la ventana
REMark - Trasladado "bifurca_a_nemo.nico%" al interior de "ensambla"
REMark   para conseguir un poco mdos de velocidad
REMark - Corregidos un par de pardometros positivos de llamada a "lista_error"
REMark - Cambiadas comparaciones "IF x=0" a "IF NOT(x)", para mayor velocidad
REMark - Eliminada inicializacio.n "fichero_fuente$=OPT_CMD$"
REMark - Ajustes para acelerar la impresio.n en la ventana
REMark   - Tinta blanca sobre papel negro
REMark   - Correcta colocacio.n de la ventana y del borde
REMark - Eliminada instruccio.n "MODE 4"
REMark - Empleada "n_" como -lndice de bucles, en vez de "n" y "n_par"
REMark - Eliminadas "n_pendiente" y "n_eti" del "IMPLICIT%", que no se usaban
REMark - Antigua variable "fin_cadena_no_encontrado" convertida en entera
REMark - Trasladado "ensambla" al interior de "bucle_principal"
REMark - A_fadidos los procedimientos
REMark   - "borra_ventana"
REMark   - "muestra_error"
REMark   - "pausa"
REMark   - "escribe_nombre_fichero"
REMark - Trasladado "guarda_etiqueta%" al interior de "ensambla"
REMark - Trasladado "coge_etiqueta%" al interior de "interpreta"
REMark - Traladado "interpreta" al interior de "ensambla"
REMark - Eliminada comprobacio.n de longitud en "localiza_etiqueta%"
REMark - Eliminadas instrucciones "TRA", residuos de versiones antiguas
REMark - Perfeccionado y corregido el procedimiento "lista_error"
REMark - A_fadido el recuento de l-lneas del fichero fuente principal
REMark - Trasladado el co.digo de "DEFM" al interior de "ensambla"
REMark - Trasladado el co.digo de "*F" al interior de "ensambla"
:
REMark (10.01) 0.23
REMark - "org_inicial" se inicializa con 0 en lugar de con 25000
REMark - Permite espacios intermedios entre los elementos de las
REMark   expresiones numkericas a interpretar, y avisa de ellos
REMark - A_fadidos los procedimientos
REMark   - "lista_aviso"
REMark   - "lista_mensaje"
REMark - Reseteada "netm_l-lneas_mo.d%" dentro del bucle "pasada"
REMark - Preparada la ventana de ensamblado tras inicializar las
REMark   variables y flags, en lugar de antes
REMark - Si se agota el espacio de etiquetas, detiene el ensamblado
:
REMark (10.02) 0.24
REMark - Corregido error en "*L+", que se produc-la al no haberse
REMark   abierto fichero de salida
REMark - Incluido, para lo anterior, el flag "listar_fuente%"
REMark - Corregido error en la peticio.n de dispositivo de salida,
REMark   donde se saltaba a "lista_error" en vez de a "muestra_error"
:
REMark (10.10) 0.25
REMark - Permite elegir si se crea el fichero objeto con cabecera especial
REMark   para ser enviado al Spectrum directamente
REMark - Para ello se crea el flag "fichero_objeto_Spectrum%"
REMark - Si se responde en blanco a las preguntas "S/N", se considera "n"
REMark - Las instrucciones de apertura del fichero objeto han sido sacadas
REMark   de la seccio.n REMAINDER del SELECT de errores y colocadas detrdos
REMark   de la estructura REPEAT
:
REMark (10.11) 0.26
REMark - Los crkeditos del programa estdon cifrados,
REMark   para que no puedan ser alterados
REMark - Nueva funcio.n "descifrado$" y nuevas variables:
REMark   "texto_c$" y "texto_d$"
:
REMark (10.20) 0.27
REMark - La opcio.n de no crear co.digo objeto ha sido eliminada,
REMark   con lo cual la ejecucio.n es algo mdos rdopida
:
REMark (10.21) 0.28
REMark 1990 01
REMark - Se ha a_fadido un cierre de fichero objeto en el caso de
REMark   finalizar el ensamblado con error, que faltaba
:
REMark (11.00) 0.30
REMark 1990 12 -> 1991 01
REMark - El nombre pasa a ser "QL-Z80" en lugar de "Quantum Z80"
REMark - Se puede elegir la lengua de trabajo entre:
REMark   Espa_fol, Esperanto, English
REMark - Corregidas dos errores ortogrdoficos: "Lineas" por "L-lneas"
REMark - Los mensajes de error aparecen en la lengua de trabajo
:
REMark (11.10) 0.31
REMark 1991 10
REMark - Corregida la inicializacio.n de la variable
REMark   "fichero_objeto_spectrum%", que quedaba a cero si la
REMark   lengua de trabajo no era el castellano
REMark - El procedimiento "pausa" siempre hace una pausa infinita
REMark - El netmero mdoximo de etiquetas es 4095, para que su espacio
REMark   no pase de 32768 bytes, y poder emplear MOD en
REMark   el procedimiento "localiza_etiqueta%"
REMark - La validez de la etiqueta encontrada en "localiza_etiqueta%"
REMark   se combrueba con MOD, para mayor velocidad
REMark - Corregida la falta de la palabra "l-lneas" en la lengua de
REMark   trabajo en la ventana informativa final
REMark - El netmero de errores final aparece en la lengua de trabajo
REMark - Eliminados "peekw" y "pokew" en favor de PEEK y POKE_W
REMark - Eliminada "texto1$" por redundante e innecesaria
REMark - A_fadido REMAINDER que faltaba en "error_en_lengua$"
REMark - Revisados todos los textos, especialmente en esperanto
REMark - La variable "segundos%" pasa a ser real, para evitar
REMark   el l-lmite de 9 horas de ensamblado
:
REMark (11.20) 0.32
REMark 1991 12 29
REMark - Reconoce IF, ELSE y ENDIF para controlar el ensamblado
REMark - Permite hasta 36 caracteres en nombres de ficheros
REMark - Corregido error, sustituido "S" por s-l$
REMark - No altera el nombre de fichero fuente si no acaba en "_asm"
REMark - Pide el idioma mediante EDIT$, para no perder el cursor
:
REMark (11.21) 0.33
REMark 1992 01 07
REMark - Corregido error que se produc-la al responder en blanco
REMark   a la eleccio.n de lengua de trabajo (la tarea se borraba)
REMark - Actualizados los t-ltulos de crkedito
REMark - Alterado el procedimiento "descifrado$" para compatibilizarlo
REMark   con el programa codificador Nomkasxilo 1.00
REMark   (se ha invertido el bucle que examina el texto)
REMark - El nombre pasa a ser simplemente QL80 en vez de QL-Z80
:
REMark (11.30) 0.40
REMark 1992 04 05
REMark - Cierra el fichero objeto aun si no tiene cabecera de Spectrum
REMark - Corregidos graves errores en el ensamblado condicional; ahora:
REMark   1) DEFM y *F no actetan cuando ensamblar%=0
REMark   2) IF no acteta cuando ensamblar%=0
REMark   3) ELSE y ENDIF actetan siempre, aun cuando ensamblar%=0
REMark   4) Si ensamblar%=0, no se leen las etiquetas
REMark   5) Si ensamblar%=0, no se examinan los pardometros de los
REMark      comandos que deben o pueden llevarlos
REMark - Cambiado el nombre de ensamblando% a ensamblado%, mdos adecuado
REMark - A_fadida la funcio.n mayetsculas$, para comprobar mejor la extensio.n
REMark   del nombre del fichero fuente, _asm o _ASM
REMark - Cambiada la traduccio.n "fronto" por "dosierkapo"
REMark - A_fadido el procedimiento abre_ventanas
:
REMark 0.50
REMark 1996
REMark cosas a medio hacer:
REMark COSAS POR HACER:
REMark PRIORITARIAS
REMark - Nueva interfaz, a modo de las ventanas del Pointer Environment
REMark - Crear ficheros objeto para Spectrum tambiken en formato TAP
REMark - Dividir el programa en mo.dulos
REMark   para hacerlo mdos fdocil de editar y mantener, ya que la velocidad
REMark   no es un problema con la QXL
REMark - Revisar y normalizar el uso de extensiones de Turbo y TK2
REMark SECUNDARIAS
REMark - Eliminar l-lmite de 4096 etiquetas
REMark - Listar etiquetas por orden alfabketico
REMark - Eliminar l-lmite de 32768 l-lneas de co.digo fuente
REMark - Eliminar l-lmite de 10 pardometros en DEFB y DEFW
REMark - Decidir sobre los idiomas de trabajo
REMark - La variable segundos puede ser entera de nuevo,
REMark   ya que el l-lmite de 9 horas de ensamblado es suficiente
REMark DIF-lCILES
REMark - Reconocer el punto y coma en los pardometros
REMark - Permitir etiquetas de longitud variable
REMark - Permitir cualquier combinacio.n de espacios y tabuladores como separadaores
:
REMark Abreviaturas en nombres de variables
REMark ant         antigua/o
REMark dir         direccio.n
REMark dis         dispositivo
REMark exp         expresio.n
REMark h_          high, parte alta de un valor de 16 bits
REMark l_          low, parte baja de un valor de 16 bits
REMark len         longitud de una cadena
REMark lon         longitud
REMark mdox         mdoximo/a
REMark mo.d         mo.dulo
REMark n_          -lndice de bucle
REMark netm         netmero
REMark org         origen, direccio.n del co.digo objeto en el Spectrum
REMark p_          pardometro de entrada en una funcio.n
REMark par         pardometro
REMark pri         primera/o
REMark etlt         etltimo/a
:
REMark Variables enteras impl-lcitas
IMPLICIT% n_, n_pardometro, n_nemo.nico, pasada, registro1, registro2, tipo1, netm_par, n_par, operacio.n, pseudo_nemo.nico, tipo_elemento, co.d_letra, flag_error, ctexto, lengua
:
REMark Bucle principal -----------------------------------------------
:
REPeat bucle_principal
  CLEAR:REMark si no, el espacio libre de la tarea se va reduciendo
  REMark Constantes y variables inicializadas
  etlt_nemo.nico%=78:REMark 75 en v11.10
  etlt_pardometro%=30
  netm_mdox_pardometros%=10
  lon_nombre%=36:REMark 32 en v11.10
  lon_mdox_l-lnea%=115:REMark 136, menos lo que a_fade el ensamblado
  lon_media_l-lnea%=20:REMark longitud media de las l-lneas
  lon_pardometro%=lon_mdox_l-lnea%-12
  bytes_mdox_listados%=4
  REMark Cadenas
  DIM fichero_fuente$(lon_nombre%)
  DIM mo.dulo_fuente$(lon_nombre%)
  DIM fichero_objeto$(lon_nombre%)
  DIM dis_listado$(lon_nombre%)
  DIM dis_errores$(lon_nombre%)
  DIM co.digo_objeto$(bytes_mdox_listados%*2)
  DIM l-lnea$(lon_mdox_l-lnea%)
  DIM l-lnea_original$(lon_mdox_l-lnea%)
  DIM l-lnea_anterior$(lon_mdox_l-lnea%)
  DIM etiqueta$(6)
  DIM comando$(4)
  DIM pardometros$(lon_pardometro%)
  DIM un_pardometro$(lon_pardometro%)
  DIM elemento$(lon_pardometro%)
  DIM letra$(1)
  DIM comillas$(1)
  DIM plural$(2)
  DIM texto_c$(80)
  DIM texto$(60):REMark para guardar el texto en la lengua en uso
  DIM texto2$(60):REMark para guardar el texto en la lengua en uso
  DIM s-l$(1)
  DIM no$(1)
  REMark Matrices
  DIM tipo_par%(netm_mdox_pardometros%)
  DIM valor_par%(netm_mdox_pardometros%)
  DIM identificador_par%(netm_mdox_pardometros%)
  DIM valor_exp(netm_mdox_pardometros%)
  DIM nemo.nico$(etlt_nemo.nico%,4)
  DIM nemo.nico%(etlt_nemo.nico%,2)
  REMark nemo.nico%(n,0)=identificador
  REMark nemo.nico%(n,1)=netmero m-lnimo de pardometros
  REMark nemo.nico%(n,2)=netmero mdoximo de pardometros
  RESTORE
  FOR n_=0 TO etlt_nemo.nico%
    READ nemo.nico%(n_,0),nemo.nico$(n_),nemo.nico%(n_,1),nemo.nico%(n_,2)
  END FOR n_
  DIM pardometro$(etlt_pardometro%,lon_pardometro%)
  DIM pardometro%(etlt_pardometro%,2)
  REMark pardometro%(n,0)=identificador
  REMark pardometro%(n,1)=tipo
  REMark pardometro%(n,2)=valor
  FOR n_=0 TO etlt_pardometro%
    READ pardometro%(n_,0),pardometro$(n_),pardometro%(n_,1),pardometro%(n_,2)
  END FOR n_
  REMark Canales
  ventana%=4
  fichero_fuente%=5
  fichero_objeto%=6
  dis_listado%=7
  dis_errores%=8
  REMark Pantalla
  abre_ventanas
  pausa
  REMark Elegir lengua de trabajo
  REPeat elige_lengua
  CLS#ventana%
  PRINT#ventana%," 1=Espa_fol 2=Esperanto 3=English ?: ";
    letra$=EDIT$(#ventana%,"2",1)
    IF LEN(letra$) AND letra$ INSTR "123":EXIT elige_lengua
  END REPeat elige_lengua
  lengua=letra$
  SELect ON lengua
    =1:s-l$="S":no$="N":REMark Espa_fol
    =2:s-l$="J":no$="N":REMark Esperanto
    =3:s-l$="Y":no$="N":REMark English
  END SELect
  REPeat ensambla
    REMark Inicializar variables previas al ensamblado
    flag_error=0
    l-lnea$=""
    netm_errores%=0
    ensamblado%=0:REMark indicador de ensamblado aetn no comenzado
    REMark Pedir nombre de fichero fuente
    abierto_fichero_fuente%=0
    REPeat pide_fichero_fuente
      CLS#ventana%
      SELect ON lengua
        =1:texto$="Fichero fuente"
        =2:texto$="Asembla dosiero"
        =3:texto$="Source file"
      END SELect
      PRINT#ventana%," ";texto$;": ";
      fichero_fuente$=EDIT$(#ventana%,fichero_fuente$,lon_nombre%)
      IF fichero_fuente$="":EXIT ensambla
      REMark Detectar errores
      flag_fichero=DEVICE_STATUS(fichero_fuente$)
      SELect ON flag_fichero
        =-8,-20
          REMark Abrir fichero fuente
          OPEN_IN#fichero_fuente%,fichero_fuente$
          abierto_fichero_fuente%=1
          lon_fichero_fuente=FLEN(#fichero_fuente%)
          netm_l-lneas%=lon_fichero_fuente/lon_media_l-lnea%
          EXIT pide_fichero_fuente
        =-3,-6,-7,-9,-11,-12,-16
          muestra_error flag_fichero
        =REMAINDER
          muestra_error -7:REMark no encontrado
      END SELect
      NEXT pide_fichero_fuente
    END REPeat pide_fichero_fuente
    REMark Pedir tipo de fichero objeto
    REPeat pide_tipo_fichero_objeto
      CLS#ventana%
      SELect ON lengua
        =1:texto$=".eCabecera para"
        =2:texto$="Dosierkapo por"
        =3:texto$="Header for"
      END SELect
      PRINT#ventana%," ";texto$;" ZX Spectrum? ";
      letra$=EDIT$(#ventana%,s-l$,1)
      IF letra$==s-l$ OR letra$==no$:EXIT pide_tipo_fichero_objeto
    END REPeat pide_tipo_fichero_objeto
    fichero_objeto_Spectrum%=LEN(letra$)&&(letra$==s-l$)
    bytes_objeto=0:REMark inicializar contador de bytes objeto
    IF mayetsculas$(fichero_fuente$(LEN(fichero_fuente$)-3 TO))="_ASM"
      fichero_objeto$="ram1"&fichero_fuente$(5 TO LEN(fichero_fuente$)-3)
    ELSE
      fichero_objeto$="ram1"&fichero_fuente$(5 TO)&"_"
    END IF
    IF fichero_objeto_Spectrum%
      fichero_objeto$=fichero_objeto$&"SpectrumCODE"
    ELSE
      fichero_objeto$=fichero_objeto$&"Z80"
    END IF
    REMark Pedir fichero objeto
    REPeat pide_fichero_objeto
      CLS#ventana%
      SELect ON lengua
        =1:texto$="Fichero objeto"
        =2:texto$="Masxinkoda dosiero"
        =3:texto$="Object file"
      END SELect
      PRINT#ventana%," ";texto$;": ";
      fichero_objeto$=EDIT$(#ventana%,fichero_objeto$,lon_nombre%)
      IF fichero_objeto$="":EXIT ensambla
      REMark Detectar errores
      flag_fichero=DEVICE_STATUS(fichero_objeto$)
      SELect ON flag_fichero
        =-3,-6,-7,-9,-11,-12,-16,-20
         muestra_error flag_fichero
          NEXT pide_fichero_objeto
      END SELect
      EXIT pide_fichero_objeto
    END REPeat pide_fichero_objeto
    OPEN_OVER#fichero_objeto%,fichero_objeto$
    IF fichero_objeto_Spectrum%
REMark - procedimiento abre_ventanas
      REMark Poner cabecera para enviar despukes el co.digo al Spectrum
      BPUT#fichero_objeto%,3,0,0,0,0,255,255,255,255
    END IF
    REMark Pedir netmero mdoximo de etiquetas
    dir_zona_etiquetas=0
    netm_mdox_etiquetas%=1+INT(netm_l-lneas%/8.3)
    REPeat pide_netm_mdox_etiquetas
      CLS#ventana%
      SELect ON lengua
        =1:texto$="Netmero mdoximo de etiquetas"
        =2:texto$="Plej da etikedoj"
        =3:texto$="Largest number of labels"
      END SELect
      PRINT#ventana%," ";texto$;": ";
      netm_mdox_etiquetas%=EDIT%(#ventana%,INT(netm_mdox_etiquetas%),4)
      IF netm_mdox_etiquetas%<1 OR netm_mdox_etiquetas>4095:EXIT ensambla
      lon_zona_etiquetas=netm_mdox_etiquetas%*8
      IF lon_zona_etiquetas>(PEEK_L(163856)-PEEK_L(163852))
        muestra_error -3:REMark sin memoria
        NEXT pide_netm_mdox_etiquetas
      END IF
      EXIT pide_netm_mdox_etiquetas
    END REPeat pide_netm_mdox_etiquetas
    dir_zona_etiquetas=ALCHP(lon_zona_etiquetas)
    REMark Pedir dispositivo de errores
    REPeat pide_dis_errores
      CLS#ventana%
      SELect ON lengua
        =1:texto$="Listado de errores hacia"
        =2:texto$="Erarlisto al"
        =3:texto$="List of errors to"
      END SELect
      PRINT#ventana%," ";texto$;": ";
      dis_errores$=EDIT$(#ventana%,"ser1",lon_nombre%)
      IF dis_errores$="":EXIT ensambla
      flag_fichero=DEVICE_STATUS(dis_errores$)
      SELect ON flag_fichero
        =-3,-6,-7,-9,-11,-12,-16,-20
          muestra_error flag_fichero
        =REMAINDER
          REMark Abrir dispositivo de listado errores
          OPEN_OVER#dis_errores%,dis_errores$
          abierto_dis_errores%=1
          EXIT pide_dis_errores
      END SELect
      NEXT pide_dis_errores
    END REPeat pide_dis_errores
    REMark Pedir listado fuente S/N
    REPeat pide_listado_fuente
      CLS#ventana%
      SELect ON lengua
        =1:texto$="Listado fuente"
        =2:texto$="Asembla printajxo"
        =3:texto$="Source list"
      END SELect
      PRINT#ventana%," ";texto$;"? ";
      letra$=EDIT$(#ventana%,no$,1)
      IF letra$==s-l$ OR letra$==no$:EXIT pide_listado_fuente
    END REPeat pide_listado_fuente
    listado_fuente%=(letra$==s-l$):REMark flag invariable
    listar_fuente%=listado_fuente%:REMark flag variable durante el ensamblado, segetn los pseudonemo.nicos "*L-" y "*L+"
    REMark Pedir listado de etiquetas S/N
    REPeat pide_listado_etiquetas
      CLS#ventana%
      SELect ON lengua
        =1:texto$="Listado de etiquetas"
        =2:texto$="Etikedlisto"
        =3:texto$="Label list"
      END SELect
      PRINT#ventana%," ";texto$;"? ";
      letra$=EDIT$(#ventana%,no$,1)
      IF letra$==s-l$ OR letra$==no$:EXIT pide_listado_etiquetas
    END REPeat pide_listado_etiquetas
    listado_etiquetas%=(letra$==s-l$)
    REMark Pedir fichero de listado
    abierto_dis_listado%=0
    IF listado_fuente% OR listado_etiquetas%
      REPeat pide_dis_listado
        CLS#ventana%
        SELect ON lengua
          =1:texto$="Dispositivo de salida"
          =2:texto$="Listkanalo"
          =3:texto$="Output device"
        END SELect
        PRINT#ventana%," ";texto$;": ";
        dis_listado$=EDIT$(#ventana%,dis_listado$,lon_nombre%)
        IF dis_listado$="":EXIT ensambla
        flag_fichero=DEVICE_STATUS(dis_listado$)
        SELect ON flag_fichero
          =-3,-6,-7,-9,-11,-12,-16,-20
            muestra_error flag_fichero
          =REMAINDER
            REMark Abrir dispositivo de listado
            OPEN_OVER#dis_listado%,dis_listado$
            abierto_dis_listado%=1
            EXIT pide_dis_listado
        END SELect
      END REPeat pide_dis_listado
    END IF
    REMark Pedir confirmacio.n
    REPeat pide_confirmacio.n
      CLS#ventana%
      SELect ON lengua
        =1:texto$=".eTodo correcto"
        =2:texto$="Cxio en ordo"
        =3:texto$="All right"
      END SELect
      PRINT#ventana%," ";texto$;"? ";
      letra$=EDIT$(#ventana%,s-l$,1)
      IF letra$==s-l$ OR letra$==no$:EXIT pide_confirmacio.n
    END REPeat pide_confirmacio.n
    IF letra$==no$:EXIT ensambla
    REMark Inicializar variables para el ensamblado
    org_inicial=0:REMark direccio.n de origen por defecto
    netm_l-lneas_fuente%=0:REMark netmero de l-lneas del fichero fuente principal
    netm_etiquetas%=0
    ensamblando_mo.dulo%=0
    es_un_registro%=0
    era_-lndice%=0
    hay_pendiente%=0
    listar_l-lnea_anterior%=1
    ensamblado%=1:REMark indicar que comienza el ensamblado
    ensamblar%=1:REMark situacio.n inicial activa de la bandera de IF
    mo.dulo_fuente$=fichero_fuente$
    REMark Preparar la pantalla
    borra_ventana
    SELect ON lengua
      =1:texto$="Pasada"
      =2:texto$="Pasxo"
      =3:texto$="Pass"
    END SELect
    PRINT#ventana%," ";texto$
    SELect ON lengua
      =1:texto$="L-lnea"
      =2:texto$="Linio"
      =3:texto$="Line"
    END SELect
    AT#ventana%,0,10
    PRINT#ventana%,texto$
    SELect ON lengua
      =1:texto$="Ensamblando"
      =2:texto$="Elasemble"
      =3:texto$="Assembling"
    END SELect
    AT#ventana%,0,22
    PRINT#ventana%,texto$;":"
    escribe_nombre_fichero
    REMark Realizar el ensamblado
    tiempo_inicio=DATE
    FOR pasada=1 TO 0 STEP -1
      netm_l-lneas_mo.d%=0
      AT#ventana%,0,8
      PRINT#ventana%,2-pasada
      SET_POSITION#fichero_fuente%,0
      dir_org=org_inicial
      netm_l-lneas%=0:REMark netmero de l-lneas total de todos los ficheros
      AT#ventana%,0,16:PRINT#ventana%,"     ":REMark borrar no. l-lnea
      REPeat ensambla_mo.dulo
        REPeat lee_l-lnea
          REMark Leer l-lnea y quitarle comentarios
          IF EOF(#fichero_fuente%):EXIT lee_l-lnea
          INPUT#fichero_fuente%,l-lnea_original$
          l-lnea$=l-lnea_original$
          IF listar_fuente%
            IF NOT(pasada)
              REMark segunda pasada
              lista_l-lnea_anterior
              REMark Preparar listado de la l-lnea actual
              dir_org_anterior=dir_org
              listar_dir_anterior%=1
              co.digo_objeto$=""
              bytes_listados%=0
              l-lnea_anterior$=l-lnea_original$
            END IF
          END IF
          netm_l-lneas%=netm_l-lneas%+1
          netm_l-lneas_mo.d%=netm_l-lneas_mo.d%+1
          AT#ventana%,0,16
          PRINT#ventana%,netm_l-lneas%
          hasta%=";" INSTR l-lnea$
          IF hasta%
            IF hasta%=1:listar_dir_anterior%=0:NEXT lee_l-lnea
            l-lnea$=l-lnea$(1 TO hasta%-1)
          END IF
          len_l-lnea%=LEN(l-lnea$)
          REMark ** IF NOT(len_l-lnea%):listar_dir_anterior%=0:NEXT lee_l-lnea
          REMark Separar etiqueta
          hay_etiqueta%=0
          IF pasada
            REMark primera pasada
            IF ensamblar%
              etiqueta$=l-lnea$(1 TO 6)&"      "
              IF etiqueta$(1 TO 6)<>"      "
                REMark la etiqueta no estdo en blanco
                IF localiza_etiqueta%=-7
                  REMark la etiqueta no exist-la antes
                  REMark Guardar la etiqueta
                  IF netm_etiquetas%=netm_mdox_etiquetas%
                    lista_error -3:REMark sin memoria
                    EXIT ensambla
                  END IF
                  POKE$ dir_etiqueta,etiqueta$
                  POKE_W dir_etiqueta+6,dir_org
                  netm_etiquetas%=netm_etiquetas%+1
                  dir_etiqueta_nueva=dir_etiqueta:REMark guardar posicio.n
                  hay_etiqueta%=1
                ELSE
                  REMark la etiqueta ya exist-la
                  lista_error -8:REMark ya existe
                END IF
              END IF
            END IF
          END IF
          REMark Separar comando
          hay_comando%=0
          netm_par=0
          IF len_l-lnea%>7
            REMark la l-lnea es mayor que la zona de etiquetas
            l-lnea$=l-lnea$&"  ":REMark a_fadir dos espacios al final
            hasta%=" " INSTR l-lnea$(8 TO)+7
            IF hasta%>8
              REMark hay algo en la zona de comandos
              comando$=l-lnea$(8 TO hasta%-1)
              pardometros$=l-lnea$(hasta%+1 TO)
              IF comando$<>FILL$(" ",LEN(comando$))
                REMark el comando no estdo en blanco
                REMark Buscar comando en la lista de nemo.nicos
                FOR n_nemo.nico=0 TO etlt_nemo.nico%
                  IF comando$=nemo.nico$(n_nemo.nico)
                    netm_m-ln_par%=nemo.nico%(n_nemo.nico,1)
                    netm_mdox_par%=nemo.nico%(n_nemo.nico,2)
                    hay_comando%=1
                    EXIT n_nemo.nico
                  END IF
                END FOR n_nemo.nico
                IF hay_comando%
                  SELect ON n_nemo.nico
                    =3
                      IF ensamblar%
                        REMark DEFM
                        bytes%=0
                        IF pardometros$(1)<>'"'
                          lista_error -15:REMark pardometro incorrecto
                        ELSE
                          len_un_pardometro%=LEN(pardometros$)
                          REPeat corta_cadena
                            IF pardometros$(len_un_pardometro%)<>" ":EXIT corta_cadena
                            len_un_pardometro%=len_un_pardometro%-1
                            pardometros$=pardometros$(1 TO len_un_pardometro%)
                          END REPeat corta_cadena
                          IF pardometros$(len_un_pardometro%)<>'"'
                            lista_error -15:REMark pardometro incorrecto
                          ELSE
                            IF pasada
                              bytes%=len_un_pardometro%-2
                            ELSE
                              FOR n_=2 TO len_un_pardometro%-1
                                pokea CODE(pardometros$(n_))
                              END FOR n_
                              bytes%=n_-1
                            END IF
                          END IF
                        END IF
                      END IF
                    =75
                      REMark *F
                      IF ensamblar%
                        hasta%=" " INSTR pardometros$
                        IF hasta%=1
                          lista_error -15:REMark pardometro incorrecto
                          EXIT ensambla
                        END IF
                        pardometros$=pardometros$(1 TO hasta%-1)
                        IF ensamblando_mo.dulo%:
                          lista_error -8:REMark ya existe
                        ELSE
                          posicio.n_fuente=POSITION(#fichero_fuente%)
                          flag_fichero=DEVICE_STATUS(pardometros$)
                          SELect ON flag_fichero
                            =-8,-20
                              REMark Cambiar fichero fuente
                              CLOSE#fichero_fuente%
                              mo.dulo_fuente$=pardometros$
                              netm_l-lneas_fuente%=netm_l-lneas_mo.d%:REMark guardar l-lneas del fichero fuente principal
                              netm_l-lneas_mo.d%=0:REMark inicializar cuenta de l-lneas del nuevo mo.dulo
                              OPEN_IN#fichero_fuente%,mo.dulo_fuente$
                              ensamblando_mo.dulo%=1
                              escribe_nombre_fichero
                              listar_dir_anterior%=0
                            =-3,-6,-7,-9,-11,-12,-16
                              lista_error flag_fichero
                            =REMAINDER
                              lista_error -7:REMark no encontrado
                          END SELect
                        END IF
                        bytes%=0
                      END IF
                    =REMAINDER
                      IF netm_m-ln_par% OR netm_mdox_par%
                        IF ensamblar%
                          REMark Leer pardometros
                          IF pardometros$<>FILL$(" ",LEN(pardometros$))
                            no_quedan_pardometros%=0
                            REPeat separa_pardometros
                              hasta%="," INSTR pardometros$
                              IF hasta%
                                IF hasta%=1
                                  lista_error -21:REMark l-lnea incorrecta
                                  NEXT lee_l-lnea
                                END IF
                                un_pardometro$=pardometros$(1 TO hasta%-1)
                                len_un_pardometro%=LEN(un_pardometro$)
                                pardometros$=pardometros$(hasta%+1 TO)
                              ELSE
                                un_pardometro$=pardometros$
                                len_un_pardometro%=LEN(un_pardometro$)
                                REPeat corta_un_pardometro
                                  IF un_pardometro$(len_un_pardometro%)<>" ":EXIT corta_un_pardometro
                                  IF len_un_pardometro%=1:EXIT corta_un_pardometro
                                  un_pardometro$=un_pardometro$(1 TO len_un_pardometro%-1)
                                  len_un_pardometro%=len_un_pardometro%-1
                                END REPeat corta_un_pardometro
                                no_quedan_pardometros%=1
                              END IF
                              IF netm_par>netm_mdox_par%
                                lista_error -21:REMark l-lnea incorrecta
                              END IF
                              REMark Estudiar el pardometro
                              IF len_un_pardometro%<5
                                FOR n_pardometro=0 TO etlt_pardometro%
                                  IF un_pardometro$=pardometro$(n_pardometro)
                                    es_un_registro%=1
                                    EXIT n_pardometro
                                  END IF
                                END FOR n_pardometro
                              END IF
                              IF es_un_registro%
                                es_un_registro%=0
                                identificador_par%(netm_par)=pardometro%(n_pardometro,0)
                                tipo_par%(netm_par)=pardometro%(n_pardometro,1)
                                valor_par%(netm_par)=pardometro%(n_pardometro,2)
                                netm_par=netm_par+1
                              ELSE
                                entre_parkentesis%=0
                                IF un_pardometro$(1)="("
                                  IF un_pardometro$(len_un_pardometro%)=")":entre_parkentesis%=1
                                END IF
                                IF entre_parkentesis%
                                  IF un_pardometro$(4) INSTR "+-"
                                    IF un_pardometro$(2 TO 3)="IX"
                                      era_-lndice%=22:REMark (IX)
                                    ELSE
                                      IF un_pardometro$(2 TO 3)="IY"
                                        era_-lndice%=23:REMark (IY)
                                      END IF
                                    END IF
                                  END IF
                                  un_pardometro$=un_pardometro$(2 TO len_un_pardometro%-1)
                                  len_un_pardometro%=len_un_pardometro%-2
                                END IF
                                IF era_-lndice%
                                  identificador_par%(netm_par)=pardometro%(era_-lndice%,0)
                                  tipo_par%(netm_par)=pardometro%(era_-lndice%,1)
                                  valor_par%(netm_par)=pardometro%(era_-lndice%,2)
                                  era_-lndice%=0
                                  netm_par=netm_par+1
                                  un_pardometro$=un_pardometro$(3 TO)
                                  len_un_pardometro%=len_un_pardometro%-2
                                  netm_mdox_par%=netm_mdox_par%+1
                                END IF
                                REMark Interpretar la expresio.n
                                hay_pendiente%=0
                                letra%=0
                                valor_expresio.n=0
                                operacio.n=1:REMark suma por defecto
                                REPeat interpreta_expresio.n
                                  fin_cadena_no_encontrado%=0:REMark resetear flag especial de cadenas
                                  elemento$=""
                                  REMark Buscar comienzo del elemento
                                  REPeat busca_elemento
                                    letra%=letra%+1
                                    IF letra%>len_un_pardometro%
                                      lista_error -17:REMark expresio.n erro.nea
                                      RETurn
                                    END IF
                                    letra$=un_pardometro$(letra%)
                                    co.d_letra=CODE(letra$)
                                    SELect ON co.d_letra
                                      =65 TO 90
                                        REMark "A...Z" etiqueta
                                        tipo_elemento=0
                                        elemento$=letra$
                                        EXIT busca_elemento
                                      =48 TO 57
                                        REMark "0...9" netmero decimal
                                        tipo_elemento=1
                                        elemento$=letra$
                                        EXIT busca_elemento
                                      =35
                                        REMark "#" netmero hexadecimal
                                        tipo_elemento=2
                                        EXIT busca_elemento
                                      =43
                                        REMark "+" suma, netmero positivo
                                        operacio.n=1:REMark suma
                                        NEXT busca_elemento
                                      =45
                                        REMark "-" resta, netmero negativo
                                        operacio.n=2:REMark resta
                                        NEXT busca_elemento
                                      =37
                                        REMark "%" netmero binario
                                        tipo_elemento=3
                                        EXIT busca_elemento
                                      =34,39
                                        tipo_elemento=5
                                        comillas$=letra$
                                        fin_cadena_no_encontrado%=1
                                        EXIT busca_elemento
                                      =36
                                        REMark "$" contador de programa
                                        tipo_elemento=4
                                        EXIT busca_elemento
                                      =32
                                        REMark espacio
                                        IF pasada
                                          REMark primera pasada
                                          lista_aviso -17:REMark expresio.n erro.nea
                                          PRINT#dis_errores%,"(Espacio innecesario ignorado)"
                                        END IF
                                        NEXT busca_elemento
                                      =REMAINDER
                                        lista_error -17:REMark expresio.n erro.nea
                                        EXIT interpreta_expresio.n
                                    END SELect
                                  END REPeat busca_elemento
                                  REMark Coger el resto del elemento
                                  REPeat coge_elemento
                                    letra%=letra%+1
                                    IF letra%>len_un_pardometro%:EXIT coge_elemento
                                    letra$=un_pardometro$(letra%)
                                    IF fin_cadena_no_encontrado%
                                      IF letra$=comillas$
                                        fin_cadena_no_encontrado%=0
                                        NEXT coge_elemento:REMark para que no se sumen las comillas
                                      END IF
                                    ELSE
                                      nueva_operacio.n%=letra$ INSTR "+-*/"
                                      IF nueva_operacio.n%:EXIT coge_elemento
                                    END IF
                                    elemento$=elemento$&letra$
                                  END REPeat coge_elemento
                                  REMark Calcular el valor del elemento
                                  SELect ON tipo_elemento
                                    =0
                                      REMark se trata de una etiqueta
                                      REMark Buscar la etiqueta entre las ya existentes
                                      etiqueta$=elemento$&"     "
                                      flag_error=localiza_etiqueta%
                                      SELect ON flag_error
                                        =-8
                                          REMark se encontro. la etiqueta
                                          REMark Coger su valor, en dos pasos
                                          REMark (de este modo se evita el signo)
                                          h_=PEEK(dir_etiqueta+6)
                                          valor_elemento=256*h_+PEEK(dir_etiqueta+7)
                                        =-7
                                          REMark la etiqueta no existe
                                          IF NOT(pasada)
                                            REMark segunda pasada
                                            lista_error -7:REMark no encontrado
                                            PRINT#dis_errores%,etiqueta$
                                          END IF
                                          hay_pendiente%=1:REMark aviso para un posible EQU
                                          valor_elemento=0
                                      END SELect
                                    =1
                                      REMark se trata de un netmero decimal
                                      valor_elemento=elemento$
                                    =2
                                      REMark se trata de un netmero hexadecimal
                                      valor_elemento=HEX(elemento$)
                                    =3
                                      REMark se trata de un netmero binario
                                      valor_elemento=BIN(elemento$)
                                    =5
                                      REMark se trata de una cadena
                                      IF LEN(elemento$)<>1
                                        lista_error -17:REMark expresio.n erro.nea
                                      END IF
                                      valor_elemento=CODE(elemento$)
                                    =4
                                      REMark se trata del contador de programa
                                      IF LEN(elemento$)>1
                                        lista_error -17:REMark expresio.n erro.nea
                                      END IF
                                      valor_elemento=dir_org
                                  END SELect
                                  SELect ON operacio.n
                                    =1
                                      REMark suma
                                      valor_expresio.n=valor_expresio.n+valor_elemento
                                    =2
                                      REMark resta
                                      valor_expresio.n=valor_expresio.n-valor_elemento
                                    =3
                                      REMark producto
                                      valor_expresio.n=valor_expresio.n*valor_elemento
                                    =4
                                      REMark divisio.n
                                      valor_expresio.n=valor_expresio.n/valor_elemento
                                  END SELect
                                  IF valor_expresio.n<-32768 OR valor_expresio.n>65535
                                    lista_error -4:REMark fuera de rango
                                    valor_expresio.n=0
                                  END IF
                                  IF letra%>=len_un_pardometro%
                                    EXIT interpreta_expresio.n
                                  END IF
                                  operacio.n=nueva_operacio.n%
                                END REPeat interpreta_expresio.n
                                tipo_par%(netm_par)=128+entre_parkentesis%
                                identificador_par%(netm_par)=-1:REMark borrar
                                valor_exp(netm_par)=valor_expresio.n
                                netm_par=netm_par+1
                              END IF
                              IF no_quedan_pardometros%:EXIT separa_pardometros
                            END REPeat separa_pardometros
                            IF netm_par<netm_m-ln_par%
                              lista_error -21:REMark l-lnea incorrecta
                              NEXT lee_l-lnea
                            END IF
                          ELSE
                            IF netm_m-ln_par%
                              lista_error -21:REMark l-lnea incorrecta
                              NEXT lee_l-lnea
                            END IF
                          END IF
                        END IF
                      ELSE
                        REMark no tiene que haber pardometros
                        IF pardometros$<>FILL$(" ",LEN(pardometros$))
                          lista_error -21:REMark l-lnea incorrecta
                          NEXT lee_l-lnea
                        END IF
                      END IF
                      pseudo_nemo.nico=nemo.nico%(n_nemo.nico,0)
                      IF ensamblar%
                        SELect ON pseudo_nemo.nico
                          = 1:bytes%=ld%:REMark                    LD
                          =48:bytes%=call%:REMark                  CALL
                          =52:bytes%=jr%:REMark                    JR
                          =66:bytes%=defb%:REMark                  DEFB
                          =67:bytes%=defw%:REMark                  DEFW
                          =50:bytes%=jp%:REMark                    JP
                          =19:bytes%=logicarit%(182,0):REMark      CP
                          =74:bytes%=push_pop%(0):REMark           POP
                          =73:bytes%=push_pop%(4):REMark           PUSH
                          =15:bytes%=inc_dec%(0):REMark            INC
                          =51:bytes%=ret_%:REMark                  RET
                          =18:bytes%=logicarit%(158,0):REMark      AND
                          =45:bytes%=bits%(62):REMark              BIT
                          =39:bytes%=equ%:REMark                   EQU
                          = 0:bytes%=logicarit%(166,0):REMark      XOR
                          =14:bytes%=inc_dec%(1):REMark            DEC
                          =13:bytes%=add%:REMark                   ADD
                          =49:bytes%=djnz%:REMark                  DJNZ
                          = 3:bytes%=nemo.nico1%(217):REMark        EXX
                          = 2:bytes%=ex%:REMark                    EX
                          =17:bytes%=logicarit%(142,0):REMark      SUB
                          = 7:bytes%=nemo.nico_ed%(176):REMark      LDIR
                          =44:bytes%=giros%(54):REMark             SRL
                          =46:bytes%=bits%(126):REMark             RES
                          =68:bytes%=defs%:REMark                  DEFS
                          =55:bytes%=rst%:REMark                   RST
                          =11:bytes%=nemo.nico_ed%(177):REMark      CPIR
                          =26:bytes%=nemo.nico1%(118):REMark        HALT
                          =27:bytes%=im%:REMark                    IM
                          =20:bytes%=logicarit%(174,0):REMark      OR
                          =29:bytes%=nemo.nico1%(0):REMark          NOP
                          =30:bytes%=nemo.nico1%(55):REMark         SCF
                          =36:bytes%=giros%(22):REMark             RR
                          =64:bytes%=org%:REMark                   ORG
                          =53:bytes%=nemo.nico_ed%(77):REMark       RETI
                          =47:bytes%=bits%(190):REMark             SET
                          =24:bytes%=nemo.nico1%(243):REMark        DI
                          =25:bytes%=nemo.nico1%(251):REMark        EI
                          = 4:bytes%=nemo.nico_ed%(168):REMark      LDD
                          = 5:bytes%=nemo.nico_ed%(184):REMark      LDDR
                          = 6:bytes%=nemo.nico_ed%(160):REMark      LDI
                          = 8:bytes%=nemo.nico_ed%(169):REMark      CPD
                          = 9:bytes%=nemo.nico_ed%(185):REMark      CPDR
                          =10:bytes%=nemo.nico_ed%(161):REMark      CPI
                          =12:bytes%=adc_sbc%(0):REMark            ADC
                          =16:bytes%=adc_sbc%(16):REMark           SBC
                          =21:bytes%=nemo.nico1%(63):REMark         CCF
                          =22:bytes%=nemo.nico1%(47):REMark         CPL
                          =23:bytes%=nemo.nico1%(39):REMark         DAA
                          =28:bytes%=nemo.nico_ed%(68):REMark       NEG
                          =31:bytes%=giros%(14):REMark             RL
                          =32:bytes%=nemo.nico1%(23):REMark         RLA
                          =33:bytes%=giros%(-2):REMark             RLC
                          =34:bytes%=nemo.nico1%(7):REMark          RLCA
                          =35:bytes%=nemo.nico_ed%(111):REMark      RLD
                          =37:bytes%=nemo.nico1%(31):REMark         RRA
                          =38:bytes%=giros%(6):REMark              RRC
                          =40:bytes%=nemo.nico1%(15):REMark         RRCA
                          =41:bytes%=nemo.nico_ed%(103):REMark      RRD
                          =42:bytes%=giros%(30):REMark             SLA
                          =43:bytes%=giros%(38):REMark             SRA
                          =54:bytes%=nemo.nico_ed%(69):REMark       RETN
                          =56:bytes%=in%:REMark                    IN
                          =61:bytes%=out%:REMark                   OUT
                          =69:bytes%=comando_listado%(1):REMark    *L+
                          =70:bytes%=comando_listado%(0):REMark    *L-
                          =76:bytes%=comando_if%:REMark            IF
                          =77:ensamblar%=NOT ensamblar%:REMark     ELSE
                              bytes%=0
                          =57:bytes%=nemo.nico_ed%(170):REMark      IND
                          =58:bytes%=nemo.nico_ed%(162):REMark      INI
                          =59:bytes%=nemo.nico_ed%(172):REMark      INIR
                          =60:bytes%=nemo.nico_ed%(186):REMark      INDR
                          =62:bytes%=nemo.nico_ed%(171):REMark      OUTD
                          =63:bytes%=nemo.nico_ed%(163):REMark      OUTI
                          =71:bytes%=nemo.nico_ed%(187):REMark      OTDR
                          =72:bytes%=nemo.nico_ed%(179):REMark      OTIR
                        END SELect
                      ELSE
                        REMark el ensamblado estdo desactivado por IF
                        SELect ON pseudo_nemo.nico
                          =77:ensamblar%=NOT ensamblar%:REMark     ELSE
                              bytes%=0
                          =78:ensamblar%=1:REMark                  ENDIF
                              bytes%=0
                        END SELect
                      END IF
                  END SELect
                  dir_org=dir_org+bytes%
                ELSE
                  REMark nemo.nico no reconocido
                  lista_error -12:REMark nombre incorrecto
                  NEXT lee_l-lnea
                END IF
              ELSE
                REMark nemo.nico en blanco
                IF pardometros$<>FILL$(" ",LEN(pardometros$))
                  lista_error -21:REMark l-lnea incorrecta
                  NEXT lee_l-lnea
                END IF
              END IF
            END IF
          END IF
          IF NOT(hay_comando%):listar_dir_anterior%=0
        END REPeat lee_l-lnea
        REMark se terminaron las l-lneas  del fichero fuente
        IF listar_fuente%
          REMark Listar la etltima l-lnea si acabamos la segunda pasada
          IF NOT(pasada):lista_l-lnea_anterior
        END IF
        REMark Volver al fichero principal, si es preciso
        IF ensamblando_mo.dulo%
          REMark estdobamos ensamblando un mo.dulo
          CLOSE#fichero_fuente%
          OPEN_IN#fichero_fuente%,fichero_fuente$
          SET_POSITION#fichero_fuente%,posicio.n_fuente
          netm_l-lneas_mo.d%=netm_l-lneas_fuente%:REMark recuperar l-lneas...
          REMark ...del fichero fuente principal, guardadas en comando_fichero%
          mo.dulo_fuente$=fichero_fuente$
          ensamblando_mo.dulo%=0
          escribe_nombre_fichero
          NEXT ensambla_mo.dulo
        END IF
        EXIT ensambla_mo.dulo
      END REPeat ensambla_mo.dulo
      REMark Inicializar variables para listado en la segunda pasada
      listar_dir_anterior%=0
      co.digo_objeto$=""
      bytes_listados%=0
      l-lnea_anterior$=""
      IF netm_errores%:EXIT ensambla
    END FOR pasada
    EXIT ensambla
  END REPeat ensambla
  REMark Final
  BEEP 2500,10
  borra_ventana
  IF abierto_fichero_fuente%:CLOSE#fichero_fuente%
  IF dir_zona_etiquetas:RECHP dir_zona_etiquetas
  IF netm_errores%
    SELect ON lengua
      =1:texto$="error":plural$="es":texto2$="en la pasada"
      =2:texto$="eraro":plural$="j":texto2$="en pasxo"
      =3:texto$="error":plural$="s":texto2$="in pass"
    END SELect
    IF netm_errores%=1:plural$=""
    PRINT#dis_errores%,\netm_errores%!texto$;plural$!texto2$!2-pasada
    CLOSE#fichero_objeto%
  ELSE
    REMark no hubo error alguno
    IF ensamblado%
      REMark el ensamblado se realizo.
      IF fichero_objeto_Spectrum%
        REMark Rellenar cabecera del fichero
        h_bytes=INT(bytes_objeto/256)
        l_bytes=bytes_objeto-256*h_bytes
        BPUT#fichero_objeto%\1,l_bytes,h_bytes:REMark netmero de bytes
        h_org=INT(org_inicial/256)
        l_org=org_inicial-256*h_org
        BPUT#fichero_objeto%\3,l_org,h_org:REMark direccio.n destino
      END IF
      CLOSE#fichero_objeto%
      REMark Mostrar resultados
      SELect ON lengua
        =1:texto$="Etiquetas":texto2$="L-lneas"
        =2:texto$="Etikedoj":texto2$="Linioj"
        =3:texto$="Labels":texto2$="Lines"
      END SELect
      PRINT#ventana%,!texto$;"=";netm_etiquetas%;
      PRINT#ventana%,!texto2$;"=";netm_l-lneas%;
      segundos=DATE-tiempo_inicio
      IF segundos
        SELect ON lengua
          =1:texto$="L-lneas/minuto":texto2$="Minutos"
          =2:texto$="Linioj/minuto":texto2$="Minutoj"
          =3:texto$="Lines/minute":texto2$="Minutes"
        END SELect
        PRINT#ventana%,!texto$;"=";60*(netm_l-lneas% DIV segundos);
        PRINT#ventana%;!texto2$;"=";segundos DIV 60;",";segundos MOD 60
      END IF
      IF listado_etiquetas%
        SELect ON lengua
          =1:texto$="Listando etiquetas"
          =2:texto$="Listante etikedojn"
          =3:texto$="Listing labels"
        END SELect
        AT#ventana%,0,55
        PRINT#ventana%,texto$;"...";
        CLS#ventana%,4
        PRINT#dis_listado%,\
        FOR n_=0 TO netm_etiquetas%-1
          dir_etiqueta=dir_zona_etiquetas+8*n_
          valor_etiqueta=256*PEEK(dir_etiqueta+6)+PEEK(dir_etiqueta+7)
          PRINT#dis_listado%,PEEK$(dir_etiqueta,6);
          PRINT_USING#dis_listado%,"######",valor_etiqueta;
          PRINT#dis_listado%,!HEX$(valor_etiqueta,16);"  ";
          IF (n_&&3)=3:PRINT#dis_listado%
        END FOR n_
        PRINT#dis_listado%
        AT#ventana%,0,55
        CLS#ventana%,4
      END IF
      pausa
    END IF
  END IF
  IF abierto_dis_listado%:CLOSE#dis_listado%
  CLOSE#dis_errores%
END REPeat bucle_principal
:
REMark Procedimientos y funciones auxiliares ------------------------
:
DEFine PROCedure lista_error(netm_error%)
  SELect ON lengua
    =1,3:texto$="ERROR"
    =2:texto$="ERARO"
  END SELect
  PRINT#dis_errores%,\texto$;
  lista_mensaje netm_error%
  netm_errores%=netm_errores%+1
END DEFine lista_error
:
DEFine PROCedure lista_aviso(netm_error%)
  SELect ON lengua
    =1:texto$="AVISO"
    =2:texto$="AVERTO"
    =3:texto$="WARNING"
  END SELect
  PRINT#dis_errores%,\texto$;
  lista_mensaje netm_error%
END DEFine lista_aviso
:
DEFine PROCedure lista_mensaje(netm_error%)
  SELect ON lengua
    =1:texto$="en la l-lnea":texto2$="del mo.dulo"
    =2:texto$="en linio":texto2$="de modjulo"
    =3:texto$="in the line":texto2$="of the module"
  END SELect
  PRINT#dis_errores%,!texto$!netm_l-lneas_mo.d%!texto2$!mo.dulo_fuente$
  PRINT#dis_errores%,l-lnea_original$
  PRINT#dis_errores%,error_en_lengua$(netm_error%)
END DEFine lista_mensaje
:
DEFine PROCedure muestra_error(netm_error%)
  REMark Muestra error, no de ensamblado, en la ventana
  borra_ventana
  PRINT#ventana%," ";error_en_lengua$(netm_error%)
  pausa
END DEFine lista_error
:
DEFine FuNction error_en_lengua$(netm_error%)
  LOCal netm_error
  netm_error=ABS(netm_error%)
  SELect ON lengua
    =1
      SELect ON netm_error
        =1:texto$="No finalizado"
        =2:texto$="Tarea invdolida"
        =3:texto$="Sin memoria"
        =4:texto$="Fuera de rango"
        =5:texto$="Betfer lleno"
        =6:texto$="Canal no abierto"
        =7:texto$="No encontrado"
        =8:texto$="Ya existe"
        =9:texto$="En uso"
        =10:texto$="Fin de fichero"
        =11:texto$="Disco/Cartucho lleno"
        =12:texto$="Nombre incorrecto"
        =13:texto$="Error de transmisio.n"
        =14:texto$="Fallo en inicializacio.n"
        =15:texto$="Pardometro incorrecto"
        =16:texto$="Medio incorrecto"
        =17:texto$="Expresio.n erro.nea"
        =18:texto$="Desbordamiento"
        =19:texto$="No implementado"
        =20:texto$="So.lo lectura"
        =21:texto$="L-lnea incorrecta"
        =REMAINDER :texto$="Error "&netm_error
      END SELect
    =2
      SELect ON netm_error
        =1:texto$="Ne finita"
        =2:texto$="Nevalida tasko"
        =3:texto$="Sen memoro"
        =4:texto$="Preter rango"
        =5:texto$="Bufro plena"
        =6:texto$="Kanalo ne malfermita"
        =7:texto$="Ne trovita"
        =8:texto$="Jam ekzistas"
        =9:texto$="Uzata"
        =10:texto$="Fino de dosiero"
        =11:texto$="Plena disko aux bendo"
        =12:texto$="Erara nomo"
        =13:texto$="Elsendad-eraro"
        =14:texto$="Malsukceso dum formatado"
        =15:texto$="Erara parametro"
        =16:texto$="Disko aux bendo difektita"
        =17:texto$="Erara esprimo"
        =18:texto$="Preterrangigxo"
        =19:texto$="Ankoraux ne estigita"
        =20:texto$="Nur legebla"
        =21:texto$="Erara linio"
        =REMAINDER :texto$="Eraro "&netm_error
      END SELect
    =3
      SELect ON netm_error
        =1:texto$="Not complete"
        =2:texto$="Invalid job"
        =3:texto$="Out of memory"
        =4:texto$="Out of range"
        =5:texto$="Buffer full"
        =6:texto$="Channel not found"
        =7:texto$="Not found"
        =8:texto$="Already exists"
        =9:texto$="In use"
        =10:texto$="End of file"
        =11:texto$="Drive full"
        =12:texto$="Bad name"
        =13:texto$="Xmit error"
        =14:texto$="Format failed"
        =15:texto$="Bad parameter"
        =16:texto$="Bad medium"
        =17:texto$="Error in expression"
        =18:texto$="Overflow"
        =19:texto$="Not implemented (yet)"
        =20:texto$="Read only"
        =21:texto$="Bad line"
        =REMAINDER :texto$="Error "&netm_error
      END SELect
  END SELect
  RETurn texto$
END DEFine error_en_lengua$
:
DEFine PROCedure pausa
  AT#ventana%,0,81
  CURSEN#ventana%
  letra$=INKEY$(#ventana%,-1)
  CURDIS#ventana%
END DEFine pausa
:
DEFine PROCedure abre_ventanas
  OPEN#ventana%,con_504x14a4x0
  PAPER#ventana%,0
  INK#ventana%,7
  borra_ventana
  PRINT#ventana%," QL80 0.40  (k) 1992 far Marcos Cruz"
END DEFine ventanas
:
DEFine PROCedure borra_ventana
  CLS#ventana%
  BORDER#ventana%,2,7,0
END DEFine borra_ventana
:
DEFine PROCedure escribe_nombre_fichero
  AT#ventana%,0,36
  IF ensamblando_mo.dulo%
    PRINT#ventana%,mo.dulo_fuente$
  ELSE
    PRINT#ventana%,fichero_fuente$
  END IF
  CLS#ventana%,4
END DEFine
:
DEFine PROCedure lista_l-lnea_anterior
  IF listar_l-lnea_anterior%
    REMark hay que listar la l-lnea anterior
    IF listar_dir_anterior%
      REMark hay que listar la direccio.n de la l-lnea anterior
      PRINT_USING#dis_listado%,"#####",dir_org_anterior;
      PRINT#dis_listado%," ";HEX$(dir_org_anterior,16);" ";
    ELSE
      REMark no hay que listar la direccio.n de la l-lnea aterior
      PRINT#dis_listado%,"           ";
    END IF
    PRINT#dis_listado%,co.digo_objeto$;
    PRINT#dis_listado%,FILL$(" ",9-2*bytes_listados%);l-lnea_anterior$
  ELSE
   listar_l-lnea_anterior%=1
  END IF
END DEFine lista_l-lnea_anterior
:
DEFine FuNction localiza_etiqueta%
  REMark Entrada
  REMark   etiqueta$=etiqueta a localizar, al menos de 6 caracteres
  REMark Local
  REMark   dir_etiquetas=direccio.n inicial de betsqueda
  REMark   lon_etiquetas=longitud de la zona de betsqueda
  REMark   dir_vale=cdolculo intermedio
  REMark Salida si se encuentra la etiqueta
  REMark   RETURN -8
  REMark   dir_etiqueta=direccio.n de la etiqueta en la zona
  REMark Salida si no se encuentra la etiqueta
  REMark   RETURN -7
  REMark   dir_etiqueta=primera direccio.n libre en la zona
  etiqueta$=etiqueta$(1 TO 6)
  dir_etiquetas=dir_zona_etiquetas
  lon_etiquetas=netm_etiquetas%*8+1
  REPeat busca_etiqueta
    dir_etiqueta=SEARCH_MEMORY(dir_etiquetas,lon_etiquetas,etiqueta$)
    IF dir_etiqueta
      IF (dir_etiqueta-dir_zona_etiquetas) MOD 8
        dir_etiquetas=dir_etiqueta+1
        lon_etiquetas=lon_etiquetas-dir_etiquetas+dir_zona_etiquetas
        IF lon_etiquetas>7:NEXT busca_etiqueta
      ELSE
        RETurn -8:REMark ya existe
      END IF
    END IF
    dir_etiqueta=dir_zona_etiquetas+netm_etiquetas%*8
    RETurn -7:REMark no encontrado
  END REPeat busca_etiqueta
END DEFine localiza_etiqueta%
:
DEFine FuNction descifrado$(texto_c$)
  LOCal texto_d$(80)
  texto_d$="":REMark texto descifrado
  FOR n_=1 TO LEN(texto_c$)
    texto_d$=texto_d$&CHR$(CODE(texto_c$(n_))^^255^^(LEN(texto_c$)-n_+1))
  END FOR n_
  RETurn texto_d$
END DEFine descifrado$
:
DEFine FuNction mayetsculas$(texto$)
  LOCal ctexto
  FOR n_=1 TO LEN(texto$)
    ctexto=CODE(texto$(n_))
    SELect ON ctexto
      =97 TO 122:texto$(n_)=CHR$(CODE(texto$(n_))-32)
      =137:texto$(n_)="do"
      =135:texto$(n_)="ac"
    END SELect
  END FOR n_
  RETurn texto$
END DEFine mayetsculas$
:
REMark Comandos del ensamblador -------------------------------------
:
DEFine FuNction comando_listado%(p_flag):REMark *L+ y *L-
  IF NOT(pasada)
    REMark segunda pasada
    IF listado_fuente%
      listar_fuente%=p_flag:listar_dir_anterior%=0
    END IF
    listar_l-lnea_anterior%=0
  END IF
  RETurn 0
END DEFine comando_listado%
:
DEFine FuNction comando_if%:REMark IF
  IF es_exp_sin_parkentesis%(0)
    ensamblar%=valor_exp(0)&&1
  ELSE
    lista_error -15:REMark pardometro incorrectro
  END IF
  RETurn 0
END DEFine comando_if%
:
REMark Pseudonemo.nicos ----------------------------------------------
:
DEFine FuNction defb%:REMark DEFB
  IF NOT(pasada)
    REMark segunda pasada
    FOR n_=0 TO netm_par-1
      IF es_exp_sin_parkentesis%(n_)
        byte=valor_exp(n_)
        IF vale_byte%
          pokea byte
        ELSE
          lista_error -4:REMark fuera de rango
        END IF
      ELSE
        lista_error -15:REMark pardometro incorrecto
      END IF
    END FOR n_
  END IF
  RETurn netm_par
END DEFine defb%
:
DEFine FuNction defs%:REMark DEFS
  IF pasada
    IF es_exp_sin_parkentesis%(0)
      valor=valor_exp(0)
      IF dir_org+valor<65536:RETurn valor
      lista_error -4:REMark fuera de rango
    ELSE
      lista_error -15:REMark pardometro incorrecto
    END IF
    RETurn 0
  END IF
  valor=valor_exp(0)
  IF fichero_objeto%:FOR byte=1 TO valor:pokea 0:REMark rellenar
  RETurn valor
END DEFine defs%
:
DEFine FuNction defw%:REMark DEFW
  IF NOT(pasada)
    REMark segunda pasada
    FOR n_=0 TO netm_par-1
      IF es_exp_sin_parkentesis%(n_)
        pokeaw valor_exp(n_)
      ELSE
        lista_error -15:REMark pardometro incorrecto
      END IF
    END FOR n_
  END IF
  RETurn 2*netm_par
END DEFine defw%
:
DEFine FuNction equ%:REMark EQU
  IF pasada
    REMark primera pasada
    IF hay_etiqueta%
      IF hay_pendiente%:
        lista_error -7:REMark no encontrado
      ELSE
        IF es_exp_sin_parkentesis%(0)
          POKE_W dir_etiqueta_nueva+6,valor_exp(0)
        ELSE
          lista_error -15:REMark pardometro incorrecto
        END IF
      END IF
    ELSE
      lista_error -21:REMark l-lnea incorrecta
    END IF
  ELSE
    IF listado_fuente%:dir_org_anterior=valor_exp(0)
  END IF
  RETurn 0
END DEFine equ%
:
DEFine FuNction org%:REMark ORG
  IF pasada
    REMark primera pasada
    IF es_exp_sin_parkentesis%(0)
      IF dir_org=org_inicial:org_inicial=valor_exp(0)
      dir_org=valor_exp(0)
    ELSE
      lista_error -15:REMark pardometro incorrecto
    END IF
  ELSE
    valor=valor_exp(0)
    IF fichero_objeto%:FOR byte=1 TO valor-dir_org:pokea 0
    dir_org=valor
  END IF
  RETurn 0
END DEFine org%
:
REMark Nemo.nicos multiuso -------------------------------------------
:
DEFine FuNction adc_sbc%(p_opcode%):REMark ADC y SBC
  REMark Nemo.nico p_opcode%
  REMark -------- ---------
  REMark ADC       0
  REMark SBC      16
  registro1=identificador_par%(0)
  IF pasada
    REMark primera pasada
    IF registro1=1:RETurn logicarit%(0,1):REMark ADC/SBC A,?
    RETurn 2:REMark ADC/SBC HL,rr
  END IF
  REMark segunda pasada
  SELect ON registro1
    =1:RETurn logicarit%(134+p_opcode%,1):REMark ADD/SBC A,?
    =15
      REMark ADC/SBC HL,rr
      p_opcode%=74-p_opcode%/2
      registro2=identificador_par%(1)
      SELect ON registro2
        =13:pokea_ed p_opcode%   :RETurn 2:REMark ADC/SBC HL,BC
        =14:pokea_ed p_opcode%+16:RETurn 2:REMark ADC/SBC HL,DE
        =15:pokea_ed p_opcode%+32:RETurn 2:REMark ADC/SBC HL,HL
        =16:pokea_ed p_opcode%+48:RETurn 2:REMark ADC/SBC HL,SP
      END SELect
  END SELect
  lista_error -15:REMark pardometro incorrecto
  RETurn 0
END DEFine adc_sbc%
:
DEFine FuNction bits%(p_opcode%):REMark BIT, SET y RES
  REMark Nemo.nico p_opcode%
  REMark -------- ---------
  REMark BIT       62
  REMark SET      126
  REMark RES      190
  IF pasada
    REMark primera pasada
    IF netm_par=3:RETurn 4:REMark BIT b,(Ir+n)
    RETurn 2:REMark BIT b,r/(HL)
  END IF
  REMark segunda pasada
  IF es_exp_sin_parkentesis%(0)
    bit=valor_exp(0)
    IF bit>7
      lista_error -4:REMark fuera de rango
       bit=0
    END IF
    registro2=identificador_par%(1)
    SELect ON netm_par
      =2
        REMark BIT b,r/(HL)
        IF entre_A_y_HL%(1)
          pokea_cb p_opcode%+valor_par%(1)+8*bit
          RETurn 2
        END IF
      =3
        REMark BIT b,(Ir+n)
        desplazamiento=valor_exp(2)
        IF vale_desplazamiento%
          SELect ON registro2
            =9 :pokea 221:REMark (IX)
            =11:pokea 253:REMark (IY)
          END SELect
          pokea_cb desplazamiento
          pokea p_opcode%+8*(bit+1)
          RETurn 4
        END IF
    END SELect
  END IF
  lista_error -15:REMark pardometro incorrecto
  RETurn 0
END DEFine bits%
:
DEFine FuNction giros%(p_opcode%)
  REMark Nemo.nico p_opcode%
  REMark -------- ---------
  REMark RLC      -2
  REMark RRC       6
  REMark RL       14
  REMark RR       22
  REMark SLA      30
  REMark SRA      38
  REMark SRL      54
  IF pasada:RETurn 2*netm_par:REMark primera pasada
  REMark segunda pasada
  registro1=identificador_par%(0)
  SELect ON netm_par
    =1
      REMark GIRO r
      IF entre_A_y_HL%(0)
        pokea_cb p_opcode%+valor_par%(0)
        RETurn 2
      END IF
    =2
      REMark GIRO (Ir+n)
      desplazamiento=valor_exp(1)
      IF vale_desplazamiento%
        SELect ON registro1
          =9 :pokea 221:REMark (IX)
          =11:pokea 253:REMark (IY)
        END SELect
        pokea_cb desplazamiento
        pokea p_opcode%+8
        RETurn 4
      END IF
      lista_error -4:REMark fuera de rango
    =REMAINDER
      lista_error -15:REMark pardometro incorrecto
  END SELect
  RETurn 0
END DEFine giros%
:
DEFine FuNction inc_dec%(p_opcode%)
  REMark Nemo.nico p_opcode%
  REMark -------- ---------
  REMark INC      0
  REMark DEC      1
  IF pasada
    REMark primera pasada
    IF netm_par=2:RETurn 3:REMark INC/DEC (Ir+n)
    registro1=identificador_par%(0)
    SELect ON registro1
      =17:RETurn 2:REMark IX
      =18:RETurn 2:REMark IY
    END SELect
    RETurn 1:REMark INC/DEC rr/r
  END IF
  REMark segunda pasada
  SELect ON netm_par
    =1
      IF entre_A_y_HL%(0)
        REMark INC/DEC r
        pokea 4+p_opcode%+8*(valor_par%(0)-2)
        RETurn 1
      END IF
      REMark INC/DEC rr
      registro1=identificador_par%(0)
      SELect ON registro1
        =13 TO 16
          REMark INC/DEC BC/DE/HL/SP
          pokea 3+8*p_opcode%+16*valor_par%(0)
          RETurn 1
        =17
           REMark INC/DEC IX
           pokea_dd 3+8*p_opcode%+16*valor_par%(0)
           RETurn 2
        =18
          REMark INC/DEC IY
          pokea_fd 3+8*p_opcode%+16*valor_par%(0)
          RETurn 2
      END SELect
    =2
      REMark INC/DEC (Ir+n)
      desplazamiento=valor_exp(1)
      IF vale_desplazamiento%
        registro1=identificador_par%(0)
        SELect ON registro1
          =9 :pokea_dd 52+p_opcode%:REMark (IX)
          =11:pokea_fd 52+p_opcode%:REMark (IY)
        END SELect
        pokea desplazamiento
        RETurn 3
      END IF
      lista_error -4:REMark fuera de rango
    =REMAINDER
      lista_error -15:REMark pardometro incorrecto
  END SELect
  RETurn 0
END DEFine inc_dec%
:
DEFine FuNction logicarit%(p_opcode%,p_par1%)
  REMark Nemo.nico p_opcode%,p_par1%
  REMark -------- -----------------
  REMark ADD A,   126,1
  REMark ADC A,   134,1
  REMark SUB      142,0
  REMark SBC A,   150,1
  REMark AND      158,0
  REMark XOR      166,0
  REMark CP       182,0
  IF pasada
  REMark primera pasada
    IF netm_par=2+p_par1%:RETurn 3:REMark NEMO-A (Ir+n)
    IF es_exp_sin_parkentesis%(p_par1%):RETurn 2:REMark NEMO-A n
    RETurn 1:REMark NEMO-A r/(HL)
  END IF
  REMark segunda pasada
  SELect ON netm_par
    =1+p_par1%
      REMark NEMO-A r/(HL)/n
      IF es_exp_sin_parkentesis%(p_par1%)
        REMark NEMO-A n
        byte=valor_exp(p_par1%)
        IF vale_byte%
          pokea p_opcode%+72
          pokea byte
          RETurn 2
        END IF
        lista_error -4:REMark fuera de rango
      ELSE
        IF entre_A_y_HL%(p_par1%)
          REMark NEMO-A r/(HL)
          pokea p_opcode%+valor_par%(p_par1%)
          RETurn 1
        END IF
      END IF
    =2+p_par1%
      REMark NEMO-A (Ir+n)
      desplazamiento=valor_exp(1+p_par1%)
      IF vale_desplazamiento%
        registro1=identificador_par%(p_par1%)
        SELect ON registro1
          =9 :pokea_dd p_opcode%+8:REMark (IX)
          =11:pokea_fd p_opcode%+8:REMark (IY)
        END SELect
        pokea desplazamiento
        RETurn 3
      END IF
      lista_error -4:REMark fuera de rango
    =REMAINDER
      lista_error -15:REMark pardometro incorrecto
  END SELect
  RETurn 0
END DEFine logicarit%
:
DEFine FuNction nemo.nico1%(p_opcode%)
  IF pasada:RETurn 1:REMark primera pasada
  REMark segunda pasada
  pokea p_opcode%
  RETurn 1
END DEFine nemo.nico1%
:
DEFine FuNction nemo.nico_ed%(p_opcode%)
  IF pasada:RETurn 2:REMark primera pasada
  REMark segunda pasada
  pokea_ed p_opcode%
  RETurn 2
END DEFine nemo.nico_ed%
:
DEFine FuNction push_pop%(p_opcode%)
  REMark Nemo.nico p_opcode%
  REMark -------- ---------
  REMark POP      0
  REMark PUSH     4
  registro1=identificador_par%(0)
  IF pasada
    REMark primera pasada
    IF netm_par<>1:lista_error -15:REMark pardometro incorrecto
    IF registro1=17 OR registro1=18:RETurn 2:REMark PUSH/POP IX/IY
    RETurn 1:REMark PUSH/POP rr
  END IF
  REMark segunda pasada
  SELect ON registro1
    =22:pokea    241+p_opcode%:RETurn 1:REMark AF
    =13:pokea    193+p_opcode%:RETurn 1:REMark BC
    =14:pokea    209+p_opcode%:RETurn 1:REMark DE
    =15:pokea    225+p_opcode%:RETurn 1:REMark HL
    =17:pokea_dd 225+p_opcode%:RETurn 2:REMark IX
    =18:pokea_fd 225+p_opcode%:RETurn 2:REMark IY
    =REMAINDER :lista_error -15:REMark pardometro incorrecto
  END SELect
  RETurn 0
END DEFine push_pop%
:
REMark Nemo.nicos concretos -----------------------------------------
:
DEFine FuNction add%:REMark ADD
  registro1=identificador_par%(0)
  IF pasada
    REMark primera pasada
    IF registro1=1:RETurn logicarit%(126,1):REMark ADD A,?
    IF netm_par<>2
      lista_error -15:REMark pardometro incorrecto
      RETurn 0
    END IF
    IF registro1=15:RETurn 1:REMark ADD HL,rr
    RETurn 2:REMark ADD Ir,nn
  END IF
  REMark segunda pasada
  SELect ON registro1
    =1:RETurn logicarit%(126,1):REMark ADD A,?
    =15
      REMark ADD HL,rr
      registro2=identificador_par%(1)
      SELect ON registro2
        =13:pokea 9 :RETurn 1:REMark ADD HL,BC
        =14:pokea 25:RETurn 1:REMark ADD HL,DE
        =15:pokea 41:RETurn 1:REMark ADD HL,HL
        =16:pokea 57:RETurn 1:REMark ADD HL,SP
      END SELect
    =17,18
      REMark ADD IX/IY,rr
      SELect ON registro1
        =17:pokea 221:REMark ADD IX,rr
        =18:pokea 253:REMark ADD IY,rr
      END SELect
      registro2=identificador_par%(1)
      SELect ON registro2
        =13:pokea 9 :RETurn 2:REMark ADD IX/IY,BC
        =14:pokea 25:RETurn 2:REMark ADD IX/IY,DE
        =17:IF registro1=17:pokea 41:RETurn 2:REMark ADD IX,IX
        =18:IF registro1=18:pokea 41:RETurn 2:REMark ADD IY,IY
        =16:pokea 57:RETurn 2:REMark ADD IX/IY,SP
      END SELect
  END SELect
  lista_error -15:REMark pardometro incorrecto
  RETurn 0
END DEFine add%
:
DEFine FuNction call%:REMark CALL
  IF pasada:RETurn 3:REMark primera pasada
  REMark segunda pasada
  SELect ON netm_par
    =1
      REMark CALL nn
      IF es_exp_sin_parkentesis%(0)
        pokea 205
        pokeaw valor_exp(0)
        RETurn 3
      END IF
    =2
      REMark CALL cc,nn
      IF es_condicio.n%(0)
        IF es_exp_sin_parkentesis%(1)
          pokea 196+8*valor_par%(0)
          pokeaw valor_exp(1)
          RETurn 3
        END IF
      END IF
  END SELect
  lista_error -15:REMark pardometro incorrecto
  RETurn 3
END DEFine call%
:
DEFine FuNction djnz%:REMark DJNZ
  IF pasada
    REMark primera pasada
    IF netm_par<>1:lista_error -15:REMark pardometro incorrecto
  ELSE
    REMark segunda pasada
    IF es_exp_sin_parkentesis%(0)
      desplazamiento=valor_exp(0)-dir_org-2
      IF vale_desplazamiento%
        pokea 16
        pokea desplazamiento
      ELSE
        lista_error -4:REMark fuera de rango
      END IF
    ELSE
      lista_error -15:REMark pardometro incorrecto
    END IF
  END IF
  RETurn 2
END DEFine djnz%
:
DEFine FuNction ex%:REMark EX
  registro2=identificador_par%(1)
  IF pasada
    REMark primera pasada
    IF netm_par=2
      IF registro2=17 OR registro2=18:RETurn 2:REMark EX ?,IX/IY
      RETurn 1:REMark EX ?,?
     END IF
  ELSE
    REMark segunda pasada
    registro1=identificador_par%(0)
    SELect ON registro1
      =14
        REMark EX DE,?
        IF registro2=15:pokea 235:RETurn 1:REMark EX DE,HL
      =22
        REMark EX AF,?
        IF registro2=23:pokea 8:RETurn 1:REMark EX AF,AF'
      =19
        REMark EX (SP),?
        SELect ON registro2
          =15:pokea    227:RETurn 1:REMark EX (SP),HL
          =17:pokea_dd 227:RETurn 2:REMark EX (SP),IX
          =18:pokea_fd 227:RETurn 2:REMark EX (SP),IY
        END SELect
    END SELect
  END IF
  lista_error -15:REMark pardometro incorrecto
  RETurn 0
END DEFine ex%
:
DEFine FuNction im%:REMark IM
  IF pasada
    REMark primera pasada
    IF netm_par<>1:lista_error -15:REMark pardometro incorrecto
  ELSE
    REMark segunda pasada
    IF es_exp_sin_parkentesis%(0)
      valor=valor_exp(0)
      SELect ON valor
        =2:pokea_ed 94
        =0:pokea_ed 70
        =1:pokea_ed 86
        =REMAINDER :lista_error -4:REMark fuera de rango
      END SELect
    ELSE
      lista_error -15:REMark pardometro incorrecto
    END IF
  END IF
  RETurn 2
END DEFine im%
:
DEFine FuNction in%:REMark IN
  IF pasada
    REMark primera pasada
    IF netm_par<>1:lista_error -15:REMark pardometro incorrecto
  ELSE
    REMark segunda pasada
    IF entre_A_y_L%(0)
      REMark IN r,?
      IF NOT(identificador_par%(1))
        REMark IN r,(C)
        pokea_ed 64+8*(valor_par%(0)-2)
      ELSE
        IF es_exp_con_parkentesis%(1)
          REMark IN r,(n)
          IF identificador_par%(0)=1
            REMark IN A,(n)
            byte=valor_exp(1)
            IF vale_byte%
              pokea 219
              pokea byte
            ELSE
              lista_error -4:REMark fuera de rango
            END IF
          END IF
        END IF
      END IF
    ELSE
      lista_error -15:REMark pardometro incorrecto
    END IF
  END IF
  RETurn 2
END DEFine in%
:
DEFine FuNction jp%:REMark JP
  IF pasada
    REMark primera pasada
    IF netm_par=2:RETurn 3:REMark JP cc,nn
    IF es_exp_sin_parkentesis%(0):RETurn 3:REMark JP nn
    IF identificador_par%(0)=8:RETurn 1:REMark JP (HL)
    RETurn 2:REMark JP (IX)/(IY)
  END IF
  REMark segunda pasada
  SELect ON netm_par
    =1
      IF es_exp_sin_parkentesis%(0)
        REMark JP nn
        pokea 195
        pokeaw valor_exp(0)
        RETurn 3
      END IF
      IF es_tipo%(0,17)
        REMark JP (rr)
        registro1=identificador_par%(0)
        SELect ON registro1
          =8 :pokea 233   :RETurn 1:REMark JP (HL)
          =9 :pokea_dd 233:RETurn 2:REMark JP (IX)
          =11:pokea_fd 233:RETurn 2:REMark JP (IY)
        END SELect
      END IF
    =2
      REMark .eJP cc,nn?
      IF es_condicio.n%(0)
        IF es_exp_sin_parkentesis%(1)
          pokea 194+8*valor_par%(0)
          pokeaw valor_exp(1)
          RETurn 3
        END IF
      END IF
  END SELect
  lista_error -15:REMark pardometro incorrecto
  RETurn 0
END DEFine jp%
:
DEFine FuNction jr%:REMark JR
  IF NOT(pasada)
    REMark segunda pasada
    SELect ON netm_par
      =1
        IF es_exp_sin_parkentesis%(0)
          REMark JR nn
          desplazamiento=valor_exp(0)-dir_org-2
          IF vale_desplazamiento%
            pokea 24
            pokea desplazamiento
          ELSE
            lista_error -4:REMark fuera de rango
          END IF
        END IF
      =2
        IF es_condicio.n%(0)
          REMark JR cc,nn
          IF es_exp_sin_parkentesis%(1)
            valor%=valor_par%(0)
            IF valor%<4
              desplazamiento=valor_exp(1)-dir_org-2
              IF vale_desplazamiento%
                pokea 32+8*valor%
                pokea desplazamiento
              ELSE
                lista_error -4:REMark fuera de rango
              END IF
            END IF
          END IF
        ELSE
          lista_error -15:REMark pardometro incorrecto
        END IF
    END SELect
  END IF
  RETurn 2
END DEFine jr%
:
DEFine FuNction ld%:REMark LD
  IF pasada
    REMark primera pasada
    IF netm_par=3
      IF es_exp_sin_parkentesis%(2):RETurn 4:REMark LD (Ir+n),n
      RETurn 3:REMark LD r,(Ir+n)/(Ir+n),r
    END IF
    IF netm_par<>2
      lista_error -15:REMark pardometro incorrecto
      RETurn 0
    END IF
    tipo1=tipo_par%(0)&&153
    SELect ON tipo1
      =8
        REMark LD r,?
        IF entre_A_y_L%(0)
          IF identificador_par%(0)=1
            REMark LD A,?
            IF es_exp_con_parkentesis%(1):RETurn 3:REMark LD A,(nn)
            registro2=identificador_par%(1)
            SELect ON registro2
              =20,21:RETurn 1:REMark LD A,(BC)/(DE)
              =10,12:RETurn 2:REMark LD A,I/R
            END SELect
          END IF
          IF es_exp_sin_parkentesis%(1):RETurn 2:REMark LD r,n
          RETurn 1:REMark LD r,r
        END IF
        RETurn 2:REMark LD I/R,A
      =16
        REMark LD rr,?
        IF es_exp_sin_parkentesis%(1)
          REMark LD rr,nn
          registro1=identificador_par%(0)
          SELect ON registro1=17,18:RETurn 4:REMark LD IX/IY,nn
            RETurn 3
        END IF
        IF es_exp_con_parkentesis%(1)
          REMark LD rr,(nn)
          IF identificador_par%(0)=15:RETurn 3:REMark LD HL,(nn)
          RETurn 4
        END IF
        REMark LD SP,?
        IF identificador_par%(1)=15:RETurn 1:REMark LD SP,HL
        REMark LD SP,IX/IY
        RETurn 2
      =129
        REMark LD (nn),?
        registro2=identificador_par%(1)
        SELect ON registro2=1,15:RETurn 3:REMark LD (nn),A/HL
        RETurn 4
      =17
        REMark LD (rr),?
        IF es_exp_sin_parkentesis%(1):RETurn 2:REMark LD (HL),nn
        RETurn 1
      =REMAINDER
        lista_error -15:REMark pardometro incorrecto
        RETurn 0
    END SELect
  END IF
  REMark segunda pasada
  registro1=identificador_par%(0)
  IF netm_par=3
    REMark carga con registros -lndices
    IF es_exp_sin_parkentesis%(2)
      REMark LD (Ir+n),n
      desplazamiento=valor_exp(1)
      IF vale_desplazamiento%
        byte=valor_exp(2)
        IF vale_byte%
          SELect ON registro1
            =9 :pokea_dd 54:REMark (IX)
            =11:pokea_fd 54:REMark (IY)
          END SELect
          pokea desplazamiento
          pokea byte
        END IF
      ELSE
        lista_error -4:REMark fuera de rango
      END IF
      RETurn 4
    ELSE
      IF entre_A_y_L%(2)
        REMark LD (Ir+n),r
        desplazamiento=valor_exp(1)
        IF vale_desplazamiento%
          SELect ON registro1
            =9 :pokea 221:REMark (IX)
            =11:pokea 253:REMark (IY)
          END SELect
          pokea 110+valor_par%(2)
          pokea desplazamiento
        ELSE
          lista_error -4:REMark fuera de rango
        END IF
        RETurn 3
      END IF
      IF entre_A_y_L%(0)
        REMark LD r,(Ir+n)
        desplazamiento=valor_exp(2)
        IF vale_desplazamiento%
          registro2=identificador_par%(1)
          SELect ON registro2
            =9 :pokea 221:REMark (IX)
            =11:pokea 253:REMark (IY)
          END SELect
          pokea 70+(valor_par%(0)-2)*8
          pokea desplazamiento
        ELSE
          lista_error -4:REMark fuera de rango
        END IF
      ELSE
        lista_error -15:REMark pardometro incorrecto
      END IF
      RETurn 3
    END IF
  END IF
  tipo1=tipo_par%(0)&&153
  SELect ON tipo1
    =8
      REMark LD r,?
      registro2=identificador_par%(1)
      IF entre_A_y_L%(0)
        IF registro1=1
          REMark LD A,?
          IF es_exp_con_parkentesis%(1)
            REMark LD A,(nn)
            pokea 58
            pokeaw valor_exp(1)
            RETurn 3
          END IF
          SELect ON registro2
            =20:pokea 10:RETurn 1:REMark LD A,(BC)
            =21:pokea 26:RETurn 1:REMark LD A,(DE)
            =12:pokea_ed 95:RETurn 2:REMark LD A,R
            =10:pokea_ed 87:RETurn 2:REMark LD A,I
          END SELect
        END IF
        IF es_exp_sin_parkentesis%(1)
          REMark LD r,n
          byte=valor_exp(1)
          IF vale_byte%
            pokea 6+(valor_par%(0)-2)*8
            pokea byte
          ELSE
            lista_error -4:REMark fuera de rango
          END IF
          RETurn 2
        END IF
        REMark LD r,?
        IF registro2=8
          REMark LD r,(HL)
          pokea 70+(valor_par%(0)-2)*8
          RETurn 1
        END IF
        IF entre_A_y_L%(1)
          REMark LD r,r
          pokea 64+(valor_par%(0)-2)*8+valor_par%(1)-2
        ELSE
          lista_error -15:REMark pardometro incorrecto
        END IF
        RETurn 1
      END IF
      REMark .e LD I/R,A ?
      IF registro2=1
        REMark LD ?,A
        SELect ON registro1
          =10:pokea_ed 71:REMark LD I,A
          =12:pokea_ed 79:REMark LD R,A
          =REMAINDER :lista_error -15:REMark pardometro incorrecto
        END SELect
      END IF
      RETurn 2
    =16
      REMark LD rr,?
      IF es_exp_sin_parkentesis%(1)
        REMark LD rr,nn
        registro1=identificador_par%(0)
        SELect ON registro1
          =15:pokea 33   :REMark LD HL,nn
          =14:pokea 17   :REMark LD DE,nn
          =13:pokea 1    :REMark LD BC,nn
          =17
            REMark LD IX,nn
            pokea_dd 33
            pokeaw valor_exp(1)
            RETurn 4
          =18
            REMark LD IY,nn
            pokea_fd 33
            pokeaw valor_exp(1)
            RETurn 4
          =16:pokea 49   :REMark LD SP,nn
          =REMAINDER :lista_error -15:REMark pardometro incorrecto
        END SELect
        pokeaw valor_exp(1)
        RETurn 3
      END IF
      IF es_exp_con_parkentesis%(1)
        REMark LD rr,(nn)
        registro1=identificador_par%(0)
        SELect ON registro1
          =15
            REMark LD HL,(nn)
            pokea 42
            pokeaw valor_exp(1)
            RETurn 3
          =14:pokea_ed 91 :REMark LD DE,(nn)
          =13:pokea_ed 75 :REMark LD BC,(nn)
          =17:pokea_dd 42 :REMark LD IX,(nn)
          =18:pokea_fd 42 :REMark LD IY,(nn)
          =16:pokea_ed 123:REMark LD SP,(nn)
          =REMAINDER :lista_error -15:REMark pardometro incorrecto
        END SELect
        pokeaw valor_exp(1)
        RETurn 4
      END IF
      IF registro1=16
        REMark LD SP,?
        registro2=identificador_par%(1)
        SELect ON registro2
          =15:pokea 249   :RETurn 1:REMark LD SP,HL
          =17:pokea_dd 249:REMark LD SP,IX
          =18:pokea_fd 249:REMark LD SP,IY
          =REMAINDER :lista_error -15:REMark pardometro incorrecto
        END SELect
      END IF
      RETurn 2
    =129
      REMark LD (nn),?
      direccio.n=valor_exp(0)
      registro2=identificador_par%(1)
      SELect ON registro2
        =1
          REMark LD (nn),A
          pokea 50
          pokeaw direccio.n
          RETurn 3
        =15
          REMark LD (nn),HL
          pokea 34
          pokeaw direccio.n
          RETurn 3
        =14:pokea_ed 83 :REMark LD (nn),DE
        =13:pokea_ed 67 :REMark LD (nn),BC
        =17:pokea_dd 34 :REMark LD (nn),IX
        =18:pokea_fd 34 :REMark LD (nn),IY
        =16:pokea_ed 115:REMark LD (nn),SP
        =REMAINDER :lista_error -15:REMark pardometro incorrecto
      END SELect
      pokeaw direccio.n
      RETurn 4
    =17
      REMark LD (rr),?
      registro1=identificador_par%(0)
      SELect ON registro1
        =8
          REMark LD (HL),?
          IF es_exp_sin_parkentesis%(1)
            REMark LD (HL),n
            byte=valor_exp(1)
            IF vale_byte%
              pokea 54
              pokea byte
            ELSE
              lista_error -4:REMark pardometro incorrecto
            END IF
            RETurn 2
          END IF
          IF entre_A_y_L%(1):pokea 110+valor_par%(1):RETurn 1:REMark LD (HL),r
        =21
          REMark LD (DE),?
          IF identificador_par%(1)=1:pokea 18:RETurn 1:REMark LD (DE),A
        =20
          REMark LD (BC),?
          IF identificador_par%(1)=1:pokea 2:RETurn 1:REMark LD (BC),A
      END SELect
  END SELect
  lista_error -15:REMark pardometro incorrecto
  RETurn 0
END DEFine ld%
:
DEFine FuNction out%:REMark OUT
  IF pasada
    REMark primera pasada
    IF netm_par<>2:lista_error -15:REMark pardometro incorrecto
  ELSE
    REMark segunda pasada
    IF es_exp_con_parkentesis%(0)
      REMark OUT (n),?
      IF identificador_par%(1)=1
        REMark OUT (n),A
        byte=valor_exp(0)
        IF vale_byte%
          pokea 211
          pokea byte
        ELSE
          lista_error -4:REMark fuera de rango
        END IF
      END IF
    ELSE
      REMark OUT ?
      IF NOT(identificador_par%(0))
        REMark OUT (C),?
        IF entre_A_y_L%(1)
          REMark OUT (C),A/B/C/D/E/H/L
          pokea_ed 65+8*(valor_par%(1)-2)
        END IF
      ELSE
        lista_error -15:REMark pardometro incorrecto
      END IF
    END IF
  END IF
  RETurn 2
END DEFine out%
:
DEFine FuNction ret_%:REMark RET
  IF pasada
    REMark primera pasada
    IF netm_par>1:lista_error -15:REMark pardometro incorrecto
  ELSE
    REMark segunda pasada
    SELect ON netm_par
      =0:pokea 201:REMark RET
      =1
        IF es_condicio.n%(0)
          REMark RET cc
          pokea 192+8*valor_par%(0)
        ELSE
          lista_error -15:REMark pardometro incorrecto
        END IF
    END SELect
  END IF
  RETurn 1
END DEFine ret_%
:
DEFine FuNction rst%:REMark RST
  IF pasada
    REMark primera pasada
    IF netm_par<>1:lista_error -15:REMark pardometro incorrecto
  ELSE
    REMark segunda pasada
    IF es_exp_sin_parkentesis%(0)
      valor=valor_exp(0)
      IF valor>56 OR valor MOD 8:lista_error -4:REMark fuera de rango
      pokea 199+valor
    ELSE
      lista_error -15:REMark pardometro incorrecto
    END IF
  END IF
  RETurn 1
END DEFine rst%
:
REMark Creacio.n del co.digo objeto ----------------------------------
:
DEFine PROCedure pokea_cb(p_byte)
  pokea 203:REMark #CB
  pokea p_byte
END DEFine
:
DEFine PROCedure pokea_dd(p_byte)
  pokea 221:REMark #DD
  pokea p_byte
END DEFine pokea_dd
:
DEFine PROCedure pokea_ed(p_byte)
  pokea 237:REMark #ED
  pokea p_byte
END DEFine pokea_ed
:
DEFine PROCedure pokea_fd(p_byte)
  pokea 253:REMark #FD
  pokea p_byte
END DEFine pokea_fd
:
DEFine PROCedure pokeaw(p_dir)
  h_dir=INT(p_dir/256)
  pokea p_dir-h_dir*256
  pokea h_dir
END DEFine pokeaw
:
DEFine PROCedure pokea(p_byte)
  PRINT#fichero_objeto%,CHR$(p_byte);
  bytes_objeto=bytes_objeto+1
  IF listar_fuente%
    REMark Comprobar ancho del co.digo
    IF bytes_listados%<bytes_mdox_listados%
      co.digo_objeto$=co.digo_objeto$&HEX$(p_byte,8)
      bytes_listados%=bytes_listados%+1
    END IF
  END IF
END DEFine pokea
:
REMark Funciones para comprobar rangos -----------------------------
:
DEFine FuNction vale_desplazamiento%
  REMark Entrada
  REMark   desplazamiento
  RETurn desplazamiento>-129 AND desplazamiento<128
END DEFine vale_desplazamiento%
:
DEFine FuNction vale_byte%
  REMark Entrada
  REMark   byte
  RETurn byte>65407 OR byte<256
END DEFine vale_byte%
:
DEFine FuNction entre_A_y_HL%(p_netm_par%)
  identificador%=identificador_par%(p_netm_par%)
  RETurn identificador%>0 AND identificador%<9
END DEFine entre_A_y_HL%
:
DEFine FuNction entre_A_y_L%(p_netm_par%)
  identificador%=identificador_par%(p_netm_par%)
  RETurn identificador%>0 AND identificador%<8
END DEFine entre_A_y_L%
:
REMark Funciones para comprobar pseudopardometros -------------------
:
DEFine FuNction es_exp_sin_parkentesis%(p_netm_par%)
  RETurn (tipo_par%(p_netm_par%)&&129)=128
END DEFine es_exp_sin_parkentesis%
:
DEFine FuNction es_exp_con_parkentesis%(p_netm_par%)
  RETurn (tipo_par%(p_netm_par%)&&129)=129
END DEFine es_exp_con_parkentesis%
:
DEFine FuNction es_tipo%(p_par,p_tipo)
  RETurn (tipo_par%(p_par)&&p_tipo)=p_tipo
END DEFine es_tipo%
:
DEFine FuNction es_condicio.n%(p_netm_par%)
  RETurn tipo_par%(p_netm_par%)&&2
END DEFine es_condicio.n%
:
REMark Datas -------------------------------------------------------
:
REMark Comandos
REMark identificador,"nombre",pardometros m-lnimos,pardometros mdoximos
:
DATA 1,"LD",2,2
DATA 48,"CALL",1,2
DATA 52,"JR",1,2
DATA 65,"DEFM",1,1
DATA 66,"DEFB",1,30
DATA 67,"DEFW",1,30
DATA 50,"JP",1,2
DATA 19,"CP",1,1
DATA 74,"POP",1,1
DATA 73,"PUSH",1,1
DATA 15,"INC",1,1
DATA 51,"RET",0,1
DATA 18,"AND",1,1
DATA 45,"BIT",2,2
DATA 39,"EQU",1,1
DATA 0,"XOR",1,1
DATA 14,"DEC",1,1
DATA 13,"ADD",2,2
DATA 49,"DJNZ",1,1
DATA 3,"EXX",0,0
DATA 2,"EX",2,2
DATA 17,"SUB",1,1
DATA 7,"LDIR",0,0
DATA 44,"SRL",1,1
DATA 46,"RES",2,2
DATA 68,"DEFS",1,1
DATA 55,"RST",1,1
DATA 11,"CPIR",0,0
DATA 26,"HALT",0,0
DATA 27,"IM",1,1
DATA 20,"OR",1,1
DATA 29,"NOP",0,0
DATA 30,"SCF",0,0
DATA 36,"RR",1,1
DATA 64,"ORG",1,1
DATA 53,"RETI",0,0
DATA 47,"SET",2,2
DATA 24,"DI",0,0
DATA 25,"EI",0,0
DATA 4,"LDD",0,0
DATA 5,"LDDR",0,0
DATA 6,"LDI",0,0
DATA 8,"CPD",0,0
DATA 9,"CPDR",0,0
DATA 10,"CPI",0,0
DATA 12,"ADC",2,2
DATA 16,"SBC",2,2
DATA 21,"CCF",0,0
DATA 22,"CPL",0,0
DATA 23,"DAA",0,0
DATA 28,"NEG",0,0
DATA 31,"RL",1,1
DATA 32,"RLA",0,0
DATA 33,"RLC",1,1
DATA 34,"RLCA",0,0
DATA 35,"RLD",0,0
DATA 37,"RRA",0,0
DATA 38,"RRC",1,1
DATA 40,"RRCA",0,0
DATA 41,"RRD",0,0
DATA 42,"SLA",1,1
DATA 43,"SRA",1,1
DATA 54,"RETN",0,0
DATA 56,"IN",2,2
DATA 57,"IND",0,0
DATA 58,"INI",0,0
DATA 59,"INIR",0,0
DATA 60,"INDR",0,0
DATA 61,"OUT",2,2
DATA 62,"OUTD",0,0
DATA 63,"OUTI",0,0
DATA 69,"*L+",0,0
DATA 70,"*L-",0,0
DATA 71,"OTDR",0,0
DATA 72,"OTIR",0,0
DATA 75,"*F",1,1
DATA 76,"IF",1,1
DATA 77,"ELSE",0,0
DATA 78,"ENDIF",0,0
:
REMark Pardometros
REMark identificador,"nombre",tipo,valor
REMark Significado de los bits del identificador
REMark 0 .eentre parkentesis? (tanto registros como expresiones)
REMark 1 .econdicio.n?
REMark 2
REMark 3 .eregistro de 8 bits?
REMark 4 .eregistro de 16 bits?
REMark 5
REMark 6
REMark 7 .eexpresio.n? (para las expresiones numkericas)
:
DATA 1,"A",8,9
DATA 15,"HL",16,2
DATA 24,"NZ",2,0
DATA 3,"C",10,3
DATA 25,"Z",2,1
DATA 13,"BC",16,0
DATA 2,"B",8,2
DATA 14,"DE",16,1
DATA 8,"(HL)",17,8
DATA 17,"IX",16,2
DATA 22,"AF",16,0
DATA 6,"H",8,6
DATA 21,"(DE)",17,1
DATA 5,"E",8,5
DATA 7,"L",8,7
DATA 26,"NC",2,2
DATA 4,"D",8,4
DATA 12,"R",8,0
DATA 19,"(SP)",17,0
DATA 10,"I",8,0
DATA 16,"SP",16,3
DATA 18,"IY",16,2
DATA 9,"(IX)",17,0
DATA 11,"(IY)",17,0
DATA 20,"(BC)",17,0
DATA 23,"AF'",16,0
DATA 0,"(C)",9,0
DATA 27,"PO",2,4
DATA 28,"PE",2,5
DATA 29,"P",2,6
DATA 30,"M",2,7
:

Deŝutoj