; LIBI08.TXT

;       Bibliotheque mathematique pour les entiers sur 08 bits
;       ------------------------------------------------------
;
;                     (C) E+E CHAMOUARD 2001

; La bibliotheque offre les sous-programmes mathematiques pour les nombres
;   fixes codes sur 08 bits en complement a deux pour les nombres signes
;   et en binaire pur pour les nombres non signes.

; Elle utilise les memes conventions que les autres bibliotheques mathematiques
;   (code de retour en cas d'erreur,...) et (obligatoirement) les memes registres.
; C'est son unique raison d'etre car les operations fournies sont (presque)
;   triviales sur une architecture MCS51.

; La bibliotheque travaille sur 2 groupes de registres :
;   RE10 pour le premier operande ou premier resultat,
;   RE20 pour le second operande ou second resultat.

; Le programme principal doit donc definir 2 registres directs :
;   direct  RE10, xxh   ; Premier operande ou premier resultat
;   direct  RE20, xxh   ; Second operande ou second resultat

; Le chargement ou sauvegarde des resultats ou des operandes s'effectue
;   par chargement  :
;       dans la memoire externe   (ex : I08ReadExtREx),
;       dans la memoire programme (ex : I08ReadProgREx),
;       dans la memoire interne   (ex : I08ReadIntREx).

; Les operations s'effectuent en signe (ex I08Mul) ou en non signe
;   (ex I08UMul).

; La carry (C) est positionnee en cas de debordement ou d'erreur (division)
;   pour tous les sous-programmes sauf ceux de chargement ou de sauvegarde.

; Liste des sous-programmes :
;   I08ReadExtRE1               Lecture de RE1 depuis la memoire externe
;   I08ReadExtRE2               Lecture de RE2 depuis la memoire externe
;   I08ReadProgRE1              Lecture de RE1 depuis la memoire programme
;   I08ReadProgRE2              Lecture de RE2 depuis la memoire programme
;   I08ReadIntRE1               Lecture de RE1 depuis la memoire interne
;   I08ReadIntRE2               Lecture de RE2 depuis la memoire interne
;   I08WriteExtRE1              Ecriture de RE1 dans la memoire externe
;   I08WriteExtRE2              Ecriture de RE2 dans la memoire externe
;   I08WriteIntRE1              Ecriture de RE1 dans la memoire interne
;   I08WriteIntRE2              Ecriture de RE2 dans la memoire interne
;   I08ClearRE1                 Mise a 0 de RE1
;   I08UAdd                     RE1=RE1+RE2 (non signe)
;   I08USub                     RE1=RE1-RE2 (non signe)
;   I08UMul                     RE1=RE1*RE2 (non signe)
;   I08UDiv                     RE1=RE1/RE2 et RE2=RE1%RE2 (non signe)
;   I08ShLeRE1                  RE1=RE1<<A (decalage a gauche non signe)
;   I08ShLeRE2                  RE2=RE2<<A (decalage a gauche non signe)
;   I08ShRiRE1                  RE1=RE1>>A (decalage a droite non signe)
;   I08ShRiRE2                  RE2=RE2>>A (decalage a droite non signe)
;   I08NegRE1                   RE1=-RE1
;   I08SgnRE1                   C=Signe de RE1
;   I08AbsRE1                   RE1=Valeur absolue de RE1
;   I08Add                      RE1=RE1+RE2 (signe)
;   I08Sub                      RE1=RE1-RE2 (signe)
;   I08Mul                      RE1=RE1*RE2 (signe)
;   I08Div                      RE1=RE1/RE2 et RE2=RE1%RE2 (signe)

I08ReadExtRE1:
    Fonction  :   Lecture de 08 bits de la memoire externe vers l'operande/resultat RE1
    Entree(s) :   Dans {DPH,DPL} l'adresse de la donnee
    Sortie(s) :   RE1={@DPTR} (DPTR incremente d'une case)
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ReadExtRE2:
    Fonction  :   Lecture de 08 bits de la memoire externe vers l'operande/resultat RE2
    Entree(s) :   Dans {DPH,DPL} l'adresse de la donnee
    Sortie(s) :   RE2={@DPTR} (DPTR incremente d'une case)
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ReadProgRE1:
    Fonction  :   Lecture de 08 bits de la memoire programme vers l'operande/resultat RE1
    Entree(s) :   Dans {DPH,DPL} l'adresse de la donnee
    Sortie(s) :   RE1={@DPTR} (DPTR incremente d'une case)
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ReadProgRE2:
    Fonction  :   Lecture de 08 bits de la memoire programme vers l'operande/resultat RE2
    Entree(s) :   Dans {DPH,DPL} l'adresse de la donnee
    Sortie(s) :   RE2={@DPTR} (DPTR incremente d'une case)
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ReadIntRE1:
    Fonction  :   Lecture de 08 bits de la memoire interne vers l'operande/resultat RE1
    Entree(s) :   Dans R0 l'adresse de la donnee
    Sortie(s) :   RE1={@R0} (R0 incremente d'une case)
    Utilise   :   Rien
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ReadIntRE2:
    Fonction  :   Lecture de 08 bits de la memoire interne vers l'operande/resultat RE2
    Entree(s) :   Dans R0 l'adresse de la donnee
    Sortie(s) :   RE2={@R0} (R0 incremente d'une case)
    Utilise   :   Rien
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08WriteExtRE1:
    Fonction  :   Ecriture de 08 bits de l'operande/resultat RE1 vers la memoire externe
    Entree(s) :   Dans {DPH,DPL} l'adresse de la donnee
    Sortie(s) :   {@DPTR}=RE1 (DPTR incremente d'une case)
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08WriteExtRE2:
    Fonction  :   Ecriture de 08 bits de l'operande/resultat RE2 vers la memoire externe
    Entree(s) :   Dans {DPH,DPL} l'adresse de la donnee
    Sortie(s) :   {@DPTR}=RE2 (DPTR incremente d'une case)
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08WriteIntRE1:
    Fonction  :   Ecriture de 08 bits de l'operande/resultat RE1 vers la memoire interne
    Entree(s) :   Dans R0 l'adresse de la donnee
    Sortie(s) :   {@R0}=RE1 (R0 incremente d'une case)
    Utilise   :   Rien
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08WriteIntRE2:
    Fonction  :   Ecriture de 08 bits de l'operande/resultat RE2 vers la memoire interne
    Entree(s) :   Dans R0 l'adresse de la donnee
    Sortie(s) :   {@R0}=RE2 (R0 incremente d'une case)
    Utilise   :   Rien
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ClearRE1:
    Fonction  :   RAZ de l'operande/resultat RE1
    Entree(s) :   Rien
    Sortie(s) :   RE1={0} (C=0)
    Utilise   :   Rien
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08UAdd:
    Fonction  :   Addition non signee de deux nombres de 08 bits
    Entree(s) :   Donnees dans RE1 et RE2
    Sortie(s) :   RE1=RE1+RE2 (RE2 inchange)
                  C=1 si debordement (RE1+RE2>ffh), C=0 sinon
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08USub:
    Fonction  :   Soustraction non signee de deux nombres de 08 bits
    Entree(s) :   Donnees dans RE1 et RE2
    Sortie(s) :   RE1=RE1-RE2 (RE2 inchange)
                  C=1 si debordement (RE1<RE2), C=0 sinon
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08UMul:
    Fonction  :   Multiplication non signee de deux nombres de 08 bits
    Entree(s) :   Donnees dans RE1 et RE2
    Sortie(s) :   RE1=RE1*RE2 (RE2 inchange)
                  C=1 si debordement (RE1*RE2>ffh), C=0 sinon
    Utilise   :   Registres A, PSW et B non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08UDiv:
    Fonction  :   Division non signee de deux nombres de 16 bits
    Entree(s) :   Donnees dans RE1 (numerateur) et RE2 (denominateur)
    Sortie(s) :   RE1=RE1/RE2 et RE2=RE1%RE2
                  C=1 si erreur (denominateur=0 et dans ce cas RE1=ffh), C=0 sinon
    Utilise   :   Registres A, PSW et B non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ShLeRE1:
    Fonction  :   Decalage a gauche de l'operande/resultat RE1
    Entree(s) :   Donnee dans RE1, nombre de decalages dans A
    Sortie(s) :   RE1=RE1<<A (decalage a gauche non signe)
                  Avec C=0 meme si debordement, A perdu
    Utilise   :   Registres A,B et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ShLeRE2:
    Fonction  :   Decalage a gauche de l'operande/resultat RE2
    Entree(s) :   Donnee dans RE2, nombre de decalages dans A
    Sortie(s) :   RE2=RE2<<A (decalage a gauche non signe)
                  Avec C=0 meme si debordement, A perdu
    Utilise   :   Registres A,B et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ShRiRE1:
    Fonction  :   Decalage a droite de l'operande/resultat RE1
    Entree(s) :   Donnee dans RE1, nombre de decalages dans A
    Sortie(s) :   RE1=RE1>>A (decalage a gauche non signe)
                  Avec C=0 meme si debordement, A perdu
    Utilise   :   Registres A,B et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08ShRiRE2:
    Fonction  :   Decalage a droite de l'operande/resultat RE2
    Entree(s) :   Donnee dans RE2, nombre de decalages dans A
    Sortie(s) :   RE2=RE2>>A (decalage a gauche non signe)
                  Avec C=0 meme si debordement, A perdu
    Utilise   :   Registres A,B et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08NegRE1:
    Fonction  :   Changement de signe de l'operande/resultat RE1
    Entree(s) :   Donnee dans RE1
    Sortie(s) :   RE1=-RE1
                  Avec C=1 si debordement (si RE1=80h=-128) et C=0 sinon
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08SgnRE1:
    Fonction  :   Recuperation du signe de l'operande/resultat RE1
    Entree(s) :   Donnee dans RE1
    Sortie(s) :   C=0 si le nombre est positif ou nul
                  C=1 si le nombre est negatif
                  RE1 reste inchange
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08AbsRE1:
    Fonction  :   Valeur absolue de l'operande/resultat RE1
    Entree(s) :   Donnee dans RE1
    Sortie(s) :   RE1=ABS(RE1)
                  C=1 si debordement en codage signe (RE1=80h=-128)
                  C=0 si nombre compatible d'un codage signe
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   4 avec l'appel
    Cycles    :   ?

I08Add:
    Fonction  :   Addition signee de deux nombres de 08 bits
    Entree(s) :   Donnees dans RE1 et RE2
    Sortie(s) :   RE1=RE1+RE2 (RE2 inchange)
                  C=1 si debordement (RE1+RE2>7fh ou <80h), C=0 sinon
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08Sub:
    Fonction  :   Soustraction signee de deux nombres de 08 bits
    Entree(s) :   Donnees dans RE1 et RE2
    Sortie(s) :   RE1=RE1-RE2 (RE2 inchange)
                  C=1 si debordement (RE1-RE2>7fh ou <80h), C=0 sinon
    Utilise   :   Registres A et PSW non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08Mul:
    Fonction  :   Multiplication signee de deux nombres de 08 bits
    Entree(s) :   Donnees dans RE1 et RE2
    Sortie(s) :   RE1=RE1*RE2 (RE2 inchange)
                  C=1 si debordement (RE1*RE2>7fh ou <80h), C=0 sinon
    Utilise   :   Registres A, PSW et B non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?

I08Div:
    Fonction  :   Division signee de deux nombres de 08 bits
    Entree(s) :   Donnees dans RE1 (numerateur) et RE2 (denominateur)
    Sortie(s) :   RE1=RE1/RE2 et RE2=RE1%RE2
                  C=1 si erreur : - denominateur=0 et dans ce cas RE1=7fh ou 80h
                                    selon le signe de RE10)
                                  - debordement du quotien en signe (+128)
                  C=0 si pas d'erreur
    Utilise   :   Registres A, PSW et B non sauvegardes
    Pile      :   2 avec l'appel
    Cycles    :   ?
