hello world!

codifica_istruzioni.h

@@ -1,5 +1,5 @@
 #include "elea_tipi.h"
-#include "conf_caratteri.h"
+#include "caratteri.h"
 
 
 /*

elea.c

@@ -1,5 +1,43 @@
+#include "elea_tipi.h"
+#include "caratteri.h"
+#include "telescrivente.h"
+#include "memoria.h"
+#include "codifica_istruzioni.h"
+
 /* main */
 int main(int argc, char *argv[])
 {
+    istruzione istr;
+    /* TEST: memoria / phi */
+
+    /* Riempie la memoria 1:11 con "HELLO.WORLD" */
+    mem_scrivi_carattere(1,CAR_H);
+    mem_scrivi_carattere(2,CAR_E);
+    mem_scrivi_carattere(3,CAR_L);
+    mem_scrivi_carattere(4,CAR_L);
+    mem_scrivi_carattere(5,CAR_O);
+    mem_scrivi_carattere(6,CAR_PUNTO);
+    mem_scrivi_carattere(7,CAR_W);
+    mem_scrivi_carattere(8,CAR_O);
+    mem_scrivi_carattere(9,CAR_R);
+    mem_scrivi_carattere(10,CAR_L);
+    mem_scrivi_carattere(11,CAR_D);
+
+    /* Costruisce una istruzione MS artificiale con indirizzo 0001 e lunghezza 11
+     * per stampare il testo sulla telescrivente
+    */
+    istr.gen.F = OP_MS;
+
+    istr.gen.I[0] = CAR_UNO;
+    istr.gen.I[1] = CAR_ZERO;
+    istr.gen.I[2] = CAR_ZERO;
+    istr.gen.I[3] = CAR_ZERO;
+
+    istr.gen.L[0] = CAR_UNO;
+    istr.gen.L[1] = CAR_UNO;
+    istr.gen.Tm = CAR_DIESIS;
+
+    /* Esegue l'istruzione phi */
+    op_ms(&istr);
     return 0;
 }

governo.h

@@ -2,6 +2,7 @@
 #define GOVERNO_INCLUSO
 
 #include "elea_tipi.h"
