nanvm_lib/parser/
root_state.rs

1use super::{
2    any_state::AnyState, const_state::ConstState, json_state::JsonState, shared::ParseError,
3};
4use crate::{mem::manager::Manager, tokenizer::JsonToken};
5
6#[derive(Debug)]
7pub enum RootStatus {
8    Initial,
9    Export,
10    Module,
11    ModuleDot,
12    ModuleDotExports,
13    Const,
14    ConstId(String),
15    Import,
16    ImportId(String),
17    ImportIdFrom(String),
18}
19
20pub struct RootState<M: Manager> {
21    pub status: RootStatus,
22    pub state: AnyState<M>,
23    pub new_line: bool,
24}
25
26impl<M: Manager> RootState<M> {
27    pub fn parse(
28        self,
29        manager: M,
30        token: JsonToken<M::Dealloc>,
31    ) -> (
32        /*json_state:*/ JsonState<M>,
33        /*import:*/ Option<(/*id:*/ String, /*module:*/ String)>,
34    ) {
35        match self.status {
36            RootStatus::Initial => match token {
37                JsonToken::NewLine => (
38                    JsonState::ParseRoot(RootState {
39                        new_line: true,
40                        ..self
41                    }),
42                    None,
43                ),
44                JsonToken::Id(s) => match self.new_line {
45                    true => match s.as_ref() {
46                        "const" => (
47                            JsonState::ParseRoot(RootState {
48                                status: RootStatus::Const,
49                                state: self.state.set_djs(),
50                                new_line: false,
51                            }),
52                            None,
53                        ),
54                        "export" if self.state.data_type.is_mjs_compatible() => (
55                            JsonState::ParseRoot(RootState {
56                                status: RootStatus::Export,
57                                state: self.state.set_mjs(),
58                                new_line: false,
59                            }),
60                            None,
61                        ),
62                        "module" if self.state.data_type.is_cjs_compatible() => (
63                            JsonState::ParseRoot(RootState {
64                                status: RootStatus::Module,
65                                state: self.state.set_cjs(),
66                                new_line: false,
67                            }),
68                            None,
69                        ),
70                        "import" if self.state.data_type.is_mjs_compatible() => (
71                            JsonState::ParseRoot(RootState {
72                                status: RootStatus::Import,
73                                state: self.state.set_mjs(),
74                                new_line: false,
75                            }),
76                            None,
77                        ),
78                        _ => {
79                            let (json_state, _module_name) =
80                                self.state.parse_for_module(manager, JsonToken::Id(s));
81                            // TODO: figure out id and use _module_name, passing Some in place of None below.
82                            (json_state, None)
83                        }
84                    },
85                    false => (JsonState::Error(ParseError::NewLineExpected), None),
86                },
87                _ => match self.new_line {
88                    true => {
89                        let (json_state, _module_name) =
90                            self.state.parse_for_module(manager, token);
91                        // TODO: figure out id and use _module_name, passing Some in place of None below.
92                        (json_state, None)
93                    }
94                    false => (JsonState::Error(ParseError::NewLineExpected), None),
95                },
96            },
97            RootStatus::Export => match token {
98                JsonToken::Id(s) => match s.as_ref() {
99                    "default" => (JsonState::ParseModule(self.state), None),
100                    _ => (JsonState::Error(ParseError::WrongExportStatement), None),
101                },
102                _ => (JsonState::Error(ParseError::WrongExportStatement), None),
103            },
104            RootStatus::Module => match token {
105                JsonToken::Dot => (
106                    JsonState::ParseRoot(RootState {
107                        status: RootStatus::ModuleDot,
108                        state: self.state,
109                        new_line: false,
110                    }),
111                    None,
112                ),
113                _ => (JsonState::Error(ParseError::WrongExportStatement), None),
114            },
115            RootStatus::ModuleDot => match token {
116                JsonToken::Id(s) => match s.as_ref() {
117                    "exports" => (
118                        JsonState::ParseRoot(RootState {
119                            status: RootStatus::ModuleDotExports,
120                            state: self.state,
121                            new_line: false,
122                        }),
123                        None,
124                    ),
125                    _ => (JsonState::Error(ParseError::WrongExportStatement), None),
126                },
127                _ => (JsonState::Error(ParseError::WrongExportStatement), None),
128            },
129            RootStatus::ModuleDotExports => match token {
130                JsonToken::Equals => (JsonState::ParseModule(self.state), None),
131                _ => (JsonState::Error(ParseError::WrongExportStatement), None),
132            },
133            RootStatus::Const => match token {
134                JsonToken::Id(s) => (
135                    JsonState::ParseRoot(RootState {
136                        status: RootStatus::ConstId(s),
137                        state: self.state,
138                        new_line: false,
139                    }),
140                    None,
141                ),
142                _ => (JsonState::Error(ParseError::WrongConstStatement), None),
143            },
144            RootStatus::ConstId(s) => match token {
145                JsonToken::Equals => (
146                    JsonState::ParseConst(ConstState {
147                        key: s,
148                        state: self.state,
149                    }),
150                    None,
151                ),
152                _ => (JsonState::Error(ParseError::WrongConstStatement), None),
153            },
154            RootStatus::Import => match token {
155                JsonToken::Id(s) => (
156                    JsonState::ParseRoot(RootState {
157                        status: RootStatus::ImportId(s),
158                        state: self.state,
159                        new_line: false,
160                    }),
161                    None,
162                ),
163                _ => (JsonState::Error(ParseError::WrongImportStatement), None),
164            },
165            RootStatus::ImportId(id) => match token {
166                JsonToken::Id(s) => match s.as_ref() {
167                    "from" => (
168                        JsonState::ParseRoot(RootState {
169                            status: RootStatus::ImportIdFrom(id),
170                            state: self.state,
171                            new_line: false,
172                        }),
173                        None,
174                    ),
175                    _ => (JsonState::Error(ParseError::WrongImportStatement), None),
176                },
177                _ => (JsonState::Error(ParseError::WrongImportStatement), None),
178            },
179            RootStatus::ImportIdFrom(id) => match token {
180                JsonToken::String(module) => (
181                    JsonState::ParseRoot(RootState {
182                        status: RootStatus::Initial,
183                        new_line: false,
184                        ..self
185                    }),
186                    Some((id, module)),
187                ),
188                _ => (JsonState::Error(ParseError::WrongImportStatement), None),
189            },
190        }
191    }
192}
nanvm_lib/parser/root_state.rs

nanvm_lib/parser/
root_state.rs
