slj/parser/
izraz.rs

1use super::*;
2
3impl<'a> Parser<'a> {
4    pub fn drevo(&mut self, izraz: &[Token<'a>]) -> Result<Rc<Vozlišče>, Napake> {
5        self.logični(izraz)
6    }
7
8    // logični izrazi (razen negacije, ki je pri osnovnih)
9    fn logični(&mut self, izraz: &[Token<'a>]) -> Result<Rc<Vozlišče>, Napake> {
10        match loči_zadaj(izraz, &["||"]) {
11            Some(Ok((l_izraz, op, d_izraz))) => {
12                let l = self.logični(l_izraz)?;
13                let d = self.logični(d_izraz)?;
14                match (l.tip(), d.tip()) {
15                    (Tip::Bool, Tip::Bool) => Ok(Disjunkcija(l, d).rc()),
16                    _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Neveljavna tipa za operacijo: {} {} {}", l.tip(), op.as_str(), d.tip()))),
17                }
18            },
19            Some(Err(napaka)) => Err(napaka),
20            None => match loči_zadaj(izraz, &["&&"]) {
21                Some(Ok((l_izraz, op, d_izraz))) => {
22                    let l = self.logični(l_izraz)?;
23                    let d = self.logični(d_izraz)?;
24                    match (l.tip(), d.tip()) {
25                        (Tip::Bool, Tip::Bool) => Ok(Konjunkcija(l, d).rc()),
26                        _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Neveljavna tipa za operacijo: {} {} {}", l.tip(), op.as_str(), d.tip()))),
27                    }
28                },
29                Some(Err(napaka)) => Err(napaka),
30                None => self.bitni(izraz),
31            }
32        }
33    }
34
35    // izrazi bitne manipulacije
36    fn bitni(&mut self, izraz: &[Token<'a>]) -> Result<Rc<Vozlišče>, Napake> {
37        match loči_zadaj(izraz, &["|"]) {
38            Some(Ok((l_izraz, op, d_izraz))) => {
39                let l = self.bitni(l_izraz)?;
40                let d = self.bitni(d_izraz)?;
41                match (l.tip(), d.tip()) {
42                    (Tip::Celo, Tip::Celo) => Ok(bitni_op(op.as_str())(l, d).rc()),
43                    _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Neveljavna tipa za operacijo: {} {} {}", l.tip(), op.as_str(), d.tip()))),
44                }
45            },
46            Some(Err(napaka)) => Err(napaka),
47            None => match loči_zadaj(izraz, &["^"]) {
48                Some(Ok((l_izraz, op, d_izraz))) => {
49                    let l = self.bitni(l_izraz)?;
50                    let d = self.bitni(d_izraz)?;
51                    match (l.tip(), d.tip()) {
52                        (Tip::Celo, Tip::Celo) => Ok(bitni_op(op.as_str())(l, d).rc()),
53                        _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Neveljavna tipa za operacijo: {} {} {}", l.tip(), op.as_str(), d.tip()))),
54                    }
55                },
56                Some(Err(napaka)) => Err(napaka),
57                None => match loči_zadaj(izraz, &["&"]) {
58                    Some(Ok((l_izraz, op, d_izraz))) => {
59                        let l = self.bitni(l_izraz)?;
60                        let d = self.bitni(d_izraz)?;
61                        match (l.tip(), d.tip()) {
62                            (Tip::Celo, Tip::Celo) => Ok(bitni_op(op.as_str())(l, d).rc()),
63                            _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Neveljavna tipa za operacijo: {} {} {}", l.tip(), op.as_str(), d.tip()))),
64                        }
65                    },
66                    Some(Err(napaka)) => Err(napaka),
67                    None => match loči_zadaj(izraz, &["<<", ">>"]) {
68                        Some(Ok((l_izraz, op, d_izraz))) => {
69                            let l = self.bitni(l_izraz)?;
70                            let d = self.bitni(d_izraz)?;
71                            match (l.tip(), d.tip()) {
72                                (Tip::Celo, Tip::Celo) => Ok(bitni_op(op.as_str())(l, d).rc()),
73                                _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Neveljavna tipa za operacijo: {} {} {}", l.tip(), op.as_str(), d.tip()))),
74                            }
75                        },
76                        Some(Err(napaka)) => Err(napaka),
77                        None => self.primerjalni(izraz),
78                    }
79                }
80            }
81        }
82    }
83
84    // primerjalni izrazi
85    pub fn primerjalni(&mut self, izraz: &[Token<'a>]) -> Result<Rc<Vozlišče>, Napake> {
86        match loči_zadaj(izraz, PRIMERJALNI_OP.as_slice()) {
87            Some(Ok((l_izraz, op, d_izraz))) => {
88                let l = self.primerjalni(l_izraz)?;
89                let d = self.primerjalni(d_izraz)?;
90                match (l.tip(), d.tip()) {
91                    (Tip::Celo, Tip::Celo) => Ok(primerjalni_op(op.as_str()).unwrap()(Tip::Celo, l, d).rc()),
92                    (Tip::Znak, Tip::Znak) => Ok(primerjalni_op(op.as_str()).unwrap()(Tip::Celo, ZnakVCelo(l).rc(), ZnakVCelo(d).rc()).rc()),
93                    (Tip::Real, Tip::Real) => Ok(primerjalni_op(op.as_str()).unwrap()(Tip::Real, l, d).rc()),
94                    _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Nemogoča operacija: {} {} {}", l.tip(), op.as_str(), d.tip()))),
95                }
96            },
97            Some(Err(napaka)) => Err(napaka),
98            None => self.aditivni(izraz)
99        }
100    }
101
102    // aritmetični izrazi
103
104    fn aditivni(&mut self, izraz: &[Token<'a>]) -> Result<Rc<Vozlišče>, Napake> {
105        match loči_zadaj(izraz, &["+", "-"]) {
106            // "-" kot unarni operator
107            Some(Ok(([], Operator("-", ..), ..))) => self.aritmetični(izraz),
108            Some(Ok((pred @ [.., Operator(..)], minus @ Operator("-", ..), za @ [..]))) =>
109                self.aditivni([pred, [Ločilo("(", 0, 0), *minus].as_slice(), za, [Ločilo(")", 0, 0)].as_slice()].concat().as_slice()),
110
111            // "-" kot binarni operator
112            Some(Ok((l_izraz, op, d_izraz))) => {
113                let l = self.aritmetični(l_izraz)?;
114                let d = self.aritmetični(d_izraz)?;
115                match (l.tip(), d.tip()) {
116                    (Tip::Celo, Tip::Celo) => Ok(aritmetični_op(op.as_str())(Tip::Celo, l, d).rc()),
117                    (Tip::Real, Tip::Real) => Ok(aritmetični_op(op.as_str())(Tip::Real, l, d).rc()),
118                    _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Nemogoča operacija: {} {} {}", l.tip(), op.as_str(), d.tip()))),
119                }
120            },
121            Some(Err(napaka)) => Err(napaka),
122            None => self.aritmetični(izraz),
123        }
124    }
125
126    fn aritmetični(&mut self, izraz: &[Token<'a>]) -> Result<Rc<Vozlišče>, Napake> {
127        match loči_zadaj(izraz, &["*", "/", "%"]) {
128            Some(Ok((l_izraz, op, d_izraz))) => {
129                let l = self.aritmetični(l_izraz)?;
130                let d = self.aritmetični(d_izraz)?;
131                match (l.tip(), d.tip()) {
132                    (Tip::Celo, Tip::Celo) => Ok(aritmetični_op(op.as_str())(Tip::Celo, l, d).rc()),
133                    (Tip::Real, Tip::Real) => Ok(aritmetični_op(op.as_str())(Tip::Real, l, d).rc()),
134                    _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Nemogoča operacija: {} {} {}", l.tip(), op.as_str(), d.tip()))),
135                }
136            },
137            Some(Err(napaka)) => Err(napaka),
138            None => match loči_zadaj(izraz, &["**"]) {
139                Some(Ok((l_izraz, op, d_izraz))) => {
140                    let l = self.aritmetični(l_izraz)?;
141                    let d = self.aritmetični(d_izraz)?;
142                    match (l.tip(), d.tip()) {
143                        (Tip::Celo, Tip::Celo) => Ok(aritmetični_op(op.as_str())(Tip::Celo, l, d).rc()),
144                        (Tip::Real, Tip::Real) => Ok(aritmetični_op(op.as_str())(Tip::Real, l, d).rc()),
145                        _ => Err(Napake::from_zaporedje(&[*op], E5, &format!("Nemogoča operacija: {} {} {}", l.tip(), op.as_str(), d.tip()))),
146                    }
147                },
148                Some(Err(napaka)) => Err(napaka),
149                None => self.osnovni(izraz),
150            }
151        }
152    }
153
154    pub fn osnovni(&mut self, izraz: &[Token<'a>]) -> Result<Rc<Vozlišče>, Napake> {
155        match izraz {
156            // bool
157            [ Literal(L::Bool("resnica", ..)) ] => Ok(Resnica.rc()),
158            [ Literal(L::Bool("laž", ..)) ] => Ok(Laž.rc()),
159            // števila
160            [ Literal(L::Celo(število, ..)) ] => Ok(Vozlišče::Celo(število.replace("_", "").parse().unwrap()).rc()),
161            [ Literal(L::Real(število, ..)) ] => Ok(Vozlišče::Real(število.replace("_", "").parse().unwrap()).rc()),
162            [ Operator("-", ..), Literal(L::Celo(str, ..)) ] => Ok(Vozlišče::Celo(-str.replace("_", "").parse::<i32>().unwrap()).rc()),
163            [ Operator("-", ..), Literal(L::Real(str, ..)) ] => Ok(Vozlišče::Real(-str.replace("_", "").parse::<f32>().unwrap()).rc()),
164            // znak
165            [ Literal(L::Znak(str, ..)) ] => Ok(Vozlišče::Znak(interpoliraj_niz(&str[1..str.len()-1]).chars().nth(0).unwrap()).rc()),
166            // niz
167            [ Literal(L::Niz(niz, ..)) ] => Ok(Vozlišče::Niz(interpoliraj_niz(&niz[1..niz.len()-1])).rc()),
168            // izraz v oklepaju
169            [ Ločilo("(", ..), ostanek @ .., Ločilo(")", ..) ] => self.drevo(ostanek),
170            // funkcija asm(str)
171            [ Ime("asm", ..), Ločilo("(", ..), argumenti @ .., Ločilo(")", ..) ] => self.asm(argumenti),
172            // klic funkcije
173            [ ime @ Ime(..), Ločilo("(", ..), argumenti @ .., Ločilo(")", ..) ] => self.funkcijski_klic(ime, argumenti),
174            // pretvorba tipa 
175            [ izraz @ .., Operator("kot", ..), tip @ Tip(..) ] => self.pretvorba(izraz, tip),
176            // zanikanje
177            [ Operator("!", ..), ostanek @ .. ] => {
178                let drevo = self.drevo(ostanek)?;
179                match drevo.tip() {
180                    Tip::Bool => Ok(Zanikaj(drevo).rc()),
181                    _ => Err(Napake::from_zaporedje(izraz, E9, "Zanikati je mogoče samo Boolove vrednosti"))
182                }
183            },
184            // negacija
185            [ Operator("-", ..), ostanek @ .. ] => {
186                let drevo = self.drevo(ostanek)?;
187                match drevo.tip() {
188                    Tip::Celo => Ok(Odštevanje(Tip::Celo, Celo(0).rc(), drevo).rc()),
189                    Tip::Real => Ok(Odštevanje(Tip::Real, Celo(0).rc(), drevo).rc()),
190                    _ => Err(Napake::from_zaporedje(ostanek, E9, "Izraza ni mogoče negirati"))
191                }
192            },
193            // spremenljivka
194            [ ime @ Ime(..) ] => Ok(self.spremenljivke.get(ime.as_str())
195                                    .ok_or(Napake::from_zaporedje(&[*ime], E2, "Neznana spremenljivka"))?.clone()),
196
197            // referenciraj
198            [ Operator("@", ..), ime @ Ime(..) ] => {
199                let spremenljivka = self.spremenljivke.get(ime.as_str())
200                        .ok_or(Napake::from_zaporedje(&[*ime], E2, "Neznana spremenljivka"))?.clone();
201
202                match spremenljivka.tip() {
203                    Tip::Seznam(..) => Ok(RefSeznama(spremenljivka).rc()),
204                    _ => Ok(Referenca(spremenljivka).rc())
205                }
206            }
207
208            // dereferenciraj
209            deref @ [ ime @ Ime(..), Operator("@", ..) ] => {
210                let referenca = self.spremenljivke.get(ime.as_str())
211                    .ok_or(Napake::from_zaporedje(&[*ime], E2, "Neznana spremenljivka"))?;
212
213                match &**referenca {
214                    Spremenljivka { tip, .. } => match &*tip {
215                        Tip::Referenca(..) => Ok(Dereferenciraj(referenca.clone()).rc()),
216                        _ => Err(Napake::from_zaporedje(deref, E2, "Dereferenciramo lahko samo referenco.")),
217                    },
218                    _ => Err(Napake::from_zaporedje(deref, E2, "Dereferenciramo lahko samo spremenljivko.")),
219                }
220            }
221
222            // indeksiraj
223            [ ime @ Ime(..), Ločilo("[", ..), indeks @ .., Ločilo("]", ..) ] => {
224                let indeks = self.drevo(indeks)?.rc();
225                let spremenljivka = self.spremenljivke.get(ime.as_str())
226                    .ok_or(Napake::from_zaporedje(&[*ime], E2, "Neznana spremenljivka"))?;
227
228                match &**spremenljivka {
229                    Spremenljivka { tip: Tip::Seznam(..), .. } =>
230                        Ok(Indeksiraj{ seznam_ref: RefSeznama(spremenljivka.clone()).rc(), indeks }.rc()),
231                    Spremenljivka { tip: Tip::RefSeznama(..), .. } =>
232                        Ok(Indeksiraj{ seznam_ref: spremenljivka.clone(), indeks }.rc()),
233                    _ => Err(Napake::from_zaporedje(izraz, E2, 
234                            &format!("V spremenljivko tipa '{}' ni mogoče indeksirati.", spremenljivka.tip()))),
235                }
236            }
237
238            [ ime @ Ime(..), Ločilo(".", ..), Ime("dolžina", ..) ] => {
239                let spremenljivka = self.spremenljivke.get(ime.as_str())
240                    .ok_or(Napake::from_zaporedje(&[*ime], E2, "Neznana spremenljivka"))?;
241
242                match spremenljivka.tip() {
243                    Tip::Seznam(..) => Ok(Dolžina(spremenljivka.clone()).rc()),
244                    Tip::RefSeznama(..) => Ok(Dolžina(spremenljivka.clone()).rc()),
245                    _ => Err(Napake::from_zaporedje(&[*ime], E2, 
246                            &format!("Tip '{}' nima dolžine", spremenljivka.tip())))
247                }
248            },
249
250            [ neznano @ Neznano(..) ] => Err(Napake::from_zaporedje(&[*neznano], E1, "Neznana beseda")),
251            [] => Ok(Prazno.rc()),
252            _ => Err(Napake::from_zaporedje(izraz, E1,
253                    &format!("Neznan izraz: {}", izraz.iter().map(|t| t.as_str()).collect::<Vec<&str>>().join(" "))))
254        }
255    }
256
257    fn pretvorba(&mut self, izraz: &[Token<'a>], tip_ven_izraz: &Token) -> Result<Rc<Vozlišče>, Napake> {
258        let drevo = self.drevo(izraz)?.rc();
259        let tip_noter = drevo.tip();
260        let tip_ven = Tip::from(&[*tip_ven_izraz])?;
261
262        match (tip_noter.clone(), tip_ven.clone()) {
263            (Tip::Real, Tip::Celo) => Ok(RealVCelo(drevo).rc()),
264            (Tip::Celo, Tip::Real) => Ok(CeloVReal(drevo).rc()),
265            (Tip::Celo, Tip::Znak) => Ok(CeloVZnak(drevo).rc()),
266            (Tip::Znak, Tip::Celo) => Ok(ZnakVCelo(drevo).rc()),
267            (a, b) if a == b => Ok(drevo),
268            _ => Err(Napake::from_zaporedje(&[*tip_ven_izraz], E1,
269                    &format!("Tipa {} ni mogoče pretvoriti v {}", tip_noter, tip_ven)))
270        }
271    }
272
273    fn asm(&self, izraz: &[Token<'a>]) -> Result<Rc<Vozlišče>, Napake> {
274        let niz = match izraz {
275            [ Literal(L::Niz(niz, ..)) ] => &niz[1..niz.len()-1],
276            _ => Err(Napake::from_zaporedje(izraz, E5, "Funkcija 'asm' sprejema samo nize"))?,
277        };
278
279        match niz {
280            "GETC" => Ok(Preberi.rc()),
281            _ => Err(Napake::from_zaporedje(izraz, E1,
282                    &format!("Neznan ukaz: {niz}")))
283        }
284    }
285}
286
287#[cfg(test)]
288mod testi {
289    use std::rc::Rc;
290
291    use crate::parser::tokenizer::Tokenize;
292
293    use super::*;
294
295    #[test]
296    fn osnovni() {
297        let mut parser = Parser::new();
298        assert_eq!(parser.osnovni([ Literal(L::Bool("resnica", 1, 1))].as_slice()).unwrap(), Resnica.rc());
299        assert_eq!(parser.osnovni([ Literal(L::Bool("laž", 1, 1))].as_slice()).unwrap(), Laž.rc());
300        assert_eq!(parser.osnovni([ Operator("!", 1, 1), Literal(L::Bool("laž", 1, 2))].as_slice()).unwrap(), Zanikaj(Laž.rc()).rc());
301        assert_eq!(parser.osnovni([ Ločilo("(", 1, 1), Literal(L::Bool("laž", 1, 2)), Ločilo(")", 1, 5)].as_slice()).unwrap(), Laž.rc());
302        assert_eq!(parser.osnovni([ Literal(L::Celo("3", 1, 1))].as_slice()).unwrap(), Celo(3).rc());
303        assert_eq!(parser.osnovni([ Literal(L::Real("3.125", 1, 1))].as_slice()).unwrap(), Real(3.125).rc());
304        assert_eq!(parser.osnovni([ Literal(L::Celo("1_000", 1, 1))].as_slice()).unwrap(), Celo(1000).rc());
305        assert_eq!(parser.osnovni([ Literal(L::Znak("'đ'", 1, 1))].as_slice()).unwrap(), Znak('đ').rc());
306        assert_eq!(parser.osnovni([ Literal(L::Niz("\"angleščina\\n\"", 1, 1))].as_slice()).unwrap(), Niz("angleščina\n".to_string()).rc());
307
308        parser.funkcije.insert("fun()".to_string(), Funkcija {
309                tip: Tip::Real,
310                ime: "fun".to_string(),
311                parametri: vec![],
312                telo: Zaporedje(vec![
313                                Vrni(Prirejanje {
314                                    spremenljivka: Spremenljivka { tip: Tip::Real, ime: "vrni".to_string(), naslov: 0, z_odmikom: true }.rc(),
315                                    izraz: Real(1.0).rc(),
316                                }.rc()).rc()
317                ]).rc(),
318                prostor: 0,
319            }.rc());
320        assert_eq!(parser.osnovni([ Ime("fun", 1, 1), Ločilo("(", 1, 4), Ločilo(")", 1, 5)].as_slice()).unwrap(), FunkcijskiKlic { 
321            funkcija: parser.funkcije["fun()"].clone(),
322            spremenljivke: Zaporedje(vec![]).rc(),
323            argumenti: Zaporedje([].to_vec()).rc(),
324        }.rc());
325
326        parser.spremenljivke.insert("a".to_string(), Rc::new(Spremenljivka { tip: Tip::Celo, ime: "a".to_string(), naslov: 0, z_odmikom: false }));
327        assert_eq!(parser.osnovni([ Ime("a", 1, 1)].as_slice()).unwrap(), parser.spremenljivke["a"].clone());
328    }
329
330    #[test]
331    fn pretvorba() {
332        let mut parser = Parser::new();
333        assert_eq!(parser.drevo([ Literal(L::Celo("3", 1, 1)), Operator("kot", 1, 3), Tip("real", 1, 7) ].as_slice()).unwrap(),
334            CeloVReal(Celo(3).rc()).rc());
335        assert_eq!(parser.drevo([ Literal(L::Real("3.0", 1, 1)), Operator("kot", 1, 3), Tip("celo", 1, 7) ].as_slice()).unwrap(),
336            RealVCelo(Real(3.0).rc()).rc());
337        assert_eq!(parser.drevo([ Literal(L::Real("3.0", 1, 1)), Operator("kot", 1, 3), Tip("real", 1, 7) ].as_slice()).unwrap(),
338            Real(3.0).rc());
339    }
340
341    #[test]
342    fn aritmetični() {
343        let mut parser = Parser::new();
344        assert_eq!(parser.drevo([ Literal(L::Celo("3", 1, 1)), Operator("+", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
345            Seštevanje(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
346        assert_eq!(parser.drevo([ Literal(L::Celo("3", 1, 1)), Operator("-", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
347            Odštevanje(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
348        assert_eq!(parser.drevo([ Literal(L::Celo("3", 1, 1)), Operator("*", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
349            Množenje(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
350        assert_eq!(parser.drevo([ Literal(L::Celo("3", 1, 1)), Operator("/", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
351            Deljenje(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
352        assert_eq!(parser.drevo([ Literal(L::Celo("3", 1, 1)), Operator("%", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
353            Modulo(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
354        assert_eq!(parser.drevo([ Literal(L::Celo("3", 1, 1)), Operator("**", 1, 2), Literal(L::Celo("2", 1, 4)) ].as_slice()).unwrap(),
355            Potenca(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
356
357        assert_eq!(parser.drevo("-(3-4)".tokenize().as_slice()).unwrap(), Odštevanje(Tip::Celo, Celo(0).rc(), Odštevanje(Tip::Celo, Celo(3).rc(), Celo(4).rc()).rc()).rc());
358        assert_eq!(parser.drevo("-3".tokenize().as_slice()).unwrap(), Celo(-3).rc());
359        assert_eq!(parser.drevo("-3 * 2".tokenize().as_slice()).unwrap(), Množenje(Tip::Celo, Celo(-3).rc(), Celo(2).rc()).rc());
360        assert_eq!(parser.drevo("3 * -2".tokenize().as_slice()).unwrap(), Množenje(Tip::Celo, Celo(3).rc(), Celo(-2).rc()).rc());
361        assert_eq!(parser.drevo("--1".tokenize().as_slice()).unwrap(), Odštevanje(Tip::Celo, Celo(0).rc(), Celo(-1).rc()).rc());
362        assert_eq!(parser.drevo("2 + -1".tokenize().as_slice()).unwrap(), Seštevanje(Tip::Celo, Celo(2).rc(), Celo(-1).rc()).rc());
363    }
364
365    #[test]
366    fn primerjalni() {
367        let mut parser = Parser::new();
368        assert_eq!(parser.primerjalni([ Literal(L::Celo("3", 1, 1)), Operator("==", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
369            Enako(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
370        assert_eq!(parser.primerjalni([ Literal(L::Celo("3", 1, 1)), Operator("!=", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
371            NiEnako(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
372        assert_eq!(parser.primerjalni([ Literal(L::Celo("3", 1, 1)), Operator("<=", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
373            ManjšeEnako(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
374        assert_eq!(parser.primerjalni([ Literal(L::Celo("3", 1, 1)), Operator(">=", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
375            VečjeEnako(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
376        assert_eq!(parser.primerjalni([ Literal(L::Celo("3", 1, 1)), Operator("<", 1, 2), Literal(L::Celo("2", 1, 3)) ].as_slice()).unwrap(),
377            Manjše(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
378        assert_eq!(parser.primerjalni([ Literal(L::Celo("3", 1, 1)), Operator(">", 1, 2), Literal(L::Celo("2", 1, 4)) ].as_slice()).unwrap(),
379            Večje(Tip::Celo, Celo(3).rc(), Celo(2).rc()).rc());
380    }
381}
slj/parser/izraz.rs

slj/parser/
izraz.rs