+#include "caratteri.h"
 
 struct registri_sistema {
     istruzione *I; /* Indirizzo istruzione primo programma */
@@ -20,6 +21,97 @@ extern struct registri_sistema R; /* Globale, definito in governo.c */
 
 typedef int(operazione)(istruzione *I);
 
+static int estrai_cifra(carattere c)
+{
+    /* c e` compresa tra ZERO e NOVE */
+    switch(c & 0x3F) {
+        case CAR_ZERO:
+            return 0;
+        case CAR_UNO:
+            return 1;
+        case CAR_DUE:
+            return 2;
+        case CAR_TRE:
+            return 3;
+        case CAR_QUATTRO:
+            return 4;
+        case CAR_CINQUE:
+            return 5;
+        case CAR_SEI:
+            return 6;
+        case CAR_SETTE:
+            return 7;
+        case CAR_OTTO:
+            return 8;
+        case CAR_NOVE:
+            return 9;
+        default:
+            return -1; /* Errore */
+    }
+}
+
+static uint32_t estrai_indirizzo(carattere *ind)
+{
+    uint32_t val = 0;
+    int r;
+    int gruppo_c, gruppo_m;
+    /* ind. e` un array di 4 caratteri, 0 e 1 sono unita` e decine */
+
+    /* unita` */
+    r = estrai_cifra(ind[0]);
+    if (r < 0)
+        return (uint32_t)-1; /* Errore */
+    val += r;
+
+    /* decine */
+    r = estrai_cifra(ind[1]);
+    if (r < 0)
+        return (uint32_t)-1; /* Errore */
+    val += 10 * r;
+
+    gruppo_c = (ind[2] & 0x30) >> 4;
+    /* Il gruppo delle centinaia condiziona incrementi di 40K */
+    switch (gruppo_c) {
+        case 0:
+            break;
+        case 1:
+            val += 40000;
+            break;
+        case 3:
+            val += 80000;
+            break;
+        case 2:
+            val += 120000;
+    }
+    gruppo_m = (ind[3] & 0x30) >> 4;
+    /* il gruppo delle migliaia condiziona incrementi di 10K */
+    switch (gruppo_m) {
+        case 0:
+            break;
+        case 1:
+            val += 10000;
+            break;
+        case 3:
+            val += 20000;
+            break;
+        case 2:
+            val += 30000;
+    }
+
+    r = estrai_cifra(ind[2] & 0x0f);
+    if (r < 0)
+        return (uint32_t)-1; /* Errore */
+    val += r * 100;
+
+    r = estrai_cifra(ind[3] & 0x0f);
+    if (r < 0)
+        return (uint32_t)-1; /* Errore */
+
+    val += r * 1000;
+
+    return val;
+}
+
 void esegui_primo_programma(void);
 
 #endif

memoria.c

@@ -1,5 +1,9 @@
 #include "elea_tipi.h"
 
+#define L_MEMORIA (160000)
+
+static carattere M[L_MEMORIA];
+
 int op_mem(istruzione *i)
 {
     return 0;
@@ -25,3 +29,13 @@ int op_meno_mm(istruzione *i)
     return 0;
 }
 
+carattere mem_leggi_carattere(uint32_t ind)
+{
+    return M[ind];
+
+}
+
+void mem_scrivi_carattere(uint32_t ind, carattere c)
+{
+    M[ind] = c;
+}

memoria.h

@@ -6,4 +6,9 @@ int op_piu_mm(istruzione *i);
 int op_cmm(istruzione *i);
 int op_pum(istruzione *i);
 int op_meno_mm(istruzione *i);
+
+/* Accesso diretto alla memoria */
+carattere mem_leggi_carattere(uint32_t ind);
+void mem_scrivi_carattere(uint32_t ind, carattere c);
+
 #endif

telescrivente.c

@@ -1,4 +1,14 @@
+#include <stdio.h>
 #include "elea_tipi.h"
+#include "governo.h"
+#include "memoria.h"
+
+static const carattere mappa_caratteri[64][3] = {
+    "0", "1", "~", "2", "4", "+", "#", "3", "5", "6", "/", "7",  "9",  "-",  "÷", "8",
+    "Φ", "A", "δ", "B", "D", "=", "α", "C", "E", "F", "%", "G",  "I",  ",",  "γ", "H",
+    ".", "S", "θ", "T", "V", "!", ")", "U", "W", "X", "?", "Y",  "\'", "&", "⊗", "Z",
+    "ε", "J", "*", "K", "M", "(", "β", "L", "N", "O", "$", "η",  "R",  "P", "π", "Q"
+};
 
 int op_cm(istruzione *i)
 {
@@ -7,6 +17,30 @@ int op_cm(istruzione *i)
 
 int op_ms(istruzione *i)
 {
+    struct istruzione_gen *ms = &i->gen;
+    uint32_t ind;
+    int len;
+    int j;
+    int r;
+    carattere c, *stampabile;
+
+    r = estrai_cifra(ms->L[0]);
+    if (r < 0)
+        return -1; /* Errore */
+    len = r;
+    r = estrai_cifra(ms->L[1]);
+    if (r < 0)
+        return -1; /* Errore */
+    len += 10 * r;
+    len = estrai_cifra(ms->L[0]) + 10 * estrai_cifra(ms->L[1]);
+    ind = estrai_indirizzo(ms->I);
+    if (ind == (uint32_t)(-1))
+        return -1; /* Errore */
+    for (j = 0; j < len; j++) {
+        c = mem_leggi_carattere(ind + j);
+        printf("%s", mappa_caratteri[c]);
+    } 
+    printf("\r\n");
     return 0;
 }