Aggiunte alcune istruzioni al modulo accumulatore

accumulatore.c

@@ -1,47 +1,23 @@
 #include "elea_tipi.h"
 #include "governo.h"
+#include "memoria.h"
 
 static carattere Accumulatore[100];
 static segno REG_SEGNO_A = 0;
 
-/* Da accumulatore a memoria */
-int AoM(carattere *mem, int lun)
-{
-    int i;
-    int pos;
-    for (i = 0; i < lun; i++) {
-        pos = (R.P + lun - (i + 1));
-        mem[i] = (Accumulatore[pos] & 0x7F);
-        Accumulatore[pos] = 0x80;
-    } 
-    return 0;
-}
-
-/* Da memoria a accumulatore */
-int MA(const carattere *mem, int lun)
-{
-    int i;
-    int pos;
-    
-    for (i = 0; i < lun; i++) {
-        pos = (lun - (i + 1));
-        Accumulatore[R.P + i] = (mem[pos] & 0x7F);
-        Accumulatore[R.P + i] &= ~0x80;
-    }
-    /* accende gA nell'ultimo carattere */
-    Accumulatore[R.P + lun - 1] |= 0x80;
-}
-
-int DA(const int disp)
-{
-    if (disp < 0 || disp > 99)
-        return -1;
-    R.P = disp; 
-    return R.P;
-}
-
 int op_da(istruzione *i)
 {
+    int r;
+    int da;
+    r = estrai_cifra(i->da.I[0]);
+    if (r < 0)
+        return -1;
+    da = r;
+    r = estrai_cifra(i->da.I[1]);
+    if (r < 0)
+        return -1;
+    da += 10 * r;
+    R.P = da; 
     return 0;
 }
 
@@ -52,6 +28,21 @@ int op_fam(istruzione *i)
 
 int op_aom(istruzione *i)
 {
+    int pos;
+    indirizzo mem;
+    int lun;
+    int j;
+    mem = estrai_indirizzo(i->gen.I);
+    if (mem == (uint32_t)(-1))
+        return -1;
+    lun = estrai_lunghezza(i->gen.L);
+
+    for (j = 0; j < lun; j++) {
+        pos = (R.P + lun - (j + 1));
+        mem_scrivi_carattere(mem + j, Accumulatore[pos] & 0x7F);
+        /* Azzeramento */
+        Accumulatore[pos] = 0x80;
+    } 
     return 0;
 }
 int op_piu_ma(istruzione *i)
@@ -64,8 +55,31 @@ int op_cma(istruzione *i)
     return 0;
 }
 
+/* Da memoria a accumulatore */
 int op_ma(istruzione *i)
 {
+    int j;
+    int pos;
+    int lun;
+    int r;
+    indirizzo mem;
+
+    mem = estrai_indirizzo(i->gen.I);
+    if (mem == (uint32_t)(-1))
+        return -1;
+    
+    lun = estrai_lunghezza(i->gen.L);
+    if (lun < 0)
+        return -1;
+    for (j = 0; j < lun; j++) {
+        carattere c;
+        pos = (lun - (j + 1));
+        c = mem_leggi_carattere(mem);
+        Accumulatore[R.P + j] = c & 0x7f;
+        Accumulatore[R.P + j] &= ~0x80;
+    }
+    /* accende gA nell'ultimo carattere */
+    Accumulatore[R.P + lun - j] |= 0x80;
     return 0;
 }
 

elea_tipi.h

@@ -7,20 +7,17 @@
 typedef uint8_t carattere;
 typedef int8_t segno;
 typedef uint8_t booleano;
+typedef uint32_t indirizzo;
 #define SI (1)
 #define NO (0)
 
 
-
 /* bit gA: valido solo se il carattere e` letto da Accumulatore.
  * Nelle operazioni aritmetiche le cifre che lo seguono sono zeri
  * Nei trasferisferimento a mem principale il bit e` ignorato i
  */
 #define gA(x) ((x >> 7) & 0x01)
 
-typedef carattere * indirizzo;
-
-
 
 struct __attribute__((packed)) istruzione_gen {
     carattere F;    /* Tipo di funzione */
@@ -60,12 +57,20 @@ struct __attribute__((packed)) istruzione_n {
     carattere X;     /* Non utilizzato */
 };
 
+struct __attribute__((packed)) istruzione_da {
+    carattere F;     /* Tipo di funzione */
+    carattere Tm;    /* Modificatore */
+    carattere I[2];  /* Indirizzo interno dell'accumulatore */
+    carattere X[4];  /* Non utilizzato */ 
+};
+
 typedef union u_istruzione {
     struct istruzione_gen gen;
     struct istruzione_t   t;
     struct istruzione_c   c;
     struct istruzione_s   s;
     struct istruzione_n   n;
+    struct istruzione_da  da;
 } istruzione;
 
 #endif /* ELEA_TIPI_INCLUSO */

governo.h

@@ -50,9 +50,28 @@ static int estrai_cifra(carattere c)
     }
 }
 
-static uint32_t estrai_indirizzo(carattere *ind)
+static int estrai_lunghezza(carattere *ind)
 {
-    uint32_t val = 0;
+    uint32_t lun = 0;
+    int r;
+    /* ind. e` un array di 2 caratteri, 0 e 1 sono unita` e decine */
+    /* unita` */
+    r = estrai_cifra(ind[0]);
+    if (r < 0)
+        return (uint32_t)-1; /* Errore */
+    lun += r;
+
+    /* decine */
+    r = estrai_cifra(ind[1]);
+    if (r < 0)
+        return (uint32_t)-1; /* Errore */
+    lun += 10 * r;
+    return lun;
+}
+
+static indirizzo estrai_indirizzo(carattere *ind)
+{
+    indirizzo val = 0;
     int r;
     int gruppo_c, gruppo_m;
     /* ind. e` un array di 4 caratteri, 0 e 1 sono unita` e decine */
@@ -106,9 +125,7 @@ static uint32_t estrai_indirizzo(carattere *ind)
     r = estrai_cifra(ind[3] & 0x0f);
     if (r < 0)
         return (uint32_t)-1; /* Errore */
-
     val += r * 1000;
-
     return val;
 }
 

memoria.c

@@ -32,7 +32,6 @@ int op_meno_mm(istruzione *i)
 carattere mem_leggi_carattere(uint32_t ind)
 {
     return M[ind];
-
 }
 
 void mem_scrivi_carattere(uint32_t ind, carattere c)

telescrivente.c

@@ -18,7 +18,7 @@ int op_cm(istruzione *i)
 int op_ms(istruzione *i)
 {
     struct istruzione_gen *ms = &i->gen;
-    uint32_t ind;
+    indirizzo ind;
     int len;
     int j;
     int r;
@@ -33,10 +33,10 @@ int op_ms(istruzione *i)
         return -1; /* Errore */
     len += 10 * r;
     ind = estrai_indirizzo(ms->I);
-    if (ind == (uint32_t)(-1))
+    if (ind == (indirizzo)(-1))
         return -1; /* Errore */
     for (j = 0; j < len; j++) {
-        c = mem_leggi_carattere(ind + j);
+        c = mem_leggi_carattere((uint32_t)(ind + j));
         printf("%s", mappa_caratteri[c]);
     } 
     printf("\r\n");