Progettino f# aggiornato pomeriggio

type indirizzo = {indirizzo: int; valore: float};;
type registro = {nome_reg: string; valore: float};;
type istruzione ={nome_istr: string;
                  arg1_reg: registro;
                  arg1_mem: indirizzo;
                  arg2_reg: registro;
                  arg2_mem: indirizzo;
                  arg2_float: float}

(* la funzione che divide l'elemento della lista di input in una lista di stringhe
e una funzione che legge dalla memoria
oppure scrive nella memoria e una funzione che scrive nel registro
e legge dal registro una funzione che individua che funzione deve essere eseguita
, una funzione che analizza gli argomenti della funzione ( se memoria registro oppure costante )
il resto sono le funzioni da eseguire con scrivi registro / memoria oppure leggi memoria / registro*)

//istruzioni per il caricamento dell'istruzione



int('a');;//97
int('z');;//122
int('A');;//65
int('Z');;//90
int(' ');;//32
int('1');;//49
int('9');;//57
int('0');;//48

//rimuovere dalla lista tutti i caratteri a parte lettere/numeri e spazi
let rec rmv_interpunzione (lst: char list) : char list = match lst with
    []->[]
    |x::xs->if(x>='a' && x<='z')||(x>='A' && x<='Z')||(x>='0' && x<='9')||x=' '||x='['||x=']' then x::rmv_interpunzione(xs) else rmv_interpunzione(xs);;

let test_string = "Ciao, mi; chiamo: Riccardo 1985";;
let list_from_string = string_to_list test_string;;
let test_rmv_int = rmv_interpunzione list_from_string;;

//dividere lista dell'istruzione con split
let position (lst, item) =
    let rec aux (n, list) = match (n, list) with
        (_,[])-> -1
        |(n, x::xs)->if x = item then n else aux(n+1, xs)
    in aux (0, lst);;

let rec take n lst = match (n, lst) with
    (0,_)->[]
    |(_,[])->[]
    |(n,x::xs)->x::(take (n-1) xs);;

let rec diff lst1 lst2= match (lst1,lst2) with
    [],[]->[]
    |xs,[]->[]
    |[],ys->ys
    |x::xs,y::ys->if x=y then diff xs ys else y::diff xs ys;;

let rmv_split (item: char) (lst: char list): char list =
    match (item, lst) with
    (x,[])->[]
    |(x,y::ys) when position(y::ys, x) = -1->y::ys
    |(x, y::ys) when position(y::ys, x) <> -1-> diff (take (position(y::ys,x)+1) (y::ys)) (y::ys);;

let rec split (x : char) (xs : char list) : char list list = match (x, xs) with
    (x,[])->[]
    |(x, y::ys) when position(y::ys, x) = -1->[y::ys]
    |(x, y::ys) when position(y::ys, x) <> -1-> let aux = (take (position(y::ys,x)) (y::ys))
                                                in [aux]@split x (rmv_split x (y::ys));;

//dividere la lista di stringhe

let test_string = "Ciao, mi; chiamo: Riccardo 1985";;

// lista di stringhe che compone un programma
let string_list_program =   ["MOV [0] 0"; "MOV [1] 1"; "MOV [2] 0"; "MOV [3] 0"; "MOV [4] 1";
   "MOV [10] 1"; "MOV [11] 1"; "MOV [12] 0"; "MOV [13] 0"; "MOV [14] 0";
   "MOV REG1 [4]"; "MOV REG2 [14]"; "NOT REG3 REG1"; "NOT REG4 REG2";
   "AND REG1 REG4"; "AND REG2 REG3"; "OR REG1 REG2"; "MOV [24] REG1";
   "MOV REG1 [3]"; "MOV REG2 [13]"; "NOT REG3 REG1"; "NOT REG4 REG2";
   "AND REG1 REG4"; "AND REG2 REG3"; "OR REG1 REG2"; "MOV [23] REG1";
   "MOV REG1 [2]"; "MOV REG2 [12]"; "NOT REG3 REG1"; "NOT REG4 REG2";
   "AND REG1 REG4"; "AND REG2 REG3"; "OR REG1 REG2"; "MOV [22] REG1";
   "MOV REG1 [1]"; "MOV REG2 [11]"; "NOT REG3 REG1"; "NOT REG4 REG2";
   "AND REG1 REG4"; "AND REG2 REG3"; "OR REG1 REG2"; "MOV [21] REG1";
   "MOV REG1 [0]"; "MOV REG2 [10]"; "NOT REG3 REG1"; "NOT REG4 REG2";
   "AND REG1 REG4"; "AND REG2 REG3"; "OR REG1 REG2"; "MOV [20] REG1"; "END"];;

//da stringa a lista
let string_to_list (s : string) = s.ToCharArray() |> Array.toList;;

//dividere le istruzioni (ogni stringa è un istruzione)
//trasformo la lista di stringhe in una lista di liste di caratteri
let rec dividi_istruzione (lst: string list) : char list list =
    match lst with
    []->[]
    |x::xs->[string_to_list(x)]@dividi_istruzione xs;;
let test_dividi_istr = dividi_istruzione string_list_program;;

//pulisco la lista da eventuali caratteri non consentiti
let rec rmv_interpunzione (lst: char list) : char list = match lst with
    []->[]
    |x::xs->if(x>='a' && x<='z')||(x>='A' && x<='Z')||(x>='0' && x<='9')||x=' '||x='['||x=']' then x::rmv_interpunzione(xs) else rmv_interpunzione(xs);;

let rec pulisci_istruzioni (lst: char list list): char list list =
    match lst with
    []->[]
    |x::xs->rmv_interpunzione(x)::pulisci_istruzioni xs;;

let test_pulisci = pulisci_istruzioni test_dividi_istr;;
//ora posso dividere ogni lista di caratteri in sottoliste che saranno la mia istruzione e i miei argomenti
//divido gli argomenti di ogni lista, rimuovendo gli spazi in sottoliste
let rec list_to_string (l : char list) =
  match l with
  | [] -> ""
  | c :: cs -> (string c) + (list_to_string cs);;

let rec dividi_argomenti (lst: char list list) : string list list =
    match lst with
    []->[]
    |x::xs->(split ' ' x)::dividi_argomenti(xs);;


let test_div_arg = dividi_argomenti test_pulisci;;

let test_instruction = [['M'; 'O'; 'V']; ['['; '0'; ']']; ['0']];;

let rec confronta_lst (lst1: char list) (lst2: char list) : bool =
    match (lst1, lst2) with
    ([],[])->true
    |([x],[y])->if x = y then true else false
    |([],_)->false
    |(_,[])->false
    |(x::xs,y::ys)->if x=y then true && confronta_lst xs, ys else false;;

let test_lst_1= ['M'; 'O'; 'V'];;
let test_lst_2= ['['; '0'; ']'];;
let test_confronta = confronta_lst test_lst_1 test_lst_2;;

//interpretare una istruzione
let rec istruzione_stringa (istruzione: char list list) : string list =
    match istruzione with
    []->[]
    |x::xs->(list_to_string x)::istruzione_stringa(xs);;

let rec nth lst k = match (lst, k) with
    (x::xs, 0)->x
    |(x::xs, k)->(nth xs k-1);;

let interpreta_istruzione (istruzione: char list list) : istruzione =
    if confronta_lst(nth(test_instruction),test_lst_1) = true then

//non so se serva il controllo, adesso devo capire come si mettono i vari valori nel record, li scelgo con nth e poi li devo associare ai vari campi presumo



//dividere ogni istruzione in nome istruzione, argomento1, argomento2