#
#  Autor(s)      : Jordi Ferrer Plana
#  e-mail        : jferrerp@eia.udg.es
#  Branch        : -
#
#  Working Group : Departament d'Electrònica, Informàtica i Automàtica
#  Project       : Examen d'ETIS/ETIG d'Estructura i Tecnologia de Computadors,
#                  2ona convocatòria, any 2005.
#  Homepage      : http://eia.udg.es/etc/
#
#  Module        : Problema 4. Zero.
#
#  File          : zero.txt
#  Date          : 06/07/2004 - 07/07/2004
#
#  Compiler      : -
#  Libraries     : -
#
#  Notes         : - Recompte dels zeros que hi ha a la memòria de la MS1.
#                  - Els programes estan implementats utilitzant etiquetes
#                    per facilitar-ne la comprensió.
#                  - El resultat es guarda a l'adreça 102d = 66h.
#                  - Es tenen en compte els zeros que hi ha a la memòria
#                    just en el moment de començar a executar la primera
#                    instrucció del programa.
#
# ----------------------------------------------------------------------------
#
#      Copyright (C) 2004-2005, Jordi Ferrer Plana
#
#      This program is free software; you can redistribute it and/or
#      modify it under the terms of the GNU General Public License
#      as published by the Free Software Foundation; either version 2
#      of the License, or (at your option) any later version.
#
#      This program is distributed in the hope that it will be useful,
#      but WITHOUT ANY WARRANTY; without even the implied warranty of
#      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
#      See the GNU General Public License (http://www.gnu.org/copyleft/)
#      for more details.
#
# ----------------------------------------------------------------------------
#

Versió 1 (Òptima en temps i mida):
==================================

    Loop = 0x00: CMP Zero, 0x0A        # Fins l'@ 0x09 hi ha el programa (!= 0)
           0x01: BEQ WasZero           # Si l'@ 0x0A == Zero (0) -> Incrementar
           0x02: CMP Next, Next        # NO era Zero => Salt incondicional
           0x03: BEQ Next              #   a l'adreça Next
 WasZero = 0x04: ADD Un, Count         # Incrementar (era un Zero)
    Next = 0x05: ADD Un, Loop          # Modificar per comparar la següent @
           0x06: CMP Loop, EndLoop     # Comparar si s'ha arribat a la darrera
     End = 0x07: BEQ End               #   iteració => Interació infinita
           0x08: CMP Next, Next        # Salt incondicional a l'adreça
           0x09: BEQ Loop              #   Loop (propera iteració).
           0x0A: ...

           0x65: ...                   # El recompte (@ 0x102). Sempre hi ha,
   Count = 0x66: 0x0001                #   com a mínim, el Zero del final (0x7F).
           0x67: ...                   #   A més a més, d'aquesta forma no hi
                                       #   ha un zero que, quan toqui comptar,
                                       #   probablement ja hagi desaparegut.
           0x7C: ...
 EndLoop = 0x7D: CMP Zero, EndLoop     # "Valor" que indica "Fi d'Iteracions"
      Un = 0x7E: 0x0001                # Per incrementar en una unitat
    Zero = 0x7F: 0x0000                # Zero per comparar




Versió 2 (Òptima en mida):
==========================

   Inc = 0x00: ADD Un, Count            # Comptar el primer (l'@ Count = 0)
  Loop = 0x01: CMP Cnt, Last            # Mirar si el comptatge ha arribat al
         0x02: BEQ Loop                 #   final => Iterar indefinidament
         0x03: ADD Un, Cnt              # Incrementar el comptatge
         0x04: ADD Un, 0x05             # Modificar la instrucció 0x05 per
         0x05: CMP Zero, 0x08           #   comparar el primer valor (@ 0x09)
         0x06: BEQ Inc                  # Era 0 => Propera iteració incrementant
         0x07: CMP Zero, Zero           # Salt incondicional: propera
         0x08: BEQ Loop                 #   iteració sense incrementar.
         0x09: ...

         0x65: ...
 Count = 0x66: 0x0000                   # Recompte
         0x67: ...

         0x7B: ...
   Cnt = 0x7C: 0x0009                   # El programa comença a comp. @0x09
    Un = 0x7D: 0x0001                   # Per incrementar
  Last = 0x7E: 0x0080                   # Darrera valor. Cal comptar el 0 que
  Zero = 0x7F: 0x0000                   #   hi ha en aquesta posició @0x7F