From ca2bdec5d4a240d431c2f1ecca29b64c8e6956d0 Mon Sep 17 00:00:00 2001 From: Daniele Lacamera Date: Tue, 24 Dec 2019 01:26:09 +0100 Subject: [PATCH] hello world! --- conf_caratteri.h => caratteri.h | 0 codifica_istruzioni.h | 2 +- elea.c | 38 ++++++++++++++ governo.h | 92 +++++++++++++++++++++++++++++++++ memoria.c | 14 +++++ memoria.h | 5 ++ telescrivente.c | 34 ++++++++++++ 7 files changed, 184 insertions(+), 1 deletion(-) rename conf_caratteri.h => caratteri.h (100%) diff --git a/conf_caratteri.h b/caratteri.h similarity index 100% rename from conf_caratteri.h rename to caratteri.h diff --git a/codifica_istruzioni.h b/codifica_istruzioni.h index b85163f..124cb7b 100644 --- a/codifica_istruzioni.h +++ b/codifica_istruzioni.h @@ -1,5 +1,5 @@ #include "elea_tipi.h" -#include "conf_caratteri.h" +#include "caratteri.h" /* diff --git a/elea.c b/elea.c index b8d19d4..66a7428 100644 --- a/elea.c +++ b/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; } diff --git a/governo.h b/governo.h index c8fb1eb..cfa7729 100644 --- a/governo.h +++ b/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 diff --git a/memoria.c b/memoria.c index 1f2af91..c4c2c2b 100644 --- a/memoria.c +++ b/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; +} diff --git a/memoria.h b/memoria.h index 9c243af..69f150e 100644 --- a/memoria.h +++ b/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 diff --git a/telescrivente.c b/telescrivente.c index d401072..2484af7 100644 --- a/telescrivente.c +++ b/telescrivente.c @@ -1,4 +1,14 @@ +#include #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; }