1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use std::ops::{RangeInclusive, Range};

use serde::{Serialize, Deserialize};
use shm_rs::Lexer;
use shm_rs::lexer::lexer;
use shm_rs::scheme_composer::composer::from_struct;
use shm_rs::serializator::serializator;
use shm_rs::static_scheme::generator::RustCode;
use shm_rs::static_scheme::init;
use shm_rs::dynamic_scheme::environment;


#[derive(Serialize, Deserialize)]
enum MyEnum
{
    Item1,
    Item2
}

#[allow(non_camel_case_types)]
#[derive(Serialize, Deserialize)]
enum OurEnum
{
    H_item1,
    Item2,
    C_item
}

#[derive(Serialize, Deserialize)]
struct CommonLevels
{
    enum1: MyEnum,
    enum2: OurEnum
}


pub fn main()
{
    let mut curdir = std::env::current_dir().unwrap(); 
    curdir.push("examples/struct_to_scheme/enum_arg/init_enum.shm");
    println!("{}", curdir.display());

    let lex = lexer::Lexer::from_file(curdir).unwrap();
    let schm = init::SchemeInit::new().unwrap();

    let res = schm.run(&lex, None).unwrap();

    let resser = res.get("test1").unwrap().clone();

    println!("Static: \n{:?}\n", res);


    let mut curdir = std::env::current_dir().unwrap();
    curdir.push("examples/struct_to_scheme/enum_arg/enum.shm");

    let lex = lexer::Lexer::from_file(curdir).unwrap();

    let dynenv = environment::DynEnvironment::new_root(resser.clone());

    let dynres = environment::DynEnvironment::run(&lex, dynenv).unwrap();

    let ret = serializator::Serialization::serialize(resser.clone(), dynres.clone()).unwrap();

    let serialized = serde_json::to_string(&ret).unwrap();


    let n: CommonLevels = serde_json::from_str(&serialized).unwrap();

    let scmp = from_struct(n, resser.clone());
    
    if scmp.is_err() == true
    {
        panic!("{}", scmp.err().unwrap());
    }
    else
    {
        let out_res = scmp.unwrap();
        println!("{}", out_res);

        let lex_out = Lexer::from_str(&out_res.to_string(), "test").unwrap();

        let dyn_root = environment::DynEnvironment::new_root(resser.clone());

        let dyn_res =
            environment::DynEnvironment::run(&lex_out, dyn_root);

        if dyn_res.is_err() == true
        {
            println!("{}", dyn_res.err().unwrap());
        }
    }
}